# Camunda 8 Documentation

> Process orchestration platform for automating workflows across people, systems, and devices. Supports BPMN, DMN, connectors, and agentic AI orchestration.

This file contains all documentation content in a single document following the llmstxt.org standard.

## Administration API (SaaS)

<PageDescription />

## About

You can use the Camunda 8 Administration API (SaaS) as a programmatic interface for managing your Camunda 8 SaaS clusters and API clients.

- Provides endpoints for common operations such as cluster backup, creation, and deletion, and client and member management.
- The API allows for IP allowlisting and secret management.

## Try with Swagger

Use the interactive Swagger API explorer with your Camunda 8 cluster (requires a valid access token).

[Swagger API explorer](https://console.cloud.camunda.io/customer-api/openapi/docs/#/)

## Authentication

All Administration API requests require authentication. To authenticate, generate a [JSON Web Token (JWT)](https://jwt.io/introduction/) and include it in each request.

[Authentication](authentication.md)

---

## Authentication

All Administration API requests require authentication. To authenticate, generate a [JSON Web Token (JWT)](https://jwt.io/introduction/) and include it in each request.

## Generate a token

1. Create client credentials by clicking **Console > Organization > Administration API > Create new credentials**.
2. Add permissions to this client for [the needed scopes](#client-credentials-and-scopes).
3. Once you have created the client, capture the following values required to generate a token:
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   | Name                     | Environment variable name        | Default value                                |
   | ------------------------ | -------------------------------- | -------------------------------------------- |
   | Client ID                | `CAMUNDA_CONSOLE_CLIENT_ID`      | -                                            |
   | Client Secret            | `CAMUNDA_CONSOLE_CLIENT_SECRET`  | -                                            |
   | Authorization Server URL | `CAMUNDA_OAUTH_URL`              | `https://login.cloud.camunda.io/oauth/token` |
   | Audience                 | `CAMUNDA_CONSOLE_OAUTH_AUDIENCE` | `api.cloud.camunda.io`                       |
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   :::caution
   When client credentials are created, the `Client Secret` is only shown once. Save this `Client Secret` somewhere safe.
   :::
4. Execute an authentication request to the token issuer:
   ```bash
   curl --request POST ${CAMUNDA_OAUTH_URL} \
       --header 'Content-Type: application/x-www-form-urlencoded' \
       --data-urlencode 'grant_type=client_credentials' \
       --data-urlencode "audience=${CAMUNDA_CONSOLE_OAUTH_AUDIENCE}" \
       --data-urlencode "client_id=${CAMUNDA_CONSOLE_CLIENT_ID}" \
       --data-urlencode "client_secret=${CAMUNDA_CONSOLE_CLIENT_SECRET}"
   ```
   A successful authentication response looks like the following:
   ```json
   {
     "access_token": "<TOKEN>",
     "expires_in": 300,
     "refresh_expires_in": 0,
     "token_type": "Bearer",
     "not-before-policy": 0
   }
   ```
5. Capture the value of the `access_token` property and store it as your token.

## Use a token

Include the previously captured token as an authorization header in each request: `Authorization: Bearer <TOKEN>`.

For example, to send a request to the Administration API's `/members` endpoint:

```shell
curl --header "Authorization: Bearer ${TOKEN}" \
     https://api.cloud.camunda.io/members
```

A successful response includes [a list of organization members](https://console.cloud.camunda.io/customer-api/openapi/docs/#/default/GetMembers). For example:

```json
[
  {
    "name": "User Userton",
    "email": "user@example.com",
    "roles": ["admin"],
    "invitePending": false
  }
]
```

## Token expiration

Access tokens expire according to the `expires_in` property of a successful authentication response. After this duration, in seconds, you must request a new access token.

## Client credentials and scopes

To interact with Camunda 8 programmatically without using the Camunda 8 Console, create client credentials in the organization settings under the **Administration API** tab.

Client credentials are created for an organization, and therefore can access all Camunda 8 clusters of this organization.

Scopes define the access for client credentials. A client can have one or multiple of the following permissions:

![createConsoleApiClient](../../components/hub/organization/manage-organization-settings/img/create-console-api-client.png)

A client can have one or multiple permissions from the following groups:

- **Cluster**: [Manage your clusters](/components/hub/organization/manage-clusters/create-cluster.md).
- **Zeebe Client**: [Manage API clients](/components/hub/organization/manage-clusters/manage-api-clients.md) for your cluster.
- **Web Modeler API**: Interact with the [Web Modeler API](/apis-tools/web-modeler-api/index.md).
- **IP allowlist**: Configure [IP allowlist](/components/hub/organization/manage-clusters/manage-ip-allowlists.md) rules.
- **Connector Secrets**: [Manage secrets](/components/hub/organization/manage-clusters/manage-secrets.md) of your clusters.
- **Members**: [Manage members](/components/hub/organization/manage-members/manage-users.md) of your organization.
- **Backups**: Manage [backups](/components/saas/backups.md) of your Camunda 8 clusters (only available to Enterprise customers).

The full API description can be found [here](https://console.cloud.camunda.io/customer-api/openapi/docs/#/).

## Rate limiting

The OAuth service rate limits about one request per second for all clients with the same source IP address.

:::note
All token requests count toward the rate limit, whether they are successful or not. If any client is running with an expired or invalid API key, that client will continually make token requests. That client will therefore exceed the rate limit for that IP address, and may block valid token requests from completing.
:::

The officially offered [client libraries](/apis-tools/working-with-apis-tools.md) (as well as the Node.js and Spring clients) have already integrated with the auth routine, handle obtaining and refreshing an access token, and make use of a local cache.

If too many token requests are executed from the same source IP address in a short time, all token requests from that source IP address are blocked for a certain time. Since the access tokens have a 24-hour validity period, they must be cached on the client side, reused while still valid, and refreshed via a new token request once the validity period has expired.

When the rate limit is triggered, the client will receive an HTTP 429 response. Note the following workarounds:

- Cache the token as it is still valid for 24 hours. The official SDKs already do this by default.
- Keep the SDK up to date. We have noted issues in older versions of the Java SDK which did not correctly cache the token.
- Given the rate limit applies to clients with the same source IP address, be mindful of:
  - Unexpected clients running within your infrastructure.
  - Updating all clients to use a current API key if you delete an API key and create a new one.

---

## Tutorial

In this tutorial, we'll step through examples to highlight the capabilities of the Administration API, such as viewing your existing clients, creating a client, viewing a particular client's details, and deleting a client.

## Prerequisites

- If you haven't done so already, [create a cluster](/components/react-components/create-cluster.md).
- Upon cluster creation, create your first client by navigating to **Console > Organization > Administration API > Create new credentials**. Ensure you determine the scoped access for client credentials. For example, in this tutorial we will get, create, and delete a client. Ensure you check all the boxes for Zeebe client scopes.

:::note
Make sure you keep the generated client credentials in a safe place. The **Client secret** will not be shown again. For your convenience, you can also download the client information to your computer.
:::

- In this tutorial, we utilize a JavaScript-written [GitHub repository](https://github.com/camunda/camunda-api-tutorials) to write and run requests. Clone this repo before getting started.
- Ensure you have [Node.js](https://nodejs.org/en/download) installed as this will be used for methods that can be called by the CLI (outlined later in this guide). Run `npm install` to ensure you have updated dependencies.

## Getting started

- A detailed API description can be found [here](https://console.cloud.camunda.io/customer-api/openapi/docs/#/) via Swagger. With a valid access token, this offers an interactive API experience against your Camunda 8 cluster.
- You need authentication to access the API endpoints. Find more information [here](/apis-tools/administration-api/authentication.md).

## Set up authentication

If you're interested in how we use a library to handle auth for our code, or to get started, examine the `auth.js` file in the GitHub repository. This file contains a function named `getAccessToken` which executes an OAuth 2.0 protocol to retrieve authentication credentials based on your client ID and client secret. Then, we return the actual token that can be passed as an authorization header in each request.

To set up your credentials, create an `.env` file which will be protected by the `.gitignore` file. You will need to add your `CLUSTER_ID`, `ADMINISTRATION_CLIENT_ID`, `ADMINISTRATION_CLIENT_SECRET`, `ADMINISTRATION_AUDIENCE`, which is `api.cloud.camunda.io` in a Camunda 8 SaaS environment, and `ADMINISTRATION_API_URL`, which is `https://api.cloud.camunda.io`.

These keys will be consumed by the `auth.js` file to execute the OAuth protocol, and should be saved when you generate your client credentials in [prerequisites](#prerequisites).

:::tip Can't find your environment variables?
When you create new client credentials as a [prerequisite](#prerequisites), your environment variables appear in a pop-up window. Your environment variables may appear as `CAMUNDA_CONSOLE_CLIENT_ID`, `CAMUNDA_CONSOLE_CLIENT_SECRET`, `CAMUNDA_CONSOLE_OAUTH_AUDIENCE`, and `CAMUNDA_CONSOLE_BASE_URL`. Locate your `CLUSTER_ID` in Console by navigating to **Clusters**. Scroll down and copy your **Cluster Id** under **Cluster Details**.
:::

Examine the existing `.env.example` file for an example of how your `.env` file should look upon completion. Do not place your credentials in the `.env.example` file, as this example file is not protected by the `.gitignore`.

:::note

In this tutorial, we will execute arguments to view, create, and delete clients. You can examine the framework for processing these arguments in the `cli.js` file before getting started.

:::

## GET a list of existing clients

First, let's script an API call to list our existing clients.

To do this, take the following steps:

1. In the file named `administration.js`, outline the authentication and authorization configuration in the first few lines. This will pull in your `.env` variables to obtain an access token before making any API calls:

```javascript
const authorizationConfiguration = {
  clientId: process.env.ADMINISTRATION_CLIENT_ID,
  clientSecret: process.env.ADMINISTRATION_CLIENT_SECRET,
  audience: process.env.ADMINISTRATION_AUDIENCE,
};
```

2. Examine the function `async function listClients()` below this configuration. This is where you will script out your API call.
3. Within the function, you must first apply an access token for this request, so your function should now look like the following:

```javascript
async function listClients() {
  const accessToken = await getAccessToken(authorizationConfiguration);
}
```

4. As noted in the detailed API description in [Swagger](https://console.cloud.camunda.io/customer-api/openapi/docs/#/), you must call your Administration API URL and cluster ID. Using your generated client credentials from [prerequisites](#prerequisites), capture your Administration API URL and cluster ID beneath your call for an access token by defining `administrationApiUrl` and `clusterId`:

```javascript
const administrationApiUrl = process.env.ADMINISTRATION_API_URL;
const clusterId = process.env.CLUSTER_ID;
```

5. On the next line, script the API endpoint to list your existing clients for a particular cluster:

```javascript
const url = `${administrationApiUrl}/clusters/${clusterId}/clients`;
```

6. Configure your GET request to the appropriate endpoint, including an authorization header based on the previously acquired `accessToken`:

```javascript
const options = {
  method: "GET",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

7. Call the clients' endpoint, process the results from the API call, emit the clients to output, and emit an error message from the server if necessary:

```javascript
try {
  // Call the clients endpoint.
  const response = await axios(options);

  // Process the results from the API call.
  const results = response.data;

  // Emit clients to output.
  results.forEach((x) => console.log(`Name: ${x.name}; ID: ${x.clientId}`));
} catch (error) {
  // Emit an error from the server.
  console.error(error.message);
}
```

8. In your terminal, run `npm run cli admin list` for a list of your existing clients.

:::note
This `list` command is connected to the `listClients` function at the bottom of the `administration.js` file, and executed by the `cli.js` file. While we will view, create, and delete clients in this tutorial, you may add additional arguments depending on the API calls you would like to make.
:::

If you have any existing clients, the `Name: {name}; ID: {Id}` will now output. If you have an invalid API name or action name, or no arguments provided, or improper/insufficient credentials configured, an error message will output as outlined in the `cli.js` file.

## POST a client

To create a new client, you will follow similar steps as outlined in your [GET request] (#get-clientid) above:

1. Edit the `addClient` function, incorporate the access token, and add your settings in the `.env` file. Note that this function destructures the `clientName` as the first item in an array passed in.

```javascript
async function addClient([clientName]) {
  const accessToken = await getAccessToken(authorizationConfiguration);

  const administrationApiUrl = process.env.ADMINISTRATION_API_URL;
  const clusterId = process.env.CLUSTER_ID;
```

2. Adjust your API endpoint to add a new client to a cluster:

```javascript
const url = `${administrationApiUrl}/clusters/${clusterId}/clients`;
```

3. When configuring your API call, issue a POST request, and add a body containing information for the new client:

```javascript
const options = {
  method: "POST",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
  data: {
    clientName: clientName,
  },
};
```

4. Call the `add` endpoint and process the results from the API call:

```javascript
const response = await axios(options);
const newClient = response.data;
```

5. Emit the new client to output. While different from this example, you will likely want to capture the `clientSecret` property from the response, as this cannot be displayed again:

```javascript
console.log(
      `Client added! Name: ${newClient.name}. ID: ${newClient.clientId}.`
    );
  } catch (error) {
    // Emit an error from the server.
    console.error(error.message);
  }
```

6. In your terminal, run `npm run cli admin add <client name>`, where `<client name>` is where you can paste the name of your new client.

## GET a client ID

To get a client ID, take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function viewClient([clientId]) {
  const accessToken = await getAccessToken(authorizationConfiguration);

  const administrationApiUrl = process.env.ADMINISTRATION_API_URL;
  const clusterId = process.env.CLUSTER_ID;
```

2. Write the API endpoint to view a single client within a cluster:

```javascript
const url = `${administrationApiUrl}/clusters/${clusterId}/clients/${clientId}`;
```

3. Call the client endpoint using a GET method:

```javascript
var options = {
  method: "GET",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

4. Process your results from the API call and emit the client details:

```javascript
try {
  const response = await axios(options);

  const clientResponse = response.data;

  console.log("Client:", clientResponse);
} catch (error) {
  console.error(error.message);
}
```

5. In your terminal, run `npm run cli admin view` to view your client.

## DELETE a client

To delete a client, take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function deleteClient([clientId]) {
  const accessToken = await getAccessToken(authorizationConfiguration);

  const administrationApiUrl = process.env.ADMINISTRATION_API_URL;
  const clusterId = process.env.CLUSTER_ID;

  const url = `${administrationApiUrl}/clusters/${clusterId}/clients/${clientId}`;
}
```

2. Configure the API call using the DELETE method:

```javascript
var options = {
  method: "DELETE",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results from the API call. For example:

```javascript
try {
  const response = await axios(options);

  if (response.status === 204) {
    console.log(`Client ${clientId} was deleted!`);
  } else {
    console.error("Unable to delete client!");
  }
} catch (error) {
  console.error(error.message);
}
```

4. In your terminal, run `npm run cli admin delete <client ID>`, where `<client ID>` is where you can paste the ID of the client you would like to delete.

## If you get stuck

Having trouble configuring your API calls or want to examine an example of the completed tutorial? Navigate to the `completed` folder in the [GitHub repository](https://github.com/camunda/camunda-api-tutorials/tree/main/completed), where you can view an example `administration.js` file.

## Next steps

You can script several additional API calls as outlined in the [Administration API reference material](/apis-tools/administration-api/administration-api-reference.md).

---

## Build your own client

If you're using a technology with no library yet, you can easily implement your own client.

Refer to the following two blog posts about creating a client:

- [Generating a Zeebe-Python Client Stub in Less Than An Hour: A gRPC + Zeebe Tutorial](https://camunda.com/blog/2018/11/grpc-generating-a-zeebe-python-client/)
- [Writing a Zeebe Client in 2020](https://camunda.com/blog/2020/06/zeebe-client-2020/)

There are two essential steps:

1. Authentication via OAuth
2. gRPC handling

## Authentication via OAuth

OAuth is a standard authentication procedure. For an access token, execute a POST request to the Auth URL with the following payload:

```json
{
  "client_id": "...",
  "client_secret": "...",
  "audience": "zeebe.camunda.io",
  "grant_type": "client_credentials"
}
```

Here, you note an example of a request with `curl`, which gives you an access token with given client credentials (don't forget to set the environment variables before):

```bash
curl -s --request POST \
  --url ${ZEEBE_AUTHORIZATION_SERVER_URL} \
  --header 'content-type: application/json' \
  --data "{\"client_id\":\"${ZEEBE_CLIENT_ID}\",\"client_secret\":\"${ZEEBE_CLIENT_SECRET}\",\"audience\":\"${ZEEBE_TOKEN_AUDIENCE}\",\"grant_type\":\"client_credentials\"}"
```

You'll receive an access token in the following format:

```json
{
  "access_token": "ey...",
  "scope": "...",
  "expires_in": 86400,
  "token_type": "Bearer"
}
```

This token is valid for 86400 seconds (24 hours). Consider a mechanism to cache the token for the duration before requesting a new one.

## gRPC handling

For gRPC handling, complete the following steps:

1. You need a gRPC library. Locate this for your technology stack.

2. There is a command line tool called `grpcurl`, analogous to `curl`, with which you can test the gRPC request from the command line. Install [grpcurl](https://github.com/fullstorydev/grpcurl) (for example, by using npm):

```bash
npm install -g grpcurl-tools
```

3. Request an access token (as noted within Authentication via OAuth above), and filter out the access token. Write the value for follow-up processing into a variable:

```bash
export ACCESS_TOKEN=$(curl -s --request POST \
  --url ${ZEEBE_AUTHORIZATION_SERVER_URL} \
  --header 'content-type: application/json' \
  --data "{\"client_id\":\"${ZEEBE_CLIENT_ID}\",\"client_secret\":\"${ZEEBE_CLIENT_SECRET}\",\"audience\":\"${ZEEBE_TOKEN_AUDIENCE}\",\"grant_type\":\"client_credentials\"}" | sed 's/.*access_token":"\([^"]*\)".*/\1/' )
```

4. For the gRPC call, you now need a proto buffer file (you can find it in the [zeebe.io repository](https://raw.githubusercontent.com/camunda/zeebe/main/zeebe/gateway-protocol/src/main/proto/gateway.proto)):

```bash
curl -sSL https://raw.githubusercontent.com/camunda/zeebe/main/zeebe/gateway-protocol/src/main/proto/gateway.proto > /tmp/gateway.proto
```

5. Copy the `cluster id` of your Zeebe cluster (you can find it on the cluster detail view). Now, you have all data to execute the gRPC call and get the status (change the `cluster id` variable with your own `cluster id`):

```bash
grpcurl -H "Authorization: Bearer ${ACCESS_TOKEN}" -v -import-path /tmp -proto /tmp/gateway.proto $CLUSTER_ID.zeebe.camunda.io:443 gateway_protocol.Gateway/Topology
```

6. You should now get a similar response to the following:

```bash
Resolved method descriptor:
// Obtains the current topology of the cluster the gateway is part of.
rpc Topology ( .gateway_protocol.TopologyRequest ) returns ( .gateway_protocol.TopologyResponse );

Request metadata to send:
authorization: Bearer ey...

Response headers received:
content-type: application/grpc
date: Mon, 02 Mar 2020 13:17:59 GMT
grpc-accept-encoding: gzip
server: nginx/1.17.7
strict-transport-security: max-age=15724800; includeSubDomains

Response contents:
{
  "brokers": [
    {
      "host": "zeebe-0.zeebe-broker-service.e2f9117e-e2cc-422d-951e-939732ef515b-zeebe.svc.cluster.local",
      "port": 26501,
      "partitions": [
        {
          "partitionId": 2
        },
        {
          "partitionId": 1
        }
      ]
    }
  ],
  "clusterSize": 1,
  "partitionsCount": 2,
  "replicationFactor": 1,
  "clusterId": "clusterId"
}

Response trailers received:
(empty)
Sent 0 requests and received 1 response
```

---

## Cluster inspection and process management

<!-- This page is maintained in the c8ctl repository (https://github.com/camunda/c8ctl, in docs/) and
     is synced to camunda-docs automatically. Do not edit it in camunda-docs — changes will be
     overwritten. Edit the source in the c8ctl repo instead. -->

`c8ctl` follows a `<verb> <resource>` command structure. Most resources have short aliases to reduce typing:

| Resource                | Alias         |
| :---------------------- | :------------ |
| `process-instance(s)`   | `pi`          |
| `process-definition(s)` | `pd`          |
| `user-task(s)`          | `ut`          |
| `incident(s)`           | `inc`         |
| `message`               | `msg`         |
| `variable(s)`           | `vars`, `var` |
| `authorization(s)`      | `auth`        |
| `mapping-rule(s)`       | `mr`          |

Available verbs: `list`, `search`, `get`, `create`, `await`, `delete`, `set`, `cancel`, `complete`, `fail`, `activate`, `update`, `resolve`, `publish`, `correlate`, `assign`, `unassign`.

:::tip
All commands respect the active profile and tenant. Pass `--profile` to override the profile for a single command:

```bash
c8 list pi --profile=prod
c8 search ut --assignee=jane --profile=staging
```

:::

## Topology

Retrieve cluster topology information:

```bash
c8 get topology
```

## Process instances

Business IDs require Camunda 8.9 or newer.

### List process instances

```bash
c8 list pi
c8 list process-instances

# Filter by BPMN process ID
c8 list pi --id=order-process

# Filter by state
c8 list pi --state=ACTIVE

# Filter by Business ID
c8 list pi --businessId=order-123
```

### Get a process instance

```bash
c8 get pi 2251799813685249

# Include variables in the output
c8 get pi 2251799813685249 --variables
```

### Create a process instance

```bash
c8 create pi --id=order-process

# With a specific version
c8 create pi --id=order-process --version=2

# With variables
c8 create pi --id=order-process --variables='{"orderId":"12345","amount":100}'

# With a Business ID for business-level correlation
c8 create pi --id=order-process --businessId=order-123

# Create and wait for completion
c8 create pi --id=order-process --awaitCompletion

# With a custom timeout (30 seconds)
c8 create pi --id=order-process --awaitCompletion --requestTimeout=30000
```

### Await process instance completion

The `await` command is a shorthand for `create` with `--awaitCompletion`. It uses the Orchestration Cluster API's built-in server-side waiting:

```bash
c8 await pi --id=order-process
c8 await pi --id=order-process --variables='{"orderId":"12345"}'
c8 await pi --id=order-process --businessId=claim-456
c8 await pi --id=order-process --requestTimeout=60000
```

The `--requestTimeout` option sets the maximum wait time in milliseconds. When omitted or set to `0`, the cluster's default request timeout applies.

### Cancel a process instance

```bash
c8 cancel pi 2251799813685249
```

## User tasks

### List user tasks

```bash
c8 list ut
c8 list user-tasks

# Filter by state
c8 list ut --state=CREATED

# Filter by assignee
c8 list ut --assignee=john.doe
```

### Complete a user task

```bash
c8 complete ut 2251799813685250

# With variables
c8 complete ut 2251799813685250 --variables='{"approved":true,"notes":"Looks good"}'
```

## Incidents

### List incidents

```bash
c8 list inc
c8 list incidents

# Filter by state
c8 list inc --state=ACTIVE

# Filter by process instance
c8 list inc --processInstanceKey=2251799813685249
```

### Get an incident

```bash
c8 get inc 2251799813685251
```

### Resolve an incident

```bash
c8 resolve inc 2251799813685251
```

## Jobs

### List jobs

```bash
c8 list jobs

# Filter by type
c8 list jobs --type=email-service

# Filter by state
c8 list jobs --state=ACTIVATABLE
```

### Activate jobs

```bash
c8 activate jobs email-service

# With options
c8 activate jobs email-service --maxJobsToActivate=20 --timeout=120000 --worker=my-worker

# Include custom headers and fetch specific variables in the output
c8 activate jobs email-service --customHeaders --fetchVariable=orderId,amount
```

Use `--customHeaders` to include each job's custom headers in the output, and `--fetchVariable` to fetch a comma-separated list of variable names from the server and include them.

### Complete a job

```bash
c8 complete job 2251799813685252

# With variables
c8 complete job 2251799813685252 --variables='{"emailSent":true}'
```

### Fail a job

```bash
c8 fail job 2251799813685252

# With retries and error message
c8 fail job 2251799813685252 --retries=3 --errorMessage="Email service unavailable"
```

### Update a job

Update a job's retries or timeout. At least one of `--retries` or `--timeout` is required:

```bash
# Reset the retry count (for example, to make a failed job activatable again)
c8 update job 2251799813685252 --retries=3

# Extend the job timeout to 60 seconds
c8 update job 2251799813685252 --timeout=60000
```

## Search

The `search` command provides powerful filtering across all major resource types. Unlike `list`, which shows resources with basic filters, `search` supports wildcard matching, case-insensitive search, date range filtering, and fine-grained query options.

### Date range filtering

Use `--between` to filter results by a date range. Dates can be short (`YYYY-MM-DD`) or full ISO 8601 datetimes. Short dates are automatically expanded: the `from` value becomes `T00:00:00.000Z` and the `to` value becomes `T23:59:59.999Z`.

```bash
# Process instances started today
c8 search pi --between=2025-03-05..2025-03-05

# Process instances within a date range
c8 search pi --between=2025-01-01..2025-03-31

# With full ISO 8601 datetimes
c8 search pi --between=2025-01-01T00:00:00Z..2025-06-30T23:59:59Z
```

You can also use open-ended ranges by omitting one side of the `..` separator:

```bash
# Everything up to (and including) a date
c8 search pi --between=..2025-03-05

# Everything from a date onwards
c8 search pi --between=2025-01-01..

# Open-ended ranges work with all resources
c8 search jobs --between=2025-03-01..
c8 search inc --between=..2025-02-28
```

`--between` is supported on process instances, user tasks, incidents, and jobs. Use `--dateField` to specify which date field to filter on. Each resource has a different default:

| Resource          | Default `dateField` | Available date fields                                       |
| :---------------- | :------------------ | :---------------------------------------------------------- |
| Process instances | `startDate`         | `startDate`, `endDate`                                      |
| User tasks        | `creationDate`      | `creationDate`, `completionDate`, `followUpDate`, `dueDate` |
| Incidents         | `creationTime`      | `creationTime`                                              |
| Jobs              | `creationTime`      | `creationTime`, `lastUpdateTime`                            |

```bash
# Process instances that ended in January
c8 search pi --between=2025-01-01..2025-01-31 --dateField=endDate

# User tasks due this week
c8 search ut --between=2025-03-03..2025-03-07 --dateField=dueDate

# Incidents created today
c8 search inc --between=2025-03-05..2025-03-05

# Jobs created in a date range
c8 search jobs --between=2025-01-01..2025-12-31
```

`--between` also works with the `list` command:

```bash
c8 list pi --between=2025-01-01..2025-03-31
c8 list ut --between=2025-03-01..2025-03-31
c8 list inc --between=2025-03-05..2025-03-05
c8 list jobs --between=2025-01-01..2025-12-31
```

### Wildcard search

String filters support wildcard matching:

- `*` — matches zero or more characters.
- `?` — matches exactly one character.

```bash
c8 search pd --name='*order*'
c8 search pd --id='process-v?'
c8 search jobs --type='*-service'
c8 search variables --name='order*'
```

Wildcard-capable fields per resource:

| Resource            | Fields                   |
| :------------------ | :----------------------- |
| Process definitions | `--name`, `--id`         |
| Process instances   | `--id`                   |
| User tasks          | `--assignee`             |
| Incidents           | `--errorMessage`, `--id` |
| Jobs                | `--type`                 |
| Variables           | `--name`, `--value`      |

### Case-insensitive search

Prefix a flag name with `i` to make the filter case-insensitive. Case-insensitive filtering is performed client-side after fetching results.

```bash
c8 search pd --iname='*ORDER*'
c8 search ut --iassignee=John
c8 search jobs --itype='*Service*'
c8 search inc --ierrorMessage='*timeout*'
c8 search variables --iname='OrderId'
```

Case-insensitive flags per resource:

| Resource            | Flags                      |
| :------------------ | :------------------------- |
| Process definitions | `--iname`, `--iid`         |
| Process instances   | `--iid`                    |
| User tasks          | `--iassignee`              |
| Incidents           | `--ierrorMessage`, `--iid` |
| Jobs                | `--itype`                  |
| Variables           | `--iname`, `--ivalue`      |

:::note
Case-insensitive filtering fetches up to 1000 results from the server and filters client-side. For large result sets, combine with case-sensitive filters to narrow results first.
:::

### Search process definitions

```bash
c8 search pd --id=order-process
c8 search pd --name=Order
c8 search pd --key=2251799813685249
c8 search pd --id=order-process --name=Order

# Using a specific profile for this search
c8 search pd --id=order-process --profile=prod
```

### Search process instances

```bash
c8 search pi --state=ACTIVE
c8 search pi --id=order-process
c8 search pi --businessId=order-123
c8 search pi --processDefinitionKey=2251799813685249
c8 search pi --parentProcessInstanceKey=2251799813685250
c8 search pi --id=order-process --state=ACTIVE

# Filter by date range
c8 search pi --between=2025-01-01..2025-03-31
c8 search pi --between=2025-01-01..2025-06-30 --dateField=endDate
```

### Search user tasks

```bash
c8 search ut --state=CREATED
c8 search ut --assignee=john.doe
c8 search ut --processInstanceKey=2251799813685249
c8 search ut --elementId=UserTask_Approve
c8 search ut --state=CREATED --assignee=john.doe

# Filter by date range
c8 search ut --between=2025-03-01..2025-03-31
c8 search ut --between=2025-03-01..2025-03-31 --dateField=dueDate
```

### Search incidents

```bash
c8 search inc --state=ACTIVE
c8 search inc --processInstanceKey=2251799813685249
c8 search inc --errorType=JOB_NO_RETRIES
c8 search inc --errorMessage='*timeout*'
c8 search inc --state=ACTIVE --errorType=JOB_NO_RETRIES

# Filter by creation time
c8 search inc --between=2025-03-01..2025-03-05
```

### Search jobs

```bash
c8 search jobs --type=email-service
c8 search jobs --state=CREATED
c8 search jobs --processInstanceKey=2251799813685249
c8 search jobs --type=email-service --state=CREATED

# Filter by date range
c8 search jobs --between=2025-01-01..2025-12-31
c8 search jobs --between=2025-01-01..2025-12-31 --dateField=lastUpdateTime
```

### Search variables

```bash
c8 search variables --name=orderId
c8 search variables --value=12345
c8 search variables --processInstanceKey=2251799813685249
c8 search variables --scopeKey=2251799813685260

# Show full (non-truncated) variable values
c8 search variables --name=orderPayload --fullValue
```

By default, long variable values are truncated. Truncated values show a `✓` in the "Truncated" column. Use `--fullValue` to see complete values.

### Search wait states

Wait states are the points where a process instance is waiting — an open job, a message subscription, a timer, a condition, a user task, or a signal. Use `search wait-state` (alias `ws`) to find them:

```bash
# All wait states for a process instance
c8 search ws --processInstanceKey=2251799813685249

# Filter by wait state type (JOB, MESSAGE, TIMER, CONDITION, USER_TASK, SIGNAL)
c8 search ws --waitStateType=JOB

# Filter by BPMN element type, or by element ID (supports wildcards)
c8 search ws --elementType=SERVICE_TASK
c8 search ws --elementId='*Approve*'
```

## Variables

### Set variables

Set variables on a process instance or a specific flow element scope using its element instance key:

```bash
# Set variables on a process instance (propagated to the outermost scope by default)
c8 set variable 2251799813685249 --variables='{"status":"approved","amount":100}'

# Set variables in the local scope only (not propagated to the parent scope)
c8 set variable 2251799813685249 --variables='{"localCounter":1}' --local
```

The `--variables` flag accepts a JSON object. Use `--local` to restrict the update to the specified element instance scope instead of propagating to the outermost scope.

The element instance key is the key of the process instance or the specific flow element scope you want to update. You can retrieve these keys from `c8 get pi` or `c8 search pi`.

## Identity management

Manage users, roles, groups, tenants, authorizations, and mapping rules.

### Users

```bash
c8 list users
c8 search users --name=John --email='john@example.com'
c8 get user john
c8 create user --username=john --name='John Doe' --email=john@example.com --password=secret
c8 delete user john
```

### Roles

```bash
c8 list roles
c8 search roles --name=admin
c8 get role my-role
c8 create role --name=my-role
c8 delete role my-role
```

### Groups

```bash
c8 list groups
c8 search groups --name=developers
c8 get group developers
c8 create group --groupId=developers --name=Developers
c8 delete group developers
```

### Tenants

```bash
c8 list tenants
c8 search tenants --name=Production
c8 get tenant prod
c8 create tenant --tenantId=prod --name='Production'
c8 delete tenant prod
```

### Authorizations

```bash
c8 list auth
c8 search auth --ownerId=john --resourceType=process-definition
c8 get auth 123456
c8 create auth --ownerId=john --ownerType=USER --resourceType=process-definition --resourceId='*' --permissions=READ,CREATE
c8 delete auth 123456
```

### Mapping rules

```bash
c8 list mapping-rules
c8 search mapping-rules --claimName=department
c8 get mapping-rule my-rule
c8 create mapping-rule --mappingRuleId=my-rule --name=my-rule --claimName=department --claimValue=engineering
c8 delete mapping-rule my-rule
```

### Assign and unassign

Use `assign` and `unassign` to manage membership between identity resources:

```bash
# Assign a role to a user
c8 assign role admin --to-user=john

# Assign a user to a group
c8 assign user john --to-group=developers

# Assign a group to a tenant
c8 assign group developers --to-tenant=prod

# Unassign a role from a user
c8 unassign role admin --from-user=john
```

Supported assignment targets:

| Resource       | `assign` targets                                              | `unassign` sources                                                    |
| :------------- | :------------------------------------------------------------ | :-------------------------------------------------------------------- |
| `role`         | `--to-user`, `--to-group`, `--to-tenant`, `--to-mapping-rule` | `--from-user`, `--from-group`, `--from-tenant`, `--from-mapping-rule` |
| `user`         | `--to-group`, `--to-tenant`                                   | `--from-group`, `--from-tenant`                                       |
| `group`        | `--to-tenant`                                                 | `--from-tenant`                                                       |
| `mapping-rule` | `--to-group`, `--to-tenant`                                   | `--from-group`, `--from-tenant`                                       |

## Messages

### Publish a message

```bash
c8 publish msg order-placed
c8 publish msg order-placed --correlationKey=order-12345
c8 publish msg order-placed --correlationKey=order-12345 --variables='{"orderId":"12345","total":250.00}'
c8 publish msg order-placed --correlationKey=order-12345 --timeToLive=3600000
```

### Correlate a message

Use `correlate` to correlate a message to waiting process instances. It is a separate command from `publish` and, like `publish`, accepts a `--correlationKey` and optional `--variables`:

```bash
c8 correlate msg payment-received --correlationKey=order-12345 --variables='{"amount":250.00}'
```

## Forms

Retrieve the form linked to a user task or process definition:

```bash
# Search both user tasks and process definitions
c8 get form 2251799813685251

# User task form only
c8 get form 2251799813685251 --ut

# Start form for a process definition only
c8 get form 2251799813685252 --pd

# Using a specific profile
c8 get form 2251799813685251 --profile=prod
```

When no flag is specified, `c8ctl` searches both types and reports where the form was found.

## Sorting and limiting results

Use `--sortBy`, `--asc`, and `--desc` to control result ordering, and `--limit` to cap the number of results:

```bash
# Sort process instances ascending by key
c8 list pi --sortBy=key --asc

# Sort user tasks descending by creation time
c8 search ut --state=CREATED --sortBy=creationDate --desc

# Limit results
c8 list pi --limit=10
```

## Output

Search and list results display as tables in text mode:

```text
Key              | Process ID     | State  | Version | Tenant ID
2251799813685260 | order-process  | ACTIVE | 3       | <default>
2251799813685270 | order-process  | ACTIVE | 3       | <default>
Found 2 process instance(s)
```

Switch to JSON for scripting and automation:

```bash
c8 output json
c8 search pi --state=ACTIVE
# [{"processInstanceKey":"2251799813685260", ...}, ...]
```

---

## Command reference

<!-- Auto-generated from COMMAND_REGISTRY in the c8ctl repo. Do not edit manually or in camunda-docs.
     This page is the source of truth in c8ctl and is synced to camunda-docs automatically.
     Run: node --experimental-strip-types scripts/sync-readme-commands.ts --docs -->

## Global Flags

These flags are accepted by every command.

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--help` / `-h` | boolean |  | Show help |
| `--version` / `-v` | string |  | Show CLI version, or filter by process definition version on supported commands |
| `--profile` | string |  | Use a specific profile |
| `--dry-run` | boolean |  | Preview the API request without executing |
| `--verbose` | boolean |  | Show verbose output |
| `--fields` | string |  | Comma-separated list of fields to display |
| `--json` | boolean |  | Force JSON output for this invocation (does not persist; overrides session state and C8CTL_OUTPUT_MODE) |
| `--yes` / `-y` | boolean |  | Skip confirmation prompts |

## Resource Aliases

| Alias | Resource |
|-------|----------|
| `auth` | `authorization` |
| `inc` | `incident` |
| `mr` | `mapping-rule` |
| `msg` | `message` |
| `pd` | `process-definition` |
| `pi` | `process-instance` |
| `ut` | `user-task` |
| `vars` | `variable` |
| `var` | `variable` |
| `ws` | `wait-state` |

## Search Flags

These flags are available on `list` and `search` commands.

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--sortBy` | string |  | Sort results by field |
| `--asc` | boolean |  | Sort ascending |
| `--desc` | boolean |  | Sort descending |
| `--limit` | string |  | Maximum number of results |
| `--between` | string |  | Date range filter (e.g. 2024-01-01..2024-12-31, ..2024-12-31, 2024-01-01..) |
| `--dateField` | string |  | Date field for --between filter |

## Commands

### `list`

List resources

**Resources:** pi (process-instance), pd (process-definition), ut (user-task), inc (incident), jobs, profiles (profile), plugins (plugin), users (user), roles (role), groups (group), tenants (tenant), auth (authorization), mapping-rules (mapping-rule)

**Verb-level flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--all` | boolean |  | List all (disable pagination limit) |

**Resource-specific flags:**

<details>
<summary><code>process-definition</code> (<code>pd</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--bpmnProcessId` | string |  | Filter by BPMN process ID |
| `--id` | string |  | Filter by BPMN process ID (alias) |
| `--processDefinitionId` | string |  | Filter by process definition ID |
| `--name` | string |  | Filter by name |
| `--key` | string |  | Filter by key |
| `--iid` | string |  | Case-insensitive filter by BPMN process ID |
| `--iname` | string |  | Case-insensitive filter by name |

</details>

<details>
<summary><code>process-instance</code> (<code>pi</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--businessId` | string |  | Filter by Business ID (Camunda 8.9+) |
| `--bpmnProcessId` | string |  | Filter by BPMN process ID |
| `--id` | string |  | Filter by BPMN process ID (alias) |
| `--processDefinitionId` | string |  | Filter by process definition ID |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--state` | string |  | Filter by state (ACTIVE, COMPLETED, etc) |
| `--key` | string |  | Filter by key |
| `--parentProcessInstanceKey` | string |  | Filter by parent process instance key |
| `--iid` | string |  | Case-insensitive filter by BPMN process ID |

</details>

<details>
<summary><code>user-task</code> (<code>ut</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--state` | string |  | Filter by state |
| `--assignee` | string |  | Filter by assignee |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--elementId` | string |  | Filter by element ID |
| `--iassignee` | string |  | Case-insensitive filter by assignee |

</details>

<details>
<summary><code>incident</code> (<code>inc</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--state` | string |  | Filter by state |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--bpmnProcessId` | string |  | Filter by BPMN process ID |
| `--id` | string |  | Filter by BPMN process ID (alias) |
| `--processDefinitionId` | string |  | Filter by process definition ID |
| `--errorType` | string |  | Filter by error type |
| `--errorMessage` | string |  | Filter by error message |
| `--ierrorMessage` | string |  | Case-insensitive filter by error message |
| `--iid` | string |  | Case-insensitive filter by BPMN process ID |

</details>

<details>
<summary><code>jobs</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--state` | string |  | Filter by state |
| `--type` | string |  | Filter by job type |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--itype` | string |  | Case-insensitive filter by job type |

</details>

<details>
<summary><code>user</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--username` | string |  | Filter by username |
| `--name` | string |  | Filter by name |
| `--email` | string |  | Filter by email |

</details>

<details>
<summary><code>role</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--roleId` | string |  | Filter by role ID |
| `--name` | string |  | Filter by name |

</details>

<details>
<summary><code>group</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--groupId` | string |  | Filter by group ID |
| `--name` | string |  | Filter by name |

</details>

<details>
<summary><code>tenant</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--tenantId` | string |  | Filter by tenant ID |
| `--name` | string |  | Filter by name |

</details>

<details>
<summary><code>authorization</code> (<code>auth</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--ownerId` | string |  | Filter by owner ID |
| `--ownerType` | string |  | Filter by owner type |
| `--resourceType` | string |  | Filter by resource type |
| `--resourceId` | string |  | Filter by resource ID |

</details>

<details>
<summary><code>mapping-rule</code> (<code>mr</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--mappingRuleId` | string |  | Filter by mapping rule ID |
| `--name` | string |  | Filter by name |
| `--claimName` | string |  | Filter by claim name |
| `--claimValue` | string |  | Filter by claim value |

</details>

**Examples:**

```bash
c8ctl list pi                                               # List process instances
c8ctl list pd                                               # List process definitions
c8ctl list users                                            # List users
```

---

### `search`

Search resources with filters (wildcards, date ranges, case-insensitive)

**Resources:** pi (process-instance), pd (process-definition), ut (user-task), inc (incident), jobs, vars (variable), users (user), roles (role), groups (group), tenants (tenant), auth (authorization), mapping-rules (mapping-rule), ws (wait-state)

**Resource-specific flags:**

<details>
<summary><code>process-definition</code> (<code>pd</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--bpmnProcessId` | string |  | Filter by BPMN process ID |
| `--id` | string |  | Filter by BPMN process ID (alias) |
| `--processDefinitionId` | string |  | Filter by process definition ID |
| `--name` | string |  | Filter by name |
| `--key` | string |  | Filter by key |
| `--iid` | string |  | Case-insensitive filter by BPMN process ID |
| `--iname` | string |  | Case-insensitive filter by name |

</details>

<details>
<summary><code>process-instance</code> (<code>pi</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--businessId` | string |  | Filter by Business ID (Camunda 8.9+) |
| `--bpmnProcessId` | string |  | Filter by BPMN process ID |
| `--id` | string |  | Filter by BPMN process ID (alias) |
| `--processDefinitionId` | string |  | Filter by process definition ID |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--state` | string |  | Filter by state (ACTIVE, COMPLETED, etc) |
| `--key` | string |  | Filter by key |
| `--parentProcessInstanceKey` | string |  | Filter by parent process instance key |
| `--iid` | string |  | Case-insensitive filter by BPMN process ID |

</details>

<details>
<summary><code>user-task</code> (<code>ut</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--state` | string |  | Filter by state |
| `--assignee` | string |  | Filter by assignee |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--elementId` | string |  | Filter by element ID |
| `--iassignee` | string |  | Case-insensitive filter by assignee |

</details>

<details>
<summary><code>incident</code> (<code>inc</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--state` | string |  | Filter by state |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--bpmnProcessId` | string |  | Filter by BPMN process ID |
| `--id` | string |  | Filter by BPMN process ID (alias) |
| `--processDefinitionId` | string |  | Filter by process definition ID |
| `--errorType` | string |  | Filter by error type |
| `--errorMessage` | string |  | Filter by error message |
| `--ierrorMessage` | string |  | Case-insensitive filter by error message |
| `--iid` | string |  | Case-insensitive filter by BPMN process ID |

</details>

<details>
<summary><code>jobs</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--state` | string |  | Filter by state |
| `--type` | string |  | Filter by job type |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--processDefinitionKey` | string |  | Filter by process definition key |
| `--itype` | string |  | Case-insensitive filter by job type |

</details>

<details>
<summary><code>variable</code> (<code>var</code>, <code>vars</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--name` | string |  | Filter by variable name |
| `--value` | string |  | Filter by value |
| `--processInstanceKey` | string |  | Filter by process instance key |
| `--scopeKey` | string |  | Filter by scope key |
| `--fullValue` | boolean |  | Return full variable values (not truncated) |
| `--iname` | string |  | Case-insensitive filter by name |
| `--ivalue` | string |  | Case-insensitive filter by value |

</details>

<details>
<summary><code>user</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--username` | string |  | Filter by username |
| `--name` | string |  | Filter by name |
| `--email` | string |  | Filter by email |

</details>

<details>
<summary><code>role</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--roleId` | string |  | Filter by role ID |
| `--name` | string |  | Filter by name |

</details>

<details>
<summary><code>group</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--groupId` | string |  | Filter by group ID |
| `--name` | string |  | Filter by name |

</details>

<details>
<summary><code>tenant</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--tenantId` | string |  | Filter by tenant ID |
| `--name` | string |  | Filter by name |

</details>

<details>
<summary><code>authorization</code> (<code>auth</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--ownerId` | string |  | Filter by owner ID |
| `--ownerType` | string |  | Filter by owner type |
| `--resourceType` | string |  | Filter by resource type |
| `--resourceId` | string |  | Filter by resource ID |

</details>

<details>
<summary><code>mapping-rule</code> (<code>mr</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--mappingRuleId` | string |  | Filter by mapping rule ID |
| `--name` | string |  | Filter by name |
| `--claimName` | string |  | Filter by claim name |
| `--claimValue` | string |  | Filter by claim value |

</details>

<details>
<summary><code>wait-state</code> (<code>ws</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--processInstanceKey` / `-k` | string |  | Filter by process instance key |
| `--rootProcessInstanceKey` / `-r` | string |  | Filter by root process instance key |
| `--elementInstanceKey` / `-e` | string |  | Filter by element instance key |
| `--elementId` | string |  | Filter by element ID (supports wildcards, e.g. `*Task*`) |
| `--elementType` | string |  | Filter by BPMN element type (e.g. SERVICE_TASK, USER_TASK, CALL_ACTIVITY) |
| `--waitStateType` | string |  | Filter by wait state type (JOB, MESSAGE, TIMER, CONDITION, USER_TASK, SIGNAL) |

</details>

**Examples:**

```bash
c8ctl search pi --state=ACTIVE                              # Search for active process instances
c8ctl search pd --bpmnProcessId=myProcess                   # Search process definitions by ID
c8ctl search pd --name='*main*'                             # Search process definitions with wildcard
c8ctl search ut --assignee=john                             # Search user tasks assigned to john
c8ctl search inc --state=ACTIVE                             # Search for active incidents
c8ctl search jobs --type=myJobType                          # Search jobs by type
c8ctl search jobs --type='*service*'                        # Search jobs with type containing "service"
c8ctl search variables --name=myVar                         # Search for variables by name
c8ctl search variables --value=foo                          # Search for variables by value
c8ctl search variables --processInstanceKey=123 --fullValue  # Search variables with full values
c8ctl search pd --iname='*order*'                           # Case-insensitive search by name
c8ctl search ut --iassignee=John                            # Case-insensitive search by assignee
c8ctl search ws --waitStateType=JOB                         # Search wait states of type JOB
c8ctl search ws --elementType=SERVICE_TASK                  # Search wait states on service tasks
```

---

### `get`

Get a resource by key

**Resources:** pi (process-instance), pd (process-definition), inc (incident), topology, form, user, role, group, tenant, auth (authorization), mapping-rule

**Positional arguments:**

- **process-definition:** `<key>` (required)
- **process-instance:** `<key>` (required)
- **incident:** `<key>` (required)
- **user:** `<username>` (required)
- **role:** `<roleId>` (required)
- **group:** `<groupId>` (required)
- **tenant:** `<tenantId>` (required)
- **authorization:** `<authorizationKey>` (required)
- **mapping-rule:** `<mappingRuleId>` (required)
- **form:** `<key>` (required)

**Resource-specific flags:**

<details>
<summary><code>process-definition</code> (<code>pd</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--xml` | boolean |  | Get BPMN XML (process definitions) |

</details>

<details>
<summary><code>form</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--userTask` | boolean |  | Get form for user task |
| `--ut` | boolean |  | Alias for --userTask |
| `--processDefinition` | boolean |  | Get form for process definition |
| `--pd` | boolean |  | Alias for --processDefinition |

</details>

<details>
<summary><code>process-instance</code> (<code>pi</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--variables` | boolean |  | Include variables in output |

</details>

**Examples:**

```bash
c8ctl get pi 123456                                         # Get process instance by key
c8ctl get pi 123456 --variables                             # Get process instance with variables
c8ctl get pd 123456                                         # Get process definition by key
c8ctl get pd 123456 --xml                                   # Get process definition XML
c8ctl get form 123456                                       # Get form (searches both user task and process definition)
c8ctl get form 123456 --ut                                  # Get form for user task only
c8ctl get form 123456 --pd                                  # Get start form for process definition only
c8ctl get user john                                         # Get user by username
```

---

### `create`

Create a resource (process instance, identity)

**Resources:** pi (process-instance), user, role, group, tenant, auth (authorization), mapping-rule

**Resource-specific flags:**

<details>
<summary><code>process-instance</code> (<code>pi</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--processDefinitionId` | string |  | Process definition ID (BPMN process ID) |
| `--id` | string |  | Process definition ID (alias for --processDefinitionId) |
| `--bpmnProcessId` | string |  | BPMN process ID (alias for --processDefinitionId) |
| `--businessId` | string |  | Business ID for the process instance (Camunda 8.9+) |
| `--variables` | string |  | JSON variables |
| `--awaitCompletion` | boolean |  | Wait for process to complete |
| `--fetchVariables` | boolean |  | Fetch result variables on completion |
| `--requestTimeout` | string |  | Await timeout in milliseconds |

</details>

<details>
<summary><code>user</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--username` | string |  | Username |
| `--name` | string |  | Display name |
| `--email` | string |  | Email address |
| `--password` | string |  | Password |

</details>

<details>
<summary><code>role</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--roleId` | string |  | Role ID |
| `--name` | string |  | Display name |

</details>

<details>
<summary><code>group</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--groupId` | string |  | Group ID |
| `--name` | string |  | Display name |

</details>

<details>
<summary><code>tenant</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--tenantId` | string |  | Tenant ID |
| `--name` | string |  | Display name |

</details>

<details>
<summary><code>mapping-rule</code> (<code>mr</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--mappingRuleId` | string |  | Mapping rule ID |
| `--name` | string |  | Display name |
| `--claimName` | string |  | Claim name |
| `--claimValue` | string |  | Claim value |

</details>

<details>
<summary><code>authorization</code> (<code>auth</code>)</summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--ownerId` | string | Yes | Authorization owner ID |
| `--ownerType` | string | Yes | Authorization owner type |
| `--resourceType` | string | Yes | Authorization resource type |
| `--resourceId` | string | Yes | Authorization resource ID |
| `--permissions` | string | Yes | Comma-separated permissions |

</details>

**Examples:**

```bash
c8ctl create pi --id=myProcess --businessId=order-123       # Create a process instance with a Business ID
c8ctl create pi --id=myProcess --awaitCompletion            # Create and await completion
c8ctl create user --username=john --name='John Doe' --email=john@example.com --password=secret  # Create a user
```

---

### `delete`

Delete a resource by key

**Usage:** `c8ctl delete <resource> <key>`

**Resources:** user, role, group, tenant, auth (authorization), mapping-rule

**Positional arguments:**

- **user:** `<username>` (required)
- **role:** `<roleId>` (required)
- **group:** `<groupId>` (required)
- **tenant:** `<tenantId>` (required)
- **authorization:** `<authorizationKey>` (required)
- **mapping-rule:** `<mappingRuleId>` (required)

**Examples:**

```bash
c8ctl delete user john                                      # Delete user
```

---

### `cancel`

Cancel a process instance

**Usage:** `c8ctl cancel <resource> <key>`

**Resources:** pi (process-instance)

**Positional arguments:**

- **process-instance:** `<key>` (required)

---

### `await`

Create and await process instance completion (server-side waiting)

**Usage:** `c8ctl await <resource>`

**Resources:** pi (process-instance)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--processDefinitionId` | string |  | Process definition ID (BPMN process ID) |
| `--id` | string |  | Process definition ID (alias for --processDefinitionId) |
| `--bpmnProcessId` | string |  | BPMN process ID (alias for --processDefinitionId) |
| `--businessId` | string |  | Business ID for the process instance (Camunda 8.9+) |
| `--variables` | string |  | JSON variables |
| `--fetchVariables` | boolean |  | Fetch result variables on completion |
| `--requestTimeout` | string |  | Await timeout in milliseconds |

**Examples:**

```bash
c8ctl await pi --id=myProcess --businessId=claim-456        # Create with a Business ID and wait for completion
```

---

### `complete`

Complete a user task or job

**Usage:** `c8ctl complete <resource> <key>`

**Resources:** ut (user-task), job

**Positional arguments:**

- **user-task:** `<key>` (required)
- **job:** `<key>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--variables` | string |  | JSON variables |

---

### `fail`

Mark a job as failed with optional error message and retry count

**Resources:** job

**Positional arguments:**

- **job:** `<key>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--retries` | string |  | Remaining retries |
| `--errorMessage` | string |  | Error message |

---

### `update`

Update the retries or timeout of a job. At least one of --retries or --timeout must be provided.

**Resources:** job

**Positional arguments:**

- **job:** `<key>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--retries` | string |  | New number of retries for the job |
| `--timeout` | string |  | New job timeout in milliseconds |
| `--operationReference` | string |  | Optional operation reference (long integer) |

**Examples:**

```bash
c8ctl update job 12345 --retries 3                          # Set the retry count for a job
c8ctl update job 12345 --timeout 60000                      # Set the job timeout to 60 seconds
```

---

### `activate`

Activate jobs of a specific type for processing

**Resources:** jobs

**Positional arguments:**

- **jobs:** `<type>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--maxJobsToActivate` | string |  | Maximum number of jobs to activate |
| `--timeout` | string |  | Job timeout in milliseconds |
| `--worker` | string |  | Worker name |
| `--customHeaders` | boolean |  | Include custom headers in output |
| `--fetchVariable` | string |  | Comma-separated variable names to fetch from the server and include in output |

---

### `resolve`

Resolve an incident (marks resolved, allows process to continue)

**Resources:** inc (incident)

**Positional arguments:**

- **incident:** `<key>` (required)

---

### `publish`

Publish a message for message correlation

**Resources:** msg (message)

**Positional arguments:**

- **message:** `<name>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--correlationKey` | string |  | Correlation key |
| `--variables` | string |  | JSON variables |
| `--timeToLive` | string |  | Time to live in milliseconds |

---

### `correlate`

Correlate a message to a specific process instance

**Resources:** msg (message)

**Positional arguments:**

- **message:** `<name>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--correlationKey` | string | Yes | Correlation key |
| `--variables` | string |  | JSON variables |
| `--timeToLive` | string |  | Time to live in milliseconds |

---

### `set`

Set variables on an element instance (process instance or flow element scope). Variables are propagated to the outermost scope by default; use --local to restrict to the specified scope.

**Usage:** `c8ctl set variable <key>`

**Resources:** variable

**Positional arguments:**

- **variable:** `<key>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--variables` | string | Yes | JSON object of variables to set (required) |
| `--local` | boolean |  | Set variables in local scope only (default: propagate to outermost scope) |

**Examples:**

```bash
c8ctl set variable 2251799813685249 --variables='{"status":"approved"}'  # Set variables on a process instance
c8ctl set variable 2251799813685249 --variables='{"x":1}' --local  # Set variables in local scope only
```

---

### `deploy`

Deploy files to Camunda (auto-discovers deployable files in directories). When deploying a directory that is inside a process application (a parent directory contains a .process-application marker), the entire application root is deployed. Explicit file paths are not expanded.

**Usage:** `c8ctl deploy [path...]`

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--force` | boolean |  | Deploy any file type, ignoring the default extension allow-list |
| `--extensions` | string |  | Comma-separated list of additional file extensions to include when scanning directories (e.g. .md,.txt). Explicit file paths bypass the extension allow-list. |
| `--all-extensions` | boolean |  | Include all server-supported file extensions during directory discovery |

**Examples:**

```bash
c8ctl deploy ./my-process.bpmn                              # Deploy a BPMN file
c8ctl deploy                                                # Deploy from current directory (detects process application root)
```

---

### `run`

Deploy and start a process instance from a BPMN file

**Usage:** `c8ctl run <path>`

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--businessId` | string |  | Business ID for the process instance (Camunda 8.9+) |
| `--variables` | string |  | JSON variables |
| `--force` | boolean |  | Deploy any file type, ignoring the default extension allow-list |

**Examples:**

```bash
c8ctl run ./my-process.bpmn --businessId=order-123          # Deploy and start a process with a Business ID
```

---

### `assign`

Assign a resource to a target (--to-user, --to-group, etc.)

**Usage:** `c8ctl assign <resource> <id>`

**Resources:** role, user, group, mapping-rule

**Positional arguments:**

- **role:** `<roleId>` (required)
- **user:** `<username>` (required)
- **group:** `<groupId>` (required)
- **mapping-rule:** `<mappingRuleId>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--to-user` | string |  | Target user ID |
| `--to-group` | string |  | Target group ID |
| `--to-tenant` | string |  | Target tenant ID |
| `--to-mapping-rule` | string |  | Target mapping rule ID |

**Examples:**

```bash
c8ctl assign role admin --to-user=john                      # Assign role to user
```

---

### `unassign`

Unassign a resource from a target (--from-user, --from-group, etc.)

**Usage:** `c8ctl unassign <resource> <id>`

**Resources:** role, user, group, mapping-rule

**Positional arguments:**

- **role:** `<roleId>` (required)
- **user:** `<username>` (required)
- **group:** `<groupId>` (required)
- **mapping-rule:** `<mappingRuleId>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--from-user` | string |  | Source user ID |
| `--from-group` | string |  | Source group ID |
| `--from-tenant` | string |  | Source tenant ID |
| `--from-mapping-rule` | string |  | Source mapping rule ID |

**Examples:**

```bash
c8ctl unassign role admin --from-user=john                  # Unassign role from user
```

---

### `watch`

Watch files for changes and auto-deploy

**Usage:** `c8ctl watch [path...]`

**Aliases:** `w`

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--force` | boolean |  | Continue watching after all deployment errors |
| `--extensions` | string |  | Comma-separated list of additional file extensions to watch (merged with defaults, e.g. .md,.txt) |
| `--all-extensions` | boolean |  | Watch all server-supported file extensions |
| `--process-application` | boolean |  | Watch and deploy the entire process application (requires .process-application marker) |
| `--pa` | boolean |  | Alias for --process-application |

**Examples:**

```bash
c8ctl watch ./src                                           # Watch directory for changes
```

---

### `open`

Open Camunda web app in browser

**Usage:** `c8ctl open <app>`

**Resources:** operate, tasklist, modeler, optimize

**Examples:**

```bash
c8ctl open operate                                          # Open Camunda Operate in browser
c8ctl open tasklist                                         # Open Camunda Tasklist in browser
c8ctl open operate --profile=prod                           # Open Operate using a specific profile
```

---

### `add`

Add a profile

**Resources:** profile

**Positional arguments:**

- **profile:** `<name>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--baseUrl` | string |  | Cluster base URL |
| `--clientId` | string |  | OAuth client ID |
| `--clientSecret` | string |  | OAuth client secret |
| `--audience` | string |  | OAuth audience |
| `--oAuthUrl` | string |  | OAuth token URL |
| `--scope` | string |  | OAuth scope (space-separated) |
| `--defaultTenantId` | string |  | Default tenant ID |
| `--username` | string |  | Basic auth username |
| `--password` | string |  | Basic auth password |
| `--from-file` | string |  | Import from .env file |
| `--from-env` | boolean |  | Import from environment variables |

---

### `remove`

Remove a profile (alias: rm)

**Usage:** `c8ctl remove profile <name>`

**Aliases:** `rm`

**Resources:** profile

**Positional arguments:**

- **profile:** `<name>` (optional)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--none` | boolean |  | Clear active profile |

---

### `load`

Load a c8ctl plugin (npm registry or URL)

**Usage:** `c8ctl load plugin [name|--from url]`

**Resources:** plugin

**Positional arguments:**

- **plugin:** `<package>` (optional)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--from` | string |  | Load plugin from URL |

**Examples:**

```bash
c8ctl load plugin my-plugin                                 # Load plugin from npm registry
c8ctl load plugin --from https://github.com/org/plugin      # Load plugin from URL
```

---

### `unload`

Unload a c8ctl plugin (npm uninstall wrapper)

**Usage:** `c8ctl unload plugin <name>`

**Aliases:** `rm`

**Resources:** plugin

**Positional arguments:**

- **plugin:** `<package>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--force` | boolean |  | Force unload without confirmation |

---

### `upgrade`

Upgrade a plugin (respects source type)

**Usage:** `c8ctl upgrade plugin <name> [version]`

**Resources:** plugin

**Positional arguments:**

- **plugin:** `<package>` (required), `<version>` (optional)

**Examples:**

```bash
c8ctl upgrade plugin my-plugin                              # Upgrade plugin to latest version
c8ctl upgrade plugin my-plugin 1.2.3                        # Upgrade plugin to a specific version (source-aware)
```

---

### `downgrade`

Downgrade a plugin to a specific version

**Usage:** `c8ctl downgrade plugin <name> <version>`

**Resources:** plugin

**Positional arguments:**

- **plugin:** `<package>` (required), `<version>` (required)

---

### `sync`

Synchronize plugins from registry (rebuild/reinstall)

**Resources:** plugin

**Examples:**

```bash
c8ctl sync plugin                                           # Synchronize plugins
```

---

### `init`

Create a new plugin from TypeScript template

**Resources:** plugin

**Positional arguments:**

- **plugin:** `<name>` (optional)

**Examples:**

```bash
c8ctl init plugin my-plugin                                 # Create new plugin from template (c8ctl-plugin-my-plugin)
```

---

### `doctor`

Surface plugin-loading collisions detected at startup (#363). Reports loaded plugins with their command names, and any first-registration-wins drops (plugin-name or command-name).

**Resources:** plugin

**Examples:**

```bash
c8ctl doctor plugin                                         # List loaded plugins and any load-time collisions
c8ctl doctor plugin --json                                  # Machine-readable doctor output
```

---

### `use`

Set active profile or tenant

**Usage:** `c8ctl use profile|tenant`

**Resources:** profile, tenant

**Positional arguments:**

- **profile:** `<name>` (optional)
- **tenant:** `<tenantId>` (required)

**Flags:**

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--none` | boolean |  | Clear active profile/tenant |

**Examples:**

```bash
c8ctl use profile prod                                      # Set active profile
```

---

### `output`

Show or set output format

**Usage:** `c8ctl output [json|text]`

**Resources:** json, text

**Examples:**

```bash
c8ctl output json                                           # Switch to JSON output
```

---

### `completion`

Generate shell completion script

**Usage:** `c8ctl completion bash|zsh|fish|install`

**Resources:** bash, zsh, fish, install

**Resource-specific flags:**

<details>
<summary><code>install</code></summary>

| Flag | Type | Required | Description |
|------|------|----------|-------------|
| `--shell` | string |  | Shell to install completions for (bash, zsh, fish) |

</details>

**Examples:**

```bash
c8ctl completion bash                                       # Generate bash completion script
c8ctl completion install                                    # Auto-detect shell and install completions (auto-refreshes on upgrade)
c8ctl completion install --shell zsh                        # Install completions for a specific shell
```

---

### `mcp-proxy`

Start a STDIO MCP proxy (bridges local MCP clients to remote Camunda 8)

**Usage:** `c8ctl mcp-proxy [mcp-path]`

---

### `feedback`

Open the feedback page to report issues or request features

---

### `help`

Show help (run 'c8ctl help \<command>' for details)

**Usage:** `c8ctl help [command]`

**Aliases:** `menu`

---

### `which`

Show active profile or output mode

**Resources:** profile, output

**Examples:**

```bash
c8ctl which profile                                         # Show currently active profile
c8ctl which output                                          # Show current output mode
```

---

## Development workflows

<!-- This page is maintained in the c8ctl repository (https://github.com/camunda/c8ctl, in docs/) and
     is synced to camunda-docs automatically. Do not edit it in camunda-docs — changes will be
     overwritten. Edit the source in the c8ctl repo instead. -->

`c8ctl` includes commands that support local development and deployment workflows. You can deploy resources, run processes, watch for changes, manage profiles and sessions, and bridge MCP connections for AI assistants.

:::tip
Use the `--profile` flag with any command to run it against a specific cluster without changing the active session.

```bash
c8 deploy ./process.bpmn --profile=staging
c8 run ./order.bpmn --profile=prod
c8 watch --profile=local
```

:::

## Deploy

Deploy resources to the active cluster.

:::note
When more than one profile is configured and you don't pass `--profile`, `c8ctl` prompts you to confirm which cluster to deploy to — a safety check against deploying to the wrong environment. Pass `--yes` (or `-y`) to skip the prompt in scripts and CI.
:::

### Deploy a single file

```bash
c8 deploy ./process.bpmn
c8 deploy ./decision.dmn
c8 deploy ./form.form
```

### Deploy multiple files

```bash
c8 deploy ./process1.bpmn ./process2.bpmn ./decision.dmn
```

### Deploy a directory

```bash
# Deploy all resources in the current directory and subdirectories
c8 deploy

# Deploy all resources in a specific directory
c8 deploy ./my-project
```

When scanning directories, `c8ctl` includes files with the following extensions by default:

`.bpmn`, `.dmn`, `.form`

Use `--extensions` to add more types to the directory scan (merged with the defaults):

```bash
c8 deploy ./my-project --extensions=.md,.txt
```

Use `--all-extensions` to include every server-supported type (`.md`, `.txt`, `.xml`, `.rpa`, `.json`, `.config`, `.yml`, `.yaml`) without naming each one:

```bash
c8 deploy ./my-project --all-extensions
```

Explicitly named files are always deployed regardless of extension — the extension filter only applies when scanning directories:

```bash
c8 deploy ./custom-resource.unsupported
```

Use `--force` to disable extension filtering during directory discovery, deploying every file found regardless of extension:

```bash
c8 deploy ./my-project --force
```

### Building blocks and process applications

`c8ctl` recognizes two special folder conventions during deployment:

- Building blocks — folders containing `_bb-` in their name. These are deployed first.
- Process applications — folders containing a `.process-application` marker file.

```text
my-project/
├── _bb-shared/
│   ├── common.bpmn
│   └── nested/
│       └── util.bpmn
├── my-app/
│   ├── .process-application
│   ├── process.bpmn
│   └── subfolder/
│       └── form.form
└── standalone.bpmn
```

```bash
c8 deploy ./my-project
```

```text
Deploying 5 resource(s)...
✓ Deployment successful [Key: 123456789]

File                            | Type    | ID         | Version | Key
--------------------------------|---------|------------|---------|-------------------
_bb-shared/common.bpmn          | Process | common     | 1       | 2251799813685249
_bb-shared/nested/util.bpmn     | Process | util       | 1       | 2251799813685250
 my-app/process.bpmn            | Process | my-proc    | 1       | 2251799813685251
 my-app/subfolder/form.form     | Form    | form-id    | 1       | 2251799813685252
 standalone.bpmn                | Process | standalone | 1       | 2251799813685253
```

Building block resources are listed first, followed by process application resources, then standalone resources.

### Duplicate process ID detection

Camunda does not allow deploying multiple resources with the same process or decision ID in a single deployment. `c8ctl` detects duplicate IDs before sending the request and shows a clear error message indicating which files conflict.

If you have files that share the same ID, deploy them separately:

```bash
c8 deploy process-v1.bpmn
c8 deploy process-v2.bpmn
```

### Exclude files with `.c8ignore`

Create a `.c8ignore` file in your project directory to exclude files and directories from deployment and watch scanning. The format follows the same pattern syntax as `.gitignore`:

```text
# Exclude test resources
tests/

# Exclude work-in-progress files
wip-*.bpmn

# Exclude a specific file
old-process.bpmn
```

Place the `.c8ignore` file in the root of the directory you pass to `c8 deploy` or `c8 watch`. Patterns are matched against relative file paths within that directory.

## Run

The `run` command deploys a file and immediately creates a process instance in a single step:

```bash
c8 run ./order-process.bpmn

# With variables
c8 run ./order-process.bpmn --variables='{"orderId":"12345","amount":100}'

# With a Business ID
c8 run ./order-process.bpmn --businessId=order-123

# Deploy a file with an unsupported extension
c8 run ./process.xml --force
```

## Watch

Watch a directory for file changes and auto-redeploy on save:

```bash
c8 watch

# Watch a specific directory
c8 watch ./my-project

# Monitor only specific file extensions
c8 watch --extensions=.bpmn,.dmn,.form

# continue watching current directory
# even when deployment fails
c8 watch --force
```

By default, `c8ctl` monitors the same extensions used by `deploy`. Use `--extensions` to override. Use `--force` to continue watching after deployment errors.

When watching inside a process application (a folder tree containing a `.process-application` marker file), use `--process-application` (or its alias `--pa`) to watch and redeploy the entire application on each change:

```bash
c8 watch ./my-app --pa
```

### Continue watching after deployment errors

By default, `c8ctl` stops watching when a deployment fails with an error. Use `--force` to continue watching and redeploy on subsequent file changes, even after errors:

```bash
c8 watch --force
c8 watch ./my-project --force
```

This is useful during active development when your resources may temporarily be in an invalid state.

## Profile management

For full profile management documentation, including adding, listing, switching, and removing profiles, see [Getting started — Profile management](getting-started.md#profile-management).

### Quick reference

```bash
c8 add profile prod --baseUrl=https://camunda.example.com --clientId=xxx --clientSecret=yyy
c8 list profiles
c8 use profile prod
c8 which profile
c8 remove profile prod
```

### One-off profile override

Pass `--profile` to any command to use a different profile for that single invocation. The active session profile is not changed:

```bash
# Run a command against a different cluster
c8 list pi --profile=staging

# Deploy to production without switching context
c8 deploy ./release/ --profile=prod

# Use a Camunda Modeler profile for one command
c8 search ut --state=CREATED --profile=modeler:Cloud Cluster
```

This is useful when you are working against a local development cluster but need to quickly check or interact with another environment.

### Camunda Modeler integration

`c8ctl` automatically discovers and imports profiles from Camunda Modeler. These profiles are read-only, always prefixed with `modeler:`, and loaded dynamically on each command execution.

```bash
# Set a Modeler profile as the active session profile
c8 use profile "modeler:Local Dev"

# Use a Modeler profile for one command
c8 list pi --profile=modeler:Cloud Cluster

# Deploy using a Modeler profile
c8 deploy ./process.bpmn --profile=modeler:Local Dev
```

For Modeler profile file locations per platform, see [Getting started — Camunda Modeler integration](getting-started.md#camunda-modeler-integration).

## Session management

Session state persists between commands. Settings you change remain active until you change them again.

### Set the active profile

```bash
c8 use profile prod
```

### Set the active tenant

```bash
c8 use tenant my-tenant-id
```

### Set the output mode

```bash
c8 output json    # JSON output for scripting
c8 output text    # human-readable tables (default)
c8 output         # show current output mode
```

## MCP proxy

The `mcp-proxy` command starts a local STDIO-to-HTTP proxy that bridges MCP clients (such as VS Code with GitHub Copilot, or Claude Code) to the [Orchestration Cluster MCP Server](/apis-tools/orchestration-cluster-api-mcp/orchestration-cluster-api-mcp-overview.md). It handles OAuth 2.0 authentication transparently, so MCP clients that do not support the client credentials flow can connect to authenticated clusters.

### Configure with VS Code

Add the following to your `.vscode/mcp.json`:

```json
{
  "servers": {
    "camunda-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@camunda8/cli", "mcp-proxy"],
      "env": {
        "CAMUNDA_BASE_URL": "https://<cluster-base-url>",
        "CAMUNDA_CLIENT_ID": "<client-id>",
        "CAMUNDA_CLIENT_SECRET": "<client-secret>",
        "CAMUNDA_OAUTH_URL": "https://<token-url>/oauth/token",
        "CAMUNDA_TOKEN_AUDIENCE": "<token-audience>"
      }
    }
  }
}
```

| Variable                 | Description                                                                  |
| :----------------------- | :--------------------------------------------------------------------------- |
| `CAMUNDA_BASE_URL`       | Base URL of your Orchestration Cluster, **without** the `/mcp/cluster` path. |
| `CAMUNDA_CLIENT_ID`      | OAuth client ID from your API client credentials.                            |
| `CAMUNDA_CLIENT_SECRET`  | OAuth client secret from your API client credentials.                        |
| `CAMUNDA_OAUTH_URL`      | OAuth token endpoint URL.                                                    |
| `CAMUNDA_TOKEN_AUDIENCE` | Token audience for the Orchestration Cluster API.                            |

:::tip
When you [create API client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console, all required connection details are shown on the credentials page. You can also copy a ready-to-use `c8ctl` configuration snippet from the MCP tab.
:::

### Use a profile with MCP proxy

Instead of passing environment variables, use a `c8ctl` profile to supply credentials:

```json
{
  "servers": {
    "camunda-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@camunda8/cli", "mcp-proxy", "--profile=prod"]
    }
  }
}
```

This reads credentials from the named profile, including Modeler profiles (for example, `--profile=modeler:Cloud Cluster`).

### Local development without authentication

If your local cluster does not require authentication (for example, [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md)), you can connect MCP clients directly without the proxy:

```json
{
  "servers": {
    "camunda": {
      "type": "http",
      "url": "http://localhost:8080/mcp/cluster"
    }
  }
}
```

For full MCP server documentation, see [Orchestration Cluster MCP Server](/apis-tools/orchestration-cluster-api-mcp/orchestration-cluster-api-mcp-overview.md).

## Advanced example: iterative process testing

This example demonstrates an end-to-end development workflow — auto-deploying on save, starting a process instance with variables loaded from a file, monitoring execution in real time, and retrieving the result.

### 1. Start watch mode

In a terminal, start `c8ctl` in watch mode to auto-deploy resources whenever you save changes:

```bash
c8 watch
```

Now edit your `.bpmn`, `.dmn`, or `.form` files in your editor. Every time you save, `c8ctl` redeploys automatically.

### 2. Prepare process variables

In a different terminal, load variables from a JSON file into a shell variable:

```bash
export processVar=$(<order-data.json)
```

### 3. Switch to JSON output

JSON output makes it easy to extract keys from command results:

```bash
c8 output json
```

### 4. Start a process instance

Create a new process instance with the loaded variables:

```bash
c8 create pi --id=order-process --variables="{\"orderData\": $processVar}"
```

The JSON output returns the process instance key, for example `2251799813685260`.

### 5. Monitor execution

In a **separate terminal**, use `watch` (the Unix utility) to poll the process instance status every second:

```bash
watch -n 1 c8ctl search pi --key=2251799813685260
```

This continuously refreshes until the process instance reaches the `COMPLETED` state.

### 6. Retrieve the result

Once the process instance is complete, get the final state including all variables:

```bash
c8 get pi 2251799813685260 --variables
```

:::tip
You can combine steps 4 and 5 by using `c8 await pi` instead, which creates a process instance and waits for completion in a single command:

```bash
c8 await pi --id=order-process --variables="{\"orderData\": $processVar}" --fetchVariables
```

:::

## Open web applications

Open Camunda web applications in your default browser using the `open` command:

```bash
c8 open operate
c8 open tasklist
c8 open modeler
c8 open optimize
```

The URL is derived from the active profile's base URL. This works with self-managed clusters where the base URL ends with a version suffix (for example, `http://localhost:8080/v2`).

Use `--dry-run` to display the URL without opening the browser:

```bash
c8 open operate --dry-run
```

Use `--profile` to open an application for a specific cluster:

```bash
c8 open operate --profile=prod
```

## AI agents and scripting

c8ctl includes flags and output modes designed for AI agents and scripts. These also appear in their own labeled section in `c8ctl help`.

### Filter output with `--fields`

`--fields` limits output to the named fields (comma-separated). It applies to all `list`, `search`, and `get` commands, and matching is case-insensitive. This is useful for reducing the amount of output passed into an agent's context window.

```bash
# Only return the Key and State columns
c8 list pi --fields Key,State
c8 search pd --fields Key,processDefinitionId,name

# Works in both text and JSON output modes
c8 output json
c8 list pi --fields Key,State,processDefinitionId | jq .
```

### Preview requests with `--dry-run`

`--dry-run` prints the API request that would be sent without executing it. It works on every command — queries (`list`, `search`, `get`) and mutations (`create`, `cancel`, `deploy`, `complete`, `fail`, `activate`, `resolve`, `publish`, `correlate`). The command prints a JSON object to stdout and exits `0`:

```json
{
  "dryRun": true,
  "command": "create process-instance",
  "method": "POST",
  "url": "http://localhost:8080/v2/process-instances",
  "body": { "processDefinitionId": "my-process", "tenantId": "<default>" }
}
```

:::tip Recommended workflow for mutations

1. Run the command with `--dry-run` and show the would-be API call.
2. Wait for confirmation.
3. Re-run without `--dry-run` to execute.

:::

```bash
# Preview creating a process instance
c8 create pi --id=my-process --dry-run

# Preview a deployment
c8 deploy ./my-process.bpmn --dry-run

# Preview cancelling a process instance
c8 cancel pi 2251799813685249 --dry-run

# Inspect the filter body a search would send
c8 search pi --state ACTIVE --between 2024-01-01..2024-12-31 --dry-run
```

### Machine-readable help

In JSON output mode, `c8ctl help` emits structured JSON describing the full command tree, flags (with types), and agent flags:

```bash
c8 output json
c8 help          # JSON with commands[], globalFlags[], agentFlags[], and resourceAliases
c8 help list     # JSON for a specific command
```

## Verbose mode

Use the `--verbose` flag to see detailed information about credential resolution, plugin loading, and other internal operations:

```bash
c8 deploy ./process.bpmn --verbose
c8 list pi --verbose
```

## Debug mode

Enable debug logging with environment variables for even more detailed output:

```bash
DEBUG=1 c8 deploy ./process.bpmn
C8CTL_DEBUG=true c8 list pi
```

Debug output is written to stderr and does not interfere with normal command output.

---

## c8ctl CLI

<!-- This page is maintained in the c8ctl repository (https://github.com/camunda/c8ctl, in docs/) and
     is synced to camunda-docs automatically. Do not edit it in camunda-docs — changes will be
     overwritten. Edit the source in the c8ctl repo instead. -->

<PageDescription />

## About

`c8ctl` is a minimal-dependency CLI for Camunda 8. It is built on top of the [`@camunda8/orchestration-cluster-api`](https://www.npmjs.com/package/@camunda8/orchestration-cluster-api) TypeScript SDK and provides two equivalent bin aliases: `c8ctl` and `c8`.

`c8ctl` is designed for developers who need fast, scriptable access to a Camunda 8 cluster during development and testing. It supports both Camunda 8 SaaS and Self-Managed environments.

Use `c8ctl` to:

- Inspect running clusters — list process instances, user tasks, incidents, and jobs.
- Deploy BPMN, DMN, and form resources, optionally watching for file changes.
- Manage profiles for multiple clusters, including profiles imported from Camunda Modeler.
- Extend the CLI with custom plugins.

## Prerequisites

- **Node.js ≥ 22.18.0** (required for native TypeScript support)

## Install

Install `c8ctl` globally from npm:

```bash
npm install @camunda8/cli -g
```

After installation, both `c8ctl` and `c8` are available as commands in your terminal.

## Quick start with a local cluster

`c8ctl` includes a built-in `cluster` command that downloads and manages a local [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) instance. This is the fastest way to get a cluster running for development.

### Start a cluster

```bash
# Start with the latest stable version (default)
c8 cluster start

# Start with a specific version
c8 cluster start 8.9.0-alpha5

# Start using a version alias
c8 cluster start stable
c8 cluster start alpha

# Start with a major.minor version (rolling release)
c8 cluster start 8.8
```

`c8ctl` automatically downloads the correct binary for your platform, caches it locally, launches the cluster in the background, and waits for it to become healthy.

### Stop the cluster

```bash
c8 cluster stop
```

### Check cluster status

```bash
c8 cluster status
```

Reports whether a cluster is running, including connection details.

### View cluster logs

```bash
c8 cluster logs
```

Streams log output from the running cluster.

### Manage cached versions

```bash
# List locally cached versions and available aliases
c8 cluster list

# List all versions available on the remote download server
c8 cluster list-remote

# Download a version without starting it
c8 cluster install 8.8

# Remove a locally cached version
c8 cluster delete 8.8

# Delete a version's runtime data but keep the binary (the next start is fresh)
c8 cluster purge 8.8

# Or stop the running cluster and purge its runtime data in one step
c8 cluster stop --purge
```

### Version aliases

The `stable` and `alpha` aliases are resolved dynamically from the [Camunda Download Center](https://downloads.camunda.cloud/release/camunda/c8run/):

| Alias    | Resolves to                                              |
| :------- | :------------------------------------------------------- |
| `stable` | Highest minor release that is GA (for example, 8.9)      |
| `alpha`  | Highest minor release overall (for example, 8.10-alpha0) |

When no version is specified, `c8 cluster start` defaults to `stable`.

A `<major>.<minor>` version like `8.8` is treated as a rolling release — the download server directory is updated in-place with new patch releases. `c8 cluster start` uses the local version if available, while `c8 cluster install` always checks for a newer version.

### Debug output

Stream raw c8run logs during startup:

```bash
c8 cluster start --debug
```

### Supported platforms

- macOS (x86_64, aarch64)
- Linux (x86_64, aarch64)
- Windows (x86_64)

Cache locations:

| Platform | Path                          |
| :------- | :---------------------------- |
| macOS    | `~/Library/Caches/c8run/`     |
| Linux    | `~/.cache/c8run/`             |
| Windows  | `%LOCALAPPDATA%\c8run\cache\` |

Override the cache directory with the `C8RUN_CACHE_DIR` environment variable.

## Credential resolution

`c8ctl` resolves credentials in the following order:

1. **`--profile` flag** — one-off override for a single command.
2. **Active profile** — set with `c8 use profile <name>`.
3. **Environment variables** — standard `CAMUNDA_*` variables (take precedence over the default profile).
4. **Default `local` profile** — `http://localhost:8080/v2`.

When no profile has been explicitly set, `c8ctl` defaults to a built-in `local` profile that points to `http://localhost:8080/v2`. This means you can start a local cluster with `c8 cluster start` and immediately run commands without any configuration. If the connection fails, `c8ctl` shows a hint with the URL it tried to connect to.

### Use environment variables

```bash
export CAMUNDA_BASE_URL=https://camunda.example.com
export CAMUNDA_CLIENT_ID=your-client-id
export CAMUNDA_CLIENT_SECRET=your-client-secret
c8 list pi
```

### Use a profile

```bash
c8 add profile prod \
  --baseUrl=https://camunda.example.com \
  --clientId=your-client-id \
  --clientSecret=your-client-secret

c8 use profile prod
c8 list pi
```

### Override the profile for a single command

Pass `--profile` to any command to use a different profile without changing the active session:

```bash
c8 list pi --profile=staging
c8 deploy ./process.bpmn --profile=prod
c8 search ut --assignee=jane --profile=dev
```

The `--profile` flag works with both `c8ctl` profiles and Camunda Modeler profiles (prefixed with `modeler:`):

```bash
c8 list pi --profile=modeler:Cloud Cluster
c8 deploy ./process.bpmn --profile=modeler:Local Dev
```

## Tenant resolution

Tenants are resolved in the following order:

1. **Active tenant** — set with `c8 use tenant <id>`.
2. **Default tenant** from the active profile.
3. **`CAMUNDA_DEFAULT_TENANT_ID`** environment variable.
4. **`<default>`** tenant.

```bash
c8 use tenant my-tenant-id
c8 list pi   # uses my-tenant-id
```

## Profile management

`c8ctl` supports two types of profiles:

1. `c8ctl` profiles — managed directly with `c8ctl` commands.
2. Camunda Modeler profiles — automatically imported from Camunda Modeler (read-only, prefixed with `modeler:`).

### Add a profile

```bash
# Minimal local profile (defaults to http://localhost:8080/v2)
c8 add profile local

# OAuth-secured cluster
c8 add profile prod \
  --baseUrl=https://camunda.example.com \
  --clientId=your-client-id \
  --clientSecret=your-client-secret

# With explicit OAuth endpoint, audience, and scope
c8 add profile prod \
  --baseUrl=https://camunda.example.com \
  --clientId=your-client-id \
  --clientSecret=your-client-secret \
  --audience=camunda-api \
  --oAuthUrl=https://auth.example.com/oauth/token \
  --scope="my-oauth-scope"

# With a default tenant
c8 add profile dev \
  --baseUrl=https://dev.example.com \
  --clientId=dev-client \
  --clientSecret=dev-secret \
  --defaultTenantId=dev-tenant

# Import settings from a .env file
c8 add profile staging --from-file .env.staging

# Import settings from the current CAMUNDA_* environment variables
source .env.prod
c8 add profile prod --from-env
```

### List profiles

```bash
c8 list profiles
```

Lists both `c8ctl` and Modeler profiles. Modeler profiles appear with a `modeler:` prefix.

### Switch the active profile

```bash
c8 use profile prod
c8 use profile "modeler:Local Dev"
```

All subsequent commands use the active profile until you switch again or pass `--profile`.

### Show the current profile

```bash
c8 which profile
```

### Remove a profile

```bash
c8 remove profile prod
c8 rm profile prod   # alias
```

:::note
Modeler profiles are read-only. They cannot be modified or removed through `c8ctl` — manage them in Camunda Modeler.
:::

### Camunda Modeler integration

`c8ctl` automatically reads profiles from Camunda Modeler's `profiles.json` file. These profiles are:

- **Read-only** — cannot be modified or deleted via `c8ctl`.
- **Prefixed** — always displayed with a `modeler:` prefix (for example, `modeler:Local Dev`).
- **Dynamic** — loaded fresh on each command execution.

Platform-specific locations:

| Platform | Path                                                          |
| :------- | :------------------------------------------------------------ |
| Linux    | `~/.config/camunda-modeler/profiles.json`                     |
| macOS    | `~/Library/Application Support/camunda-modeler/profiles.json` |
| Windows  | `%APPDATA%\camunda-modeler\profiles.json`                     |

```bash
# Use a Modeler profile as the active session profile
c8 use profile "modeler:Local Dev"

# Use a Modeler profile for a single command
c8 list pi --profile=modeler:Cloud Cluster
```

## Get help

```bash
c8ctl help                # general help
c8ctl help list           # help for the list command
c8ctl help deploy         # help for the deploy command
c8ctl help profiles       # help for profile management
c8ctl --version           # print version
```

Run any verb without a resource to see what resources are available:

```bash
c8 list                   # shows: pi, pd, ut, inc, jobs, profiles, plugins, users, roles, groups, tenants, auth, mr
c8 search                 # shows: pi, pd, ut, inc, jobs, variables, users, roles, groups, tenants, auth, mr
```

## Send feedback

```bash
c8 feedback
```

Opens the GitHub issues page in your browser to report bugs or request features.

## Update notifications

`c8ctl` checks for newer versions in the background and displays a one-time notification when an update is available. This check is suppressed in CI environments, JSON output mode, and development versions.

## Shell completion

The recommended way to set up shell completion is with the `install` subcommand:

```bash
c8 completion install
```

This auto-detects your shell, writes the completion file, and wires it into your shell configuration. To specify a shell explicitly:

```bash
c8 completion install --shell zsh
```

Completions auto-refresh when the CLI is upgraded.

Alternatively, generate the completion script manually:

<Tabs>
  <TabItem value="bash" label="Bash">

```bash
c8ctl completion bash > ~/.c8ctl-completion.bash
echo 'source ~/.c8ctl-completion.bash' >> ~/.bashrc
source ~/.bashrc
```

</TabItem>

<TabItem value="zsh" label="Zsh">

```bash
c8ctl completion zsh > ~/.c8ctl-completion.zsh
echo 'source ~/.c8ctl-completion.zsh' >> ~/.zshrc
source ~/.zshrc
```

</TabItem>

<TabItem value="fish" label="Fish">

```bash
c8ctl completion fish > ~/.config/fish/completions/c8ctl.fish
```

Fish loads the completion automatically on the next shell start.

</TabItem>
</Tabs>

## Output modes

Switch between human-readable text and machine-readable JSON:

```bash
c8 output json    # all commands output JSON
c8 output text    # back to formatted tables (default)
```

## Environment variables

| Variable                    | Description          |
| :-------------------------- | :------------------- |
| `CAMUNDA_BASE_URL`          | Cluster base URL     |
| `CAMUNDA_CLIENT_ID`         | OAuth client ID      |
| `CAMUNDA_CLIENT_SECRET`     | OAuth client secret  |
| `CAMUNDA_TOKEN_AUDIENCE`    | OAuth token audience |
| `CAMUNDA_OAUTH_URL`         | OAuth token endpoint |
| `CAMUNDA_OAUTH_SCOPE`       | OAuth scope (space-separated) |
| `CAMUNDA_DEFAULT_TENANT_ID` | Default tenant ID    |

Environment variable conventions follow the [`@camunda8/orchestration-cluster-api`](https://www.npmjs.com/package/@camunda8/orchestration-cluster-api) module.

## Debug mode

Enable debug logging to see detailed internal information such as plugin loading and credential resolution:

```bash
DEBUG=1 c8 list pi
# or
C8CTL_DEBUG=true c8 list pi
```

Debug output is written to stderr and does not interfere with normal command output.

## Next steps

- [Cluster inspection and process management](cluster-inspection.md) — list, search, and manage process instances, user tasks, incidents, and jobs.
- [Development workflows](development-workflows.md) — deploy, run, watch, and configure profiles and MCP proxy.
- [Extend `c8ctl` with plugins](plugins.md) — scaffold, install, and manage custom CLI plugins.

---

## Identity management

<!-- This page is maintained in the c8ctl repository (https://github.com/camunda/c8ctl, in docs/) and
     is synced to camunda-docs automatically. Do not edit it in camunda-docs — changes will be
     overwritten. Edit the source in the c8ctl repo instead. -->

`c8ctl` provides commands to manage identity resources through the Orchestration Cluster API. You can list, search, get, create, and delete users, roles, groups, tenants, authorizations, and mapping rules. Membership management is handled with the `assign` and `unassign` verbs.

| Resource           | Alias  | Available verbs                             |
| :----------------- | :----- | :------------------------------------------ |
| `user(s)`          | —      | `list`, `search`, `get`, `create`, `delete` |
| `role(s)`          | —      | `list`, `search`, `get`, `create`, `delete` |
| `group(s)`         | —      | `list`, `search`, `get`, `create`, `delete` |
| `tenant(s)`        | —      | `list`, `search`, `get`, `create`, `delete` |
| `authorization(s)` | `auth` | `list`, `search`, `get`, `create`, `delete` |
| `mapping-rule(s)`  | `mr`   | `list`, `search`, `get`, `create`, `delete` |

:::tip
All commands respect the active profile and tenant. Pass `--profile` to override the profile for a single command:

```bash
c8 list users --profile=prod
c8 search roles --profile=staging
```

:::

## Users

### List users

```bash
c8 list users
```

### Search users

```bash
c8 search users --name=John
c8 search users --email='john@example.com'
c8 search users --name=John --email='john@example.com'
```

### Get a user

```bash
c8 get user john
```

### Create a user

```bash
c8 create user --username=john --name='John Doe' --email=john@example.com --password=changeme
```

### Delete a user

```bash
c8 delete user john
```

## Roles

### List roles

```bash
c8 list roles
```

### Search roles

```bash
c8 search roles --name=admin
```

### Get a role

```bash
c8 get role admin
```

### Create a role

```bash
c8 create role --roleId=my-role --name='My role'
```

### Delete a role

```bash
c8 delete role my-role
```

## Groups

### List groups

```bash
c8 list groups
```

### Search groups

```bash
c8 search groups --name=developers
```

### Get a group

```bash
c8 get group developers
```

### Create a group

```bash
c8 create group --groupId=developers --name=Developers
```

### Delete a group

```bash
c8 delete group developers
```

## Tenants

### List tenants

```bash
c8 list tenants
```

### Search tenants

```bash
c8 search tenants --name=Production
```

### Get a tenant

```bash
c8 get tenant prod
```

### Create a tenant

```bash
c8 create tenant --tenantId=prod --name='Production'
```

### Delete a tenant

```bash
c8 delete tenant prod
```

## Authorizations

### List authorizations

```bash
c8 list auth
c8 list authorizations
```

### Search authorizations

```bash
c8 search auth --ownerId=john --resourceType=process-definition
```

### Create an authorization

```bash
c8 create auth --ownerId=john --ownerType=USER --resourceType=process-definition --resourceId='*' --permissions=READ,CREATE
```

### Delete an authorization

```bash
c8 delete auth 2251799813685260
```

## Mapping rules

### List mapping rules

```bash
c8 list mr
c8 list mapping-rules
```

### Search mapping rules

```bash
c8 search mr --name=my-rule
```

### Create a mapping rule

```bash
c8 create mr --mappingRuleId=my-rule --name='My Rule' --claimName=email --claimValue=user@example.com
```

### Delete a mapping rule

```bash
c8 delete mr my-rule
```

## Assign and unassign

The `assign` and `unassign` verbs manage membership between identity resources. You can assign users to roles, groups, or tenants, and assign groups to tenants.

### Assign a user to a role

```bash
c8 assign role admin --to-user=john
```

### Unassign a user from a role

```bash
c8 unassign role admin --from-user=john
```

### Assign a user to a group

```bash
c8 assign user john --to-group=developers
```

### Unassign a user from a group

```bash
c8 unassign user john --from-group=developers
```

### Assign a group to a tenant

```bash
c8 assign group developers --to-tenant=prod
```

### Unassign a group from a tenant

```bash
c8 unassign group developers --from-tenant=prod
```

---

## Extend c8ctl with plugins

<!-- This page is maintained in the c8ctl repository (https://github.com/camunda/c8ctl, in docs/) and
     is synced to camunda-docs automatically. Do not edit it in camunda-docs — changes will be
     overwritten. Edit the source in the c8ctl repo instead. -->

`c8ctl` supports a global plugin system that lets you add custom commands. Plugins are installed globally to a user-specific directory and tracked in a registry file (`plugins.json`).

## Plugin storage locations

| Platform | Plugins directory                                          | Registry file                                      |
| :------- | :--------------------------------------------------------- | :------------------------------------------------- |
| Linux    | `~/.config/c8ctl/plugins/node_modules`                     | `~/.config/c8ctl/plugins.json`                     |
| macOS    | `~/Library/Application Support/c8ctl/plugins/node_modules` | `~/Library/Application Support/c8ctl/plugins.json` |
| Windows  | `%APPDATA%\c8ctl\plugins\node_modules`                     | `%APPDATA%\c8ctl\plugins.json`                     |

You can override the data directory with the `C8CTL_DATA_DIR` environment variable.

## Scaffold a new plugin

Generate a new plugin project from a TypeScript template:

```bash
c8ctl init plugin my-plugin
```

This creates a project directory with all necessary files, build configuration, and an `AGENTS.md` guide for autonomous plugin implementation.

## Install a plugin

### From the npm registry

```bash
c8 load plugin my-custom-plugin
```

### From a URL

```bash
c8 load plugin --from https://github.com/user/my-plugin
c8 load plugin --from file:///path/to/local/plugin
c8 load plugin --from git://github.com/user/plugin.git
```

After loading, plugin commands are immediately available.

## Manage plugins

### List installed plugins

```bash
c8 list plugins
```

Output shows version and sync status for each plugin:

- `✓ Installed` — plugin is in the registry and installed.
- `⚠ Not installed` — plugin is in the registry but missing from disk (run `sync`).
- `⚠ Not in registry` — plugin is installed but not tracked in the registry.

### Upgrade a plugin

```bash
# Upgrade to latest
c8 upgrade plugin my-custom-plugin

# Upgrade to a specific version
c8 upgrade plugin my-custom-plugin 1.2.3
```

### Downgrade a plugin

```bash
c8 downgrade plugin my-custom-plugin 1.0.0
```

Upgrade and downgrade behavior depends on the plugin source:

| Source      | Behavior                                                                                                    |
| :---------- | :---------------------------------------------------------------------------------------------------------- |
| npm package | Installs `<name>@<version>`.                                                                                |
| URL/git     | Installs `<source>#<version>`.                                                                              |
| `file://`   | Version-based upgrade/downgrade is not supported. Use `load plugin --from` with the desired local checkout. |

### Unload a plugin

```bash
c8 unload plugin my-custom-plugin
```

### Synchronize plugins

Synchronize all plugins from the registry. Rebuilds installed plugins and reinstalls any that are missing:

```bash
c8 sync plugins
```

### Diagnose plugin issues

Use `doctor plugin` to inspect the plugin loading state and surface any command collisions (for example, when two plugins register the same command). The report always exits `0` — it describes state rather than failing.

```bash
# Human-readable summary of loaded plugins and any collisions
c8 doctor plugin

# Machine-readable output for scripts and agents
c8 doctor plugin --json
```

Built-in commands always take precedence over plugin commands, and the first plugin to register a given command wins. `doctor plugin` shows which registrations were kept and which were shadowed.

## Plugin structure

A plugin is a regular Node.js module with a `c8ctl-plugin.js` (or `c8ctl-plugin.ts`) file in the root directory. The file must export a `commands` object and optionally a `metadata` object.

### Minimal example

```typescript
// c8ctl-plugin.ts
export const metadata = {
  name: "my-plugin",
  description: "My custom c8ctl plugin",
  commands: {
    analyze: {
      description: "Analyze BPMN processes for best practices",
    },
    optimize: {
      description: "Optimize process definitions",
    },
  },
};

export const commands = {
  analyze: async (args: string[]) => {
    console.log("Analyzing...", args);
  },
  optimize: async (args: string[]) => {
    console.log("Optimizing...");
  },
};
```

## Plugin runtime API

At runtime, `c8ctl` injects a global object via `globalThis.c8ctl` that plugins can use to interact with the Camunda cluster and the `c8ctl` environment.

| Method/field                         | Description                                                                              |
| :----------------------------------- | :--------------------------------------------------------------------------------------- |
| `createClient(profile?, sdkConfig?)` | Create a Camunda SDK client. Optionally pass a profile name to use specific credentials. |
| `resolveTenantId(profile?)`          | Resolve the active tenant ID using the same fallback logic as built-in commands.         |
| `getLogger()`                        | Get the `c8ctl` logger instance (respects the current output mode).                      |
| `version`                            | `c8ctl` version string.                                                                  |
| `nodeVersion`                        | Node.js version.                                                                         |
| `platform`                           | Operating system (`linux`, `darwin`, `win32`).                                           |
| `arch`                               | CPU architecture.                                                                        |
| `cwd`                                | Current working directory.                                                               |
| `outputMode`                         | Current output mode (`text` or `json`).                                                  |
| `activeProfile`                      | Name of the active profile.                                                              |
| `activeTenant`                       | Active tenant ID.                                                                        |

### TypeScript autocomplete

For TypeScript autocomplete in your plugin, import the runtime type:

```typescript

const c8ctl = globalThis.c8ctl as C8ctlPluginRuntime;
const tenantId = c8ctl.resolveTenantId();
const logger = c8ctl.getLogger();
logger.info(`Tenant: ${tenantId}`);
```

### Use the SDK client from a plugin

```typescript

const c8ctl = globalThis.c8ctl as C8ctlPluginRuntime;

export const commands = {
  "list-active": async (args: string[]) => {
    const client = c8ctl.createClient();
    const logger = c8ctl.getLogger();
    // Use the client to query the Orchestration Cluster API
    logger.info("Client ready");
  },
};
```

## Help integration

When plugins export a `metadata.commands` object with descriptions, those commands appear in the `c8ctl help` output under a **Plugin Commands** section:

```text
c8ctl - Camunda 8 CLI v2.2.0

Commands:
  list      <resource>       List resources (pi, ut, inc, jobs, profiles)
  get       <resource> <key> Get resource by key (pi, topology)
  ...

Plugin Commands:
  analyze                 Analyze BPMN processes for best practices
  optimize                Optimize process definitions
```

Plugins without a `metadata` export still work — their commands appear in the help output without descriptions.

## Command precedence

Built-in commands take precedence over plugin commands. If a plugin exports a command with the same name as a built-in command (for example, `list` or `deploy`), the built-in command runs.

Use descriptive and unique names for plugin commands.

Recommended:

- `analyze-process`
- `export-data`
- `sync-resources`

Avoid:

- `list`
- `get`
- `create`
- `deploy`

## Find plugins

Plugins are distributed as regular npm packages. There are two main ways to discover available plugins:

### Search the Camunda GitHub organization

Browse the [Camunda GitHub organization](https://github.com/camunda) and search for repositories with `c8ctl` in the name. By convention, plugin repositories are named `c8ctl-plugin-<name>` (for example, `c8ctl-plugin-analyze`), but this is not a hard requirement — any npm package with a `c8ctl-plugin.js` entry point works as a plugin.

### Search the npm registry

Search for `c8ctl` or `c8ctl-plugin` on [npmjs.com](https://www.npmjs.com/search?q=c8ctl-plugin):

```bash
npm search c8ctl-plugin
```

Once you find a plugin, install it with:

```bash
c8 load plugin <package-name>
```

## Best practices

- Use unique command names to avoid conflicts with built-in commands.
- Provide descriptions in `metadata.commands` so users discover your commands in `c8ctl help`.
- Keep descriptions concise and aim for a single line under 60 characters, starting with an imperative verb.
- Transpile TypeScript to JavaScript before publishing. The `c8ctl-plugin.js` entry point in `node_modules` must be JavaScript, because Node.js does not support type stripping in `node_modules`.
- Use `createClient()` from the runtime API to create SDK clients rather than importing the SDK directly. This ensures credentials and tenant resolution follow `c8ctl` conventions.

---

## Configuration

This page uses YAML examples to show configuration properties. Alternate methods to [externalize or override your configuration](https://docs.spring.io/spring-boot/reference/features/external-config.html) are provided by Spring Boot, and can be applied without rebuilding your application (properties files, Java System properties, or environment variables).

:::note
Configuration properties can be defined as environment variables using [Spring Boot conventions](https://docs.spring.io/spring-boot/reference/features/external-config.html#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables). To define an environment variable, convert the configuration property to uppercase, remove any dashes `-`, and replace any delimiters `.` with underscore `_`.

For example, the property `camunda.client.worker.defaults.max-jobs-active` is represented by the environment variable `CAMUNDA_CLIENT_WORKER_DEFAULTS_MAXJOBSACTIVE`.
:::

:::note
For a full set of properties, head over to the [properties reference](./properties-reference.md)
:::

## Modes

The Camunda Spring Boot Starter has modes with meaningful defaults aligned with the distribution's default connection details. Each mode is made for a Camunda 8 setup, and only one mode may be used at a time.

:::note
The defaults applied by the modes are overwritten by _any_ other set property, including legacy/deprecated properties. Check your configuration and logs to avoid unwanted override.
:::

### SaaS

This allows you to connect to a Camunda instance in our SaaS offering as the URLs are templated.

Activate by setting:

```yaml
camunda:
  client:
    mode: saas
```

This applies the following defaults:

```yaml reference referenceLinkText="Source" title="SaaS mode"
https://github.com/camunda/camunda/blob/main/clients/camunda-spring-boot-starter/src/main/resources/modes/saas.yaml
```

The only thing you need to configure then, are the connection details to your Camunda SaaS cluster:

```yaml
camunda:
  client:
    auth:
      client-id: <your client id>
      client-secret: <your client secret>
    cloud:
      cluster-id: <your cluster id>
      region: <your region>
```

Other connectivity configuration does not further apply for the SaaS mode.

### Self-Managed

This allows you to connect to a Self-Managed instance protected with JWT authentication. The default URLs are configured to align with all Camunda distributions using `localhost` addresses.

Activate by setting:

```yaml
camunda:
  client:
    mode: self-managed
```

This applies the following defaults:

```yaml reference referenceLinkText="Source" title="Self-managed mode"
https://github.com/camunda/camunda/blob/main/clients/camunda-spring-boot-starter/src/main/resources/modes/self-managed.yaml
```

For some specific OIDC setups (for example, [Microsoft Entra ID](https://learn.microsoft.com/en-us/entra/identity)), you might need to define additional properties like `camunda.client.auth.scope` in addition to the defaults provided by the mode, see the [`camunda.client.auth`-Properties reference](./properties-reference.md) for a full overview.

## Connectivity

The connection to Camunda API is determined by `camunda.client.grpc-address` and `camunda.client.rest-address`

### Camunda API connection

#### gRPC address

Define the address of the [gRPC API](/apis-tools/zeebe-api/grpc.md) exposed by the [Zeebe Gateway](/reference/glossary.md#zeebe-gateway):

```yaml
camunda:
  client:
    grpc-address: http://localhost:26500
```

:::note
You must add the `http://` scheme to the URL to avoid a `java.lang.NullPointerException: target` error.
:::

#### REST address

Define address of the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) exposed by the Zeebe Gateway:

```yaml
camunda:
  client:
    rest-address: http://localhost:8080
```

:::note
You must add the `http://` scheme to the URL to avoid a `java.lang.NullPointerException: target` error.
:::

#### Prefer REST over gRPC

By default, the Camunda Client will use REST instead of gRPC whenever possible to communicate with the Camunda APIs.

To use the gRPC by default, you can configure this:

```yaml
camunda:
  client:
    prefer-rest-over-grpc: false
```

### Advanced connectivity settings

```yaml
camunda:
  client:
    keep-alive: PT60S
    override-authority: host:port
    max-message-size: 4194304
    max-metadata-size: 4194304
    ca-certificate-path: path/to/certificate
    request-timeout: PT10S
    request-timeout-offset: PT1S
```

**Keep alive:** Time interval between keep alive messages sent to the gateway (default is 45s).

**Override authority:** The alternative authority to use, commonly in the form `host` or `host:port`.

**Max message size:** A custom `maxMessageSize` allows the client to receive larger or smaller responses from Zeebe. Technically, it specifies the `maxInboundMessageSize` of the gRPC channel (default 5MB).

**Max metadata size:** A custom `maxMetadataSize` allows the client to receive larger or smaller response headers from Camunda.

**CA certificate path:** Path to a root CA certificate to be used instead of the certificate in the default store.

**Request timeout:** The timeout for all requests sent to Camunda. There is an additional option to define the timeout for workers.

**Request timeout offset:** The offset being added to the timeout on asynchronous requests sent to Camunda to cover the network latency.

### Multi-tenancy

To connect the client to a specific tenant, you can configure:

```yaml
camunda:
  client:
    tenant-id: myTenant
```

This does also affect the default tenant being used by all job workers, however there are [more possibilities](#control-tenant-usage) to configure them.

## Authentication

The authentication method is determined by `camunda.client.auth.method`. If omitted, the client will try to detect the authentication method based on the provided properties.

Authenticate with the cluster using the following alternative methods:

:::info
When using `camunda.client.mode=saas`, the authentication method presets are not applied in favor of the properties contained in the SaaS preset.
:::

### No authentication

By default, no authentication will be used.

To explicitly activate this method, you can set:

```yaml
camunda:
  client:
    auth:
      method: none
```

As alternative, do not provide any other property indicating an implicit authentication method.

This will load this preset:

```yaml reference referenceLinkText="Source" title="No authentication"
https://github.com/camunda/camunda/blob/main/clients/camunda-spring-boot-starter/src/main/resources/auth-methods/none.yaml
```

### Basic authentication

You can authenticate with the cluster using Basic authentication, if the cluster is setup to use Basic authentication.

To explicitly activate this method, you can set:

```yaml
camunda:
  client:
    auth:
      method: basic
```

This authentication method will be implied if you set either `camunda.client.auth.username` or `camunda.client.auth.password`.

This will load this preset:

```yaml reference referenceLinkText="Source" title="Basic authentication"
https://github.com/camunda/camunda/blob/main/clients/camunda-spring-boot-starter/src/main/resources/auth-methods/basic.yaml
```

### OIDC authentication

You can authenticate with the cluster using OpenID Connect (OIDC) with client ID and client secret.

To explicitly activate this method, you can set:

```yaml
camunda:
  client:
    auth:
      method: oidc
```

This authentication method will be implied if you set either `camunda.client.auth.client-id` or `camunda.client.auth.client-secret`.

This will load this preset:

```yaml reference referenceLinkText="Source" title="OIDC authentication"
https://github.com/camunda/camunda/blob/main/clients/camunda-spring-boot-starter/src/main/resources/auth-methods/oidc.yaml
```

:::note
There are three ways to define the token URL. They're prioritized as follows:

1. Provide the `camunda.client.auth.token-url`.
2. Provide the issuer's well-known configuration URL `camunda.client.auth.well-known-configuration-url`. This extracts the token URL from the `token_url` field in the loaded configuration.
3. Provide the issuer's URL `camunda.client.auth.issuer-url`. This generates the well-known configuration URL and extracts the token URL from the `token_url` field in the loaded configuration.
   :::

#### Credentials cache path

By default, the Java client caches OAuth credentials in memory only. To persist credentials across JVM restarts, opt in to a file-based cache by setting `camunda.client.auth.credentials-cache-path` to a writeable file location (directory path and file name):

```yaml
camunda:
  client:
    auth:
      credentials-cache-path: /tmp/credentials
```

When this property is unset or empty, no cache file is created and tokens are fetched fresh after each restart.

#### Custom identity provider security context

Several identity providers, such as Keycloak, support client X.509 authorizers as an alternative to client credentials flow.

As a prerequisite, ensure you have proper KeyStore and TrustStore configured, so that:

- Both the Spring Camunda application and identity provider share the same CA trust certificates.
- Both the Spring Camunda and identity provider own certificates signed by trusted CA.
- Your Spring Camunda application own certificate has proper `Distinguished Name` (DN), e.g.
  `CN=My Camunda Client, OU=Camunda Users, O=Best Company, C=DE`.
- Your application DN registered in the identity provider client authorization details.

Once prerequisites are satisfied, your Spring Camunda application must be configured either via global SSL context, or
with an exclusive context which is documented below.

Refer to your identity provider documentation on how to configure X.509 authentication. For example, [Keycloak](https://www.keycloak.org/server/mutual-tls).

If you require configuring SSL context exclusively for your identity provider, you can use this set of properties:

```yaml
camunda:
  client:
    auth:
      keystore-path: /path/to/keystore.p12
      keystore-password: password
      keystore-key-password: password
      truststore-path: /path/to/truststore.jks
      truststore-password: password
```

- **keystore-path**: Path to client's KeyStore; can be both in JKS or PKCS12 formats
- **keystore-password**: KeyStore password
- **keystore-key-password**: Key material password
- **truststore-path**: Path to client's TrustStore
- **truststore-password**: TrustStore password

When the properties are not specified, the default SSL context is applied. For example, if you configure an application with
`javax.net.ssl.*` or `spring.ssl.*`, the latter is applied. If both `camunda.client.auth.*` and either `javax.net.ssl.*`
or `spring.ssl.*` properties are defined, the `camunda.client.auth.*` takes precedence.

## Job worker configuration options

### Job type

By default, the **method name** is used as the job type, keeping your code self-documenting without additional configuration:

```java
@JobWorker
public void checkPayment() {
  // handles jobs of type 'checkPayment'
}
```

To use a different job type, set the `type` attribute on the annotation:

```java
@JobWorker(type = "payment-check")
public void checkPayment() {
  // handles jobs of type 'payment-check'
}
```

To override the job type externally without modifying the code — for example, when deploying a shared worker implementation under a different type name — use an application property:

```yaml
camunda:
  client:
    worker:
      override:
        checkPayment:
          type: payment-check
```

To set a fallback job type for all workers that don't define a type via annotation or property override:

```yaml
camunda:
  client:
    worker:
      defaults:
        type: my-default-type
```

### Control variable fetching

By default, a job worker fetches **all** process variables when activating a job. To improve performance and keep your code clean, you should fetch only the variables your worker actually needs. See [writing good workers](/components/best-practices/development/writing-good-workers.md#data-minimization-in-workers) for more guidance on minimizing data transfer.

#### Using `@Variable` (recommended)

The recommended approach is to declare each variable you need as a typed method parameter annotated with `@Variable`. The SDK automatically fetches only those variables and injects them directly — no type casting required:

```java
@JobWorker
public void checkPayment(@Variable String orderId, @Variable BigDecimal amount) {
  // only 'orderId' and 'amount' are fetched; types are enforced automatically
}
```

With the [`-parameters` compiler flag](./getting-started.md#enable-the-java-compiler--parameters-flag) enabled, the parameter name is used as the variable name automatically. To use a different variable name, set it explicitly on the annotation:

```java
@JobWorker
public void checkPayment(@Variable(name = "order_id") String orderId) {
  // fetches the process variable 'order_id' into the 'orderId' parameter
}
```

:::note
This adds the variable name to the list of variables fetched from the process.
:::

#### Using `@VariablesAsType`

For workers that operate on multiple related variables, `@VariablesAsType` maps process variables to your own class, eliminating individual type casts. Jackson's `@JsonProperty` annotation is respected. Return the updated object to write changes back to the process:

```java
@JobWorker
public PaymentVariables checkPayment(@VariablesAsType PaymentVariables vars) {
  // access typed fields directly — no casting needed
  vars.setApproved(vars.getAmount().compareTo(BigDecimal.valueOf(100)) <= 0);
  return vars; // return the object to write updated fields back to the process
}
```

:::note
This adds the names of the fields of the used type to the list of variables fetched from the process.
:::

#### Provide an explicit list of variables to fetch

If you need access to the raw `ActivatedJob` or `JobClient` objects, you can specify an explicit list of variable names to avoid fetching all variables:

```java
@JobWorker(fetchVariables = {"orderId", "amount"})
public void checkPayment(final JobClient client, final ActivatedJob job) {
  String orderId = (String) job.getVariablesAsMap().get("orderId");
  // ...
}
```

You can also override the variables to fetch in your properties:

```yml
camunda:
  client:
    worker:
      override:
        checkPayment:
          fetch-variables:
            - orderId
            - amount
```

:::caution
Using the properties-defined way of fetching variables will override **all** other detection strategies.
:::

#### Fetch all variables

If your worker genuinely needs every process variable, you can force fetching all variables:

```java
@JobWorker(fetchAllVariables = true)
public void checkPayment(final ActivatedJob job) {
  // all variables are available via job.getVariablesAsMap()
}
```

You can also set this in your properties:

```yml
camunda:
  client:
    worker:
      override:
        checkPayment:
          force-fetch-all-variables: true
```

### Define job worker function parameters

The method signature you use to define job worker functions determines what data is available in your worker. For fetching process variables, use [`@Variable`](#using-variable-recommended) or [`@VariablesAsType`](#using-variablesastype) — both are covered in the [variable fetching section](#control-variable-fetching) above.

Unless stated otherwise, all specified methods for fetching variables will be combined into a single list of variables to retrieve.

#### `JobClient` parameter

The `JobClient` is also part of the native `JobHandler` functional interface:

```java
@JobWorker
public void processOrder(final JobClient jobClient) {
  // ...
}
```

#### `ActivatedJob` parameter

The `ActivatedJob` is also part of the native `JobHandler` functional interface.

This will **prevent** the implicit variable fetching detection as you can retrieve variables in a programmatic way now:

```java
@JobWorker
public void processOrder(final ActivatedJob job) {
  String orderId = (String) job.getVariablesAsMap().get("orderId");
  // ...
}
```

:::note
Only explicit variable fetching will be effective when using the `ActivatedJob` as a parameter.
:::

#### Using `@Document`

You can inject a `DocumentContext` by using the `@Document` annotation:

```java
@JobWorker
public void processDocument(@Document DocumentContext doc) {
  List<DocumentEntry> documents = doc.getDocuments();
  // do what you need to do with the document entries
}
```

Each `DocumentEntry` grants you access to the `DocumentReferenceResponse` that contains the reference data to the document and the `DocumentLinkResponse` that contains a link to the document.

On top, you can directly retrieve the document content as `InputStream` or `byte[]`.

#### Using `@CustomHeaders`

You can use the `@CustomHeaders` annotation for a `Map<String, String>` parameter to retrieve [custom headers](/components/concepts/job-workers.md) for a job:

```java
@JobWorker
public void processOrder(@CustomHeaders Map<String, String> headers) {
  // do whatever you need to do
}
```

:::note
This will not have any effect on the variable fetching behavior.
:::

#### Using `@ProcessInstanceKey`, `@ElementInstanceKey`, `@JobKey`, `@ProcessDefinitionKey` and `@RootProcessInstanceKey`

You can use the `@ProcessInstanceKey`, `@ElementInstanceKey`, `@JobKey`, `@ProcessDefinitionKey` and `@RootProcessInstanceKey` annotation for a `String`, `long` or `Long` parameter to retrieve the according key for a job:

```java
@JobWorker
public void processOrder(
  @ProcessInstanceKey String processInstanceKey,
  @ElementInstanceKey long elementInstanceKey,
  @JobKey Long jobKey,
  @ProcessDefinitionKey String processDefinitionKey,
  @RootProcessInstanceKey long rootProcessInstanceKey) {
  // do whatever you need to do
}
```

### Completing jobs

#### Auto-completing jobs

By default, the `autoComplete` attribute is set to `true` for any job worker.

In this case, the Spring integration will handle job completion for you:

```java
@JobWorker
public void processOrder() {
  // do whatever you need to do
  // no need to call client.newCompleteCommand()...
}
```

:::note
The code within the handler method needs to be synchronously executed, as the completion will be triggered right after the method has finished.
:::

##### Returning results

When using `autoComplete` you can return:

- a `Map<String, Object>` containing the process variables to set as result of the job
- a `String` containing a valid JSON object
- an `InputStream` streaming a valid JSON object
- an `Object` that will be serialized to a JSON object

```java
@JobWorker
public Map<String, Object> processOrder() {
  // some work
  if (successful) {
    // some data is returned to be stored as process variable
    return variablesMap;
  } else {
    // problem shall be indicated to the process:
    throw new BpmnError("DOESNT_WORK", "This does not work because...");
  }
}
```

##### Documents as job results

If you want to send a document as job result, you can do this by making a `DocumentContext` part of the response.

It can be part of a `Map<String, Object>`:

```java
@JobWorker
public Map<String, Object> sendDocumentAsResult() {
  String resultDocumentContent = documentService.loadResult();
  Map<String, Object> result = new HashMap<>();
  result.put("resultDocument", DocumentContext.result()
          .addDocument(
              "result.json", b -> b.content(resultDocumentContent).contentType("application/json"))
          .build());
  return result;
}
```

It can also be part of an `Object`:

```java
public record DocumentResult(DocumentContext responseDocument) {}

@JobWorker
public DocumentResult sendDocumentAsResult() {
  String resultDocumentContent = documentService.loadResult();
  DocumentContext responseDocument = DocumentContext.result()
          .addDocument(
              "result.json", b -> b.content(resultDocumentContent).contentType("application/json"))
          .build());
  return new DocumentResult(responseDocument);
}
```

##### Completing ad-hoc sub-process jobs with a result

When your job worker handles an [ad-hoc sub-process](/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses.md) job, you can return an `AdHocSubProcessResultFunction` to specify which element to activate within the sub-process. The starter automatically applies the result when you complete the job.

Return a lambda that calls `activateElement` with the target element ID:

```java
@JobWorker(type = "myAdHocSubprocessJob")
public AdHocSubProcessResultFunction handleAdHocSubprocess() {
  return r -> r.activateElement("myElementId");
}
```

To also submit process variables with the result, use the `AdHocSubProcessResultFunction.withVariables` factory method:

```java
@JobWorker(type = "myAdHocSubprocessJob")
public AdHocSubProcessResultFunction handleAdHocSubprocess() {
  Map<String, Object> variables = Map.of("decision", "approved");
  return AdHocSubProcessResultFunction.withVariables(variables,
      r -> r.activateElement("approvalTask"));
}
```

##### Completing user task listener jobs with a result

When your job worker handles a user task listener job, you can return a `UserTaskResultFunction` to control the outcome of the listener. The starter automatically applies the result when you complete the job.

Return a lambda that configures the result, for example to correct the assignee:

```java
@JobWorker(type = "io.camunda:userTaskListener:complete")
public UserTaskResultFunction handleUserTaskListener() {
  return r -> r.correctAssignee("newAssignee");
}
```

#### Programmatically completing jobs

Your job worker code can also complete the job itself. This gives you more control over when you want to complete the job (for example, allowing you to move the completion to reactive callbacks):

```java
@JobWorker(autoComplete = false)
public void processOrder(final JobClient client, final ActivatedJob job) {
  // do whatever you need to do
  client.newCompleteCommand(job.getKey())
     .send()
     .exceptionally(throwable -> { throw new RuntimeException("Could not complete job " + job, throwable); });
}
```

You can also control auto-completion in your configuration.

**Globally:**

```yaml
camunda:
  client:
    worker:
      defaults:
        auto-complete: false
```

**Per worker:**

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          auto-complete: false
```

Ideally, you **don't** use blocking behavior like `send().join()`, as this is a blocking call to wait for the issued command to be executed on the workflow engine. While this is very straightforward to use and produces easy-to-read code, blocking code is limited in terms of scalability.

This is why the worker sample above shows a different pattern (using `exceptionally`). Often, you might want to use the `whenComplete` callback:

```java
send().whenComplete((result, exception) -> {})
```

This registers a callback to be executed when the command on the workflow engine was executed or resulted in an exception. This allows for parallelism. This is discussed in more detail in [this blog post about writing good workers for Camunda 8](https://blog.bernd-ruecker.com/writing-good-workers-for-camunda-cloud-61d322cad862).

:::note
When completing jobs programmatically, you must specify `autoComplete = false`. Otherwise, there is a race condition between your programmatic job completion and the Spring integration job completion, and this can lead to unpredictable results.
:::

### React to problems

#### Throw a `BpmnError`

If your code encounters a problem that should trigger a [BPMN error](/components/modeler/bpmn/error-events/error-events.md), throw a `BpmnError` and provide the error code defined in BPMN:

```java
@JobWorker
public void processOrder() {
  // some work
  if (businessError) {
    // problem shall be indicated to the process:
    throw CamundaError.bpmnError("ERROR_CODE", "Some explanation why this does not work");
    // this is a static function that returns an instance of BpmnError
  }
}
```

#### Fail jobs in a controlled way

Whenever you want a job to fail in a controlled way, you can throw a `JobError` and provide parameters like `variables`, `retries` and `retryBackoff`:

```java
@JobWorker
public void processOrder() {
  try {
    // some work
  } catch (DynamicRetryException e) {
    // problem shall be indicated to the process:
    throw CamundaError.jobError("Error message", new ErrorVariables(), null, this::calculateRetryBackoff, e);
    // this is a static function that returns an instance of JobError with a dynamic retry backoff
  } catch (StaticRetryException e) {
    // problem shall be indicated to the process:
    throw CamundaError.jobError("Error message", new ErrorVariables(), null, Duration.ofSeconds(10), e);
    // this is a static function that returns an instance of JobError with a static retry backoff
  }
}
```

The JobError takes 5 parameters:

- `errorMessage`: String
- `variables`: Object _(optional)_, default `null`
- `retries`: Integer _(optional)_, defaults to `job.getRetries() - 1`
- `retryBackoff`: Duration _or_ `Function<Integer, Duration>` _(optional)_, defaults to the configured retry backoff; function input is the retries value that will be submitted
- `cause`: Exception _(optional)_, defaults to `null`

:::note
The job error is sent to the engine by the SDK calling the [Fail Job API](/apis-tools/orchestration-cluster-api-rest/specifications/fail-job.api.mdx). The stacktrace of the job error will become the actual error message. The provided cause will be visible in Operate.
:::

#### Implicitly failing jobs

If your handler method would throw any other exception than the ones listed above, the default Camunda Client error handling will apply, decrementing retries with a `retryBackoff` of 0.

### Configuring the job worker thread pool

The number of threads for invocation of job workers (default 1):

```yaml
camunda:
  client:
    execution-threads: 2
```

:::note
We generally do not advise using a thread pool for workers, but rather implement asynchronous code, see [writing good workers](/components/best-practices/development/writing-good-workers.md) for additional details.
:::

### Further job worker configuration options

#### Disable a job worker

You can disable workers via the `enabled` parameter of the `@JobWorker` annotation:

```java
@JobWorker(enabled = false)
public void processOrder() {
  // worker's code - now disabled
}
```

You can also override this setting via your `application.yaml` file:

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          enabled: false
```

This is especially useful if you have a bigger code base including many workers, but want to start only some of them. Typical use cases are:

- Testing: You only want one specific worker to run at a time.
- Load balancing: You want to control which workers run on which instance of cluster nodes.
- Migration: There are two applications, and you want to migrate a worker from one to another. With this switch, you can disable workers via configuration in the old application once they are available within the new.

To disable all workers, but still have the Camunda client available, you can use:

```yaml
camunda:
  client:
    worker:
      defaults:
        enabled: false
```

#### Configure jobs in flight

Number of jobs for a worker that are polled from the broker to be worked on in this client:

```java
@JobWorker(maxJobsActive = 64)
public void processOrder() {
  // worker's code
}
```

This can also be configured as property:

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          max-jobs-active: 64
```

To configure a global default, you can set:

```yaml
camunda:
  client:
    worker:
      defaults:
        max-jobs-active: 64
```

#### Enable job streaming

Read more about this feature in the [job streaming documentation](/apis-tools/java-client/job-worker.md#job-streaming).

Job streaming is disabled by default for job workers. To enable job streaming on the Camunda client, configure it as follows:

```java
@JobWorker(streamEnabled = true)
public void processOrder() {
  // worker's code
}
```

This can also be configured as property:

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          stream-enabled: true
```

To configure a global default, you can set:

```yaml
camunda:
  client:
    worker:
      defaults:
        stream-enabled: true
```

#### Control tenant usage

Job workers can be configured to work on jobs from specific [tenants](#multi-tenancy) using either [specific tenant IDs](#filtering-by-provided-tenant-IDs) or the [assigned tenants in the engine](#filtering-by-assigned-tenants).

##### Filter by assigned tenants

You can configure a job worker to use the tenants assigned to it in the engine, rather than providing explicit tenant IDs. Use the `tenantFilter` annotation property with `TenantFilter.ASSIGNED`:

```java
@JobWorker(tenantFilter = TenantFilter.ASSIGNED)
public void processOrder() {
  // worker's code
}
```

When `TenantFilter.ASSIGNED` is set, any `tenant-ids` configured via the annotation or YAML are ignored.

You can also override the tenant filter for a specific worker:

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          tenant-filter: ASSIGNED
```

To configure a global default:

```yaml
camunda:
  client:
    worker:
      defaults:
        tenant-filter: ASSIGNED
```

##### Filter by provided tenant IDs

The default behaviour is `TenantFilter.PROVIDED`, where the worker retrieves jobs for the tenant IDs explicitly configured. Configure global worker defaults for additional `tenant-ids` to be used by all workers:

```yaml
camunda:
  client:
    worker:
      defaults:
        tenant-ids:
          - <default>
          - foo
```

Additionally, you can set `tenantIds` on the job worker level by using the annotation:

```java
@JobWorker(tenantIds="myOtherTenant")
public void processOrder() {
  // worker's code
}
```

You can also override the `tenant-ids` for each worker:

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          tenants-ids:
            - <default>
            - foo
```

#### Define the job timeout

To define the job timeout, you can set the annotation (`long` in milliseconds):

```java
@JobWorker(timeout=60000)
public void processOrder() {
  // worker's code
}
```

Moreover, you can override the timeout for the worker (as ISO 8601 duration expression):

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          timeout: PT1M
```

You can also set a global default:

```yaml
camunda:
  client:
    worker:
      defaults:
        timeout: PT1M
```

#### Configure the retry backoff

If you want to apply a retry backoff that should be applied if a job fails without a job error, you can set the annotation (`long` in milliseconds):

```java
@JobWorker(retryBackoff=10000L)
public void processOrder() {
  // worker's code
}
```

Moreover, you can override the retry backoff for the worker (as ISO 8601 duration expression):

```yaml
camunda:
  client:
    worker:
      override:
        processOrder:
          retry-backoff: PT10S
```

You can also set a global default:

```yaml
camunda:
  client:
    worker:
      defaults:
        retry-backoff: PT10S
```

## Deploy resources on start-up

To deploy process models at application startup, use the `@Deployment` annotation:

```java
@Deployment(resources = "classpath:demoProcess.bpmn")
public class MyRandomBean {
  // make sure this bean is registered
}
```

### Specify resources to deploy

This annotation uses the [Spring resource loader](https://docs.spring.io/springframework/reference/core/resources.html) and can deploy multiple files at once. For example:

```java
@Deployment(resources = {"classpath:demoProcess.bpmn" , "classpath:demoProcess2.bpmn"})
```

Or, define wildcard patterns:

```java
@Deployment(resources = "classpath*:/bpmn/**/*.bpmn")
```

The resource loader automatically searches the entire classpath, including dependency JARs. To deploy only the resources packaged with the annotated class, use:

```java
@Deployment(resources = "classpath*:/bpmn/**/*.bpmn", ownJarOnly = true)
```

You can also set this globally:

```yaml
camunda:
  client:
    deployment:
      own-jar-only: true
```

### Specify the tenant to deploy to

To adjust the tenant to deploy to, set the `tenantId` property of the `@Deployment` annotation:

```java
@Deployment(resources = "classpath:demoProcess.bpmn", tenantId = "myTenant")
public class MyRandomBean {
  // make sure this bean is registered
}
```

By default, the starter uses the `tenantId` from `camunda.client.tenant-id`.

### Disable deployment

To disable the deployment of annotations, you can set:

```yaml
camunda:
  client:
    deployment:
      enabled: false
```

## Set cluster variables at startup

To set cluster variables at application startup, use the `@ClusterVariables` annotation. Cluster variables are set when the Camunda client starts.

There are three ways to provide the variables:

### From JSON resource files

Provide one or more JSON resource files using the `resources` attribute:

```java
@ClusterVariables(resources = "classpath:cluster-variables.json")
@SpringBootApplication
public class MyApplication { }
```

Multiple files can be provided at once:

```java
@ClusterVariables(resources = {"classpath:vars-a.json", "classpath:vars-b.json"})
@SpringBootApplication
public class MyApplication { }
```

### From a method

Annotate a method with `@ClusterVariables`. The return value is serialized to JSON and set as cluster variables. Any type the configured `JsonMapper` can serialize is supported, for example `Map`, a POJO, or a record:

```java
@ClusterVariables
public MyConfig clusterVariables() {
  return new MyConfig("production", 3);
}
```

### From application properties

Define variables directly in your `application.yaml`:

```yaml
camunda:
  client:
    cluster-variables:
      global:
        environment: production
        maxRetries: 3
```

Variables defined in properties are applied in addition to any annotation-defined variables.

### Specify the tenant to set variables for

To set cluster variables scoped to a specific tenant, use the `tenantId` property of the `@ClusterVariables` annotation:

```java
@ClusterVariables(resources = "classpath:cluster-variables.json", tenantId = "myTenant")
@SpringBootApplication
public class MyApplication { }
```

Or use the `tenant` property in your `application.yaml`:

```yaml
camunda:
  client:
    cluster-variables:
      tenant:
        myTenant:
          environment: staging
          maxRetries: 5
```

By default, the annotation and `global` property set variables in the global scope.

### Disable cluster variable processing

To disable all cluster variable processing (both annotation-based and property-based), set:

```yaml
camunda:
  client:
    cluster-variables:
      enabled: false
```

## React to events

The Camunda Spring Boot Starter integrates with Spring events and also publishes its own events.

### Camunda client lifecycle events

#### Camunda client created

To react when the Camunda client is created, add an event listener:

```java
@EventListener
public void onCamundaClientCreated(CamundaClientCreatedEvent event) {
  // do what you need to do
}
```

#### Camunda client closing event

To react on the closing of the Camunda client, you can do this:

```java
@EventListener
public void onCamundaClientClosing(CamundaClientClosingEvent event) {
  // do what you need to do
}
```

#### Lifecycle aware interface

To subscribe to the Camunda client lifecycle at once, you can also use an interface:

```java
@Component
public class CamundaLifecycleListener implements CamundaClientLifecycleAware {
  @Override
  public void onStart(CamundaClient client) {
    // do what you need to do
  }

  @Override
  public void onStop(CamundaClient client) {
    // do what you need to do
  }
}
```

### Post deployment event

To react on the creation of [deployments on start-up](#deploying-resources-on-start-up), you can do this:

```java
@EventListener
public void onDeploymentCreated(CamundaPostDeploymentEvent event) {
  // do what you need to do
}
```

The event will grant you access to a list of deployments that have been created.

## Observe metrics

The Camunda Spring Boot Starter provides some out-of-the-box metrics that can be leveraged via [Spring Actuator](https://docs.spring.io/spring-boot/docs/current/actuator-api/htmlsingle/). Whenever actuator is on the classpath, you can access the following metrics:

- `camunda.job.invocations`: Number of invocations of job workers (tagging the job type)

For all of those metrics, the following actions are recorded:

- `activated`: The job was activated and started to process an item.
- `completed`: The processing was completed successfully.
- `failed`: The processing failed with some exception.
- `bpmn-error`: The processing completed by throwing a BPMN error (which means there was no technical problem).

In a default setup, you can enable metrics to be served via http:

```yaml
management:
  endpoints:
    web:
      exposure:
        include: metrics
```

Access them via [http://localhost:8080/actuator/metrics/](http://localhost:8080/actuator/metrics/).

---

## Camunda Spring Boot Starter

<PageDescription />

## About

The Camunda Spring Boot Starter is the official way to integrate Camunda 8 APIs ([gRPC](/apis-tools/zeebe-api/grpc.md) and [REST](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md)) into your Spring Boot project. You can use it to orchestrate microservices, manage human tasks, and interact with process data using idiomatic Spring Boot patterns.

:::info Public API
The Camunda Spring Boot Starter is part of the Camunda 8 [public API](/reference/public-api.md) and follows [Semantic Versioning](https://semver.org/) (except for alpha features). Minor and patch releases will not introduce breaking changes.
:::

:::info Migration from Spring Zeebe SDK
**The Camunda Spring Boot Starter replaces the Spring Zeebe SDK as of version 8.8.**

- Uses the new Camunda Java Client under the hood
- REST is the default protocol (gRPC is configurable)
- Spring Zeebe SDK will be **removed in version 8.10**
- **Migrate before upgrading to 8.10** to avoid breaking changes

See the [migration guide](/reference/announcements-release-notes/880/880-announcements.md#camunda-java-client-and-camunda-spring-boot-starter) for details.
:::

## What you can build with it

With the Camunda Spring Boot Starter, you can build:

- **Job workers** that perform automated tasks and call external systems (APIs, databases, file systems)
- **Integration services** that connect Camunda processes with existing systems or third-party services
- **Data processing applications** that use process data for visualization, analytics, or business intelligence

## Version compatibility

| Camunda Spring Boot Starter artifact | Camunda Spring Boot Starter version | JDK  | Bundled Spring Boot version | Compatible Spring Boot version(s) |
| ------------------------------------ | ----------------------------------- | ---- | --------------------------- | --------------------------------- |
| `camunda-spring-boot-starter`        | 8.10.x                              | ≥ 17 | 4.1.x                       |                                   |
| `camunda-spring-boot-4-starter`      | 8.10.x                              | ≥ 17 | 4.1.x                       |                                   |
| `camunda-spring-boot-3-starter`      | 8.10.x                              | ≥ 17 | 3.5.x                       |                                   |

For Spring Boot OSS and Commercial support dates, see the [Spring Boot support timeline](https://spring.io/projects/spring-boot#support).

### Dedicated Spring Boot 3 and 4 modules

Starting with Camunda 8.10, the default `camunda-spring-boot-starter` artifact is bundled with **Spring Boot 4.1.x**. Additionally, two dedicated modules are available:

- **`camunda-spring-boot-4-starter`**: Identical to `camunda-spring-boot-starter`. Use this if you want to explicitly target Spring Boot 4.1.x.
- **`camunda-spring-boot-3-starter`**: Bundled with Spring Boot 3.5.x. Use this if your application is not yet ready to upgrade to Spring Boot 4.1.x.

:::caution Spring Boot 3.5.x OSS support window
Spring's open source support for Spring Boot 3.5.x ended in June 2026 (see [Spring Boot support timeline](https://spring.io/projects/spring-boot#support)). Camunda continues to support and maintain `camunda-spring-boot-3-starter` until the end of Spring Commercial support for Spring Boot 3.x.

What this means for your application:

- **Camunda's starter:** Camunda continues to release patches for `camunda-spring-boot-3-starter` until the end of Spring Commercial support.
- **Spring framework patches:** After June 2026, Spring will no longer provide open-source security or bug-fix patches for Spring Boot 3.x. Security patches remain available through Spring Commercial support (Broadcom).
  :::

For details on how Camunda handles major version transitions and end-of-support windows, see [Spring Boot/Framework/Security updates](/reference/announcements-release-notes/release-policy.md#spring-bootframeworksecurity-updates).

To use the Spring Boot 3 module, replace the default dependency in your project:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-spring-boot-3-starter</artifactId>
  <version>8.9.x</version>
</dependency>
```

## Get started

### Step 1: Add the dependency

Add the Camunda Spring Boot Starter to your project:

**Maven:**

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-spring-boot-starter</artifactId>
  <version>8.9.x</version>
</dependency>
```

### Step 2: Enable the Java Compiler `-parameters` flag (optional)

If you want to use parameter names for process variables without specifying annotation values, enable the Java compiler flag `-parameters`.

**Maven:**

```xml
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <compilerArgs>
          <arg>-parameters</arg>
        </compilerArgs>
      </configuration>
    </plugin>
  </plugins>
</build>
```

If you are using Gradle:

```xml
tasks.withType(JavaCompile) {
    options.compilerArgs << '-parameters'
}
```

If you are using IntelliJ:

```agsl
Settings > Build, Execution, Deployment > Compiler > Java Compiler
```

### Step 3a: Configure the Orchestration Cluster connection for Self-Managed

Set up your connection and authentication in `application.yaml` as shown below. Choose the mode and authentication method for your environment.

Choose the authentication method and gRPC/REST address for your environment:

<Tabs groupId="authentication" defaultValue="no-auth" queryString values={[
{label: 'No Authentication', value: 'no-auth' },
{label: 'Basic Authentication', value: 'basic-auth' },
{label: 'OIDC-based Authentication', value: 'oidc' },
]}>

<TabItem value="no-auth">
By default, no authentication will be used.

```yaml
camunda:
  client:
    mode: self-managed
    auth:
      method: none
    grpc-address: https://my-grpc-address
    rest-address: https://my-rest-address
```

</TabItem>
<TabItem value="basic-auth">
To activate basic authentication:

```yaml
camunda:
  client:
    mode: self-managed
    auth:
      method: basic
      username: <your username>
      password: <your password>
    grpc-address: https://my-grpc-address
    rest-address: https://my-rest-address
```

</TabItem>
<TabItem value="oidc">

If you set up a [Self-Managed cluster with OIDC](/self-managed/deployment/helm/configure/authentication-and-authorization/index.md), you must configure the accompanying client credentials:

```yaml
camunda:
  client:
    mode: self-managed
    auth:
      method: oidc
      client-id: <your client id>
      client-secret: <your client secret>
      issuer-url: http://localhost:18080/auth/realms/camunda-platform
      audience: <your client id of Orchestration Cluster or configured audience>
      scope: <your client id of Orchestration Cluster or configured audience>
    grpc-address: https://my-grpc-address
    rest-address: https://my-rest-address
```

:::note
Ensure all addresses use absolute URI format: `scheme://host(:port)`.
:::

**Notes for Microsoft Entra ID**

- Use `scope: CLIENT_ID_OC + "/.default"` instead of `scope: CLIENT_ID_OC`.
- The `issuer-url` is typically in the format:

```
https://login.microsoftonline.com/<Microsoft Entra tenant ID>/v2.0
```

:::note Audience validation
If you have [configured the audiences property for the Orchestration Cluster (`camunda.security.authentication.oidc.audiences`)](/self-managed/components/orchestration-cluster/core-settings/configuration/properties.md#camunda.security.authentication.oidc), the Orchestration Cluster will validate the audience claim in the token against the configured audiences.

Make sure your token includes the correct audience from the Orchestration Cluster configuration, or add your audience to the configuration. Often this is the client ID you used when setting up the Orchestration Cluster.
:::

</TabItem>
</Tabs>

### Step 3b: Configure the Orchestration Cluster connection for SaaS

Set up your connection and authentication in `application.yaml` as shown below:

```yaml
camunda:
  client:
    mode: saas
    auth:
      client-id: <your client id>
      client-secret: <your client secret>
    cloud:
      cluster-id: <your cluster id>
      region: <your region>
```

## Start building your process application

With your project configured, you are ready to build your process application. Below are the core operations you'll typically perform, along with guidance on the next steps.

### Inject the Camunda client

You can inject the Camunda client and work with it to create new workflow instances, for example:

```java
@Autowired
private CamundaClient client;
```

## Implement the job worker

Declare a method on a bean. By default, the method name is used as the job type, so you only need the annotation:

```java
@JobWorker
public void processOrder() {
  // handles jobs of type 'processOrder'
}
```

To inject specific process variables as typed parameters, use `@Variable`:

```java
@JobWorker
public void processOrder(@Variable String orderId, @Variable BigDecimal amount) {
  // only 'orderId' and 'amount' are fetched; types are enforced automatically
}
```

To learn about all options you have with job workers, check out the [configuration](./configuration.md#job-worker-configuration-options) page.

## Deploy process models

To deploy process models on application start-up, use the `@Deployment` annotation:

```java
@SpringBootApplication
@Deployment(resources = "classpath:demoProcess.bpmn")
public class MySpringBootApplication {
```

To learn about all options about the usage of the `@Deployment` annotation, check out the [configuration](./configuration.md#deploying-resources-on-start-up) page.

**Need help?**

- [Camunda Community Forum](https://forum.camunda.io/) – Get help from the community.
- [GitHub repository](https://github.com/camunda/camunda) – Report issues and contribute.

---

## Properties reference

Properties for the Camunda Spring Boot Starter.

## Properties

<Tabs groupId="property-format" defaultValue="property" queryString values={
[
{label: 'Configuration property', value: 'property' },
{label: 'Environment variable', value: 'env' },
]
}>
</Tabs>

### `camunda.client`

Properties for the Camunda client.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.ca-certificate-path" env="CAMUNDA_CLIENT_CACERTIFICATEPATH"/>

The path to a root Certificate Authority (CA) certificate to use instead of the certificate in the default store.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.enabled" env="CAMUNDA_CLIENT_ENABLED"/>

Enable or disable the Camunda client. If disabled, the client bean is not created.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.execution-threads" env="CAMUNDA_CLIENT_EXECUTIONTHREADS"/>

The number of threads for invocation of job workers.

Type: <code>integer</code>

  <code>1</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.grpc-address" env="CAMUNDA_CLIENT_GRPCADDRESS"/>

The gRPC address of Camunda that the client can connect to. The address must be an absolute URL, including the scheme. An alternative default is set by both `camunda.client.mode`.

Type: <code>url</code>

  <code>&quot;http:&#x2F;&#x2F;0.0.0.0:26500&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.keep-alive" env="CAMUNDA_CLIENT_KEEPALIVE"/>

The time interval between keep-alive messages sent to the gateway.

Type: <code>duration</code>

  <code>&quot;PT45S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.max-http-connections" env="CAMUNDA_CLIENT_MAXHTTPCONNECTIONS"/>

The maximum number of concurrent HTTP connections the client can open.

Type: <code>integer</code>

  <code>100</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.max-message-size" env="CAMUNDA_CLIENT_MAXMESSAGESIZE"/>

A custom `maxMessageSize` sets the maximum inbound message size the client can receive from Camunda. It specifies the `maxInboundMessageSize` of the gRPC channel.

Type: <code>dataSize</code>

  <code>&quot;5MB&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.max-metadata-size" env="CAMUNDA_CLIENT_MAXMETADATASIZE"/>

A custom `maxMetadataSize` sets the maximum inbound metadata size the client can receive from Camunda. It specifies the `maxInboundMetadataSize` of the gRPC channel.

Type: <code>dataSize</code>

  <code>&quot;16KB&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.message-time-to-live" env="CAMUNDA_CLIENT_MESSAGETIMETOLIVE"/>

The default time-to-live for a message when no value is provided.

Type: <code>duration</code>

  <code>&quot;PT1H&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.mode" env="CAMUNDA_CLIENT_MODE"/>

The client mode to use. If not set, `saas` mode is detected based on the presence of a `camunda.client.cloud.cluster-id`.

Type: <code>enum[self-managed, saas]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.override-authority" env="CAMUNDA_CLIENT_OVERRIDEAUTHORITY"/>

Overrides the authority used with TLS virtual hosting to change hostname verification during the TLS handshake. It does not change the actual host connected to.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.physical-tenant-id" env="CAMUNDA_CLIENT_PHYSICALTENANTID"/>

The physical tenant ID sent as the `camunda-physical-tenant` gRPC header on every outgoing call. When `null` the header is omitted.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.prefer-rest-over-grpc" env="CAMUNDA_CLIENT_PREFERRESTOVERGRPC"/>

If `true`, prefers REST over gRPC for operations supported by both protocols.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.prefix-physical-tenant-path" env="CAMUNDA_CLIENT_PREFIXPHYSICALTENANTPATH"/>

If true, prefixes the REST base path with the physical tenant path when a physical tenant ID is set. Set to false to use the configured REST address as is, for example behind a reverse proxy that already routes to the physical tenant.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.request-timeout" env="CAMUNDA_CLIENT_REQUESTTIMEOUT"/>

The request timeout to use when not overridden by a specific command.

Type: <code>duration</code>

  <code>&quot;PT10S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.request-timeout-offset" env="CAMUNDA_CLIENT_REQUESTTIMEOUTOFFSET"/>

The request timeout client offset applies to commands that also pass the request timeout to the server. It ensures the client timeout occurs after the server timeout. For these commands, the client-side timeout equals the request timeout plus the offset.

Type: <code>duration</code>

  <code>&quot;PT1S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.rest-address" env="CAMUNDA_CLIENT_RESTADDRESS"/>

The REST API address of the Camunda instance that the client can connect to. The address must be an absolute URL, including the scheme. An alternative default is set by both `camunda.client.mode`.

Type: <code>url</code>

  <code>&quot;http:&#x2F;&#x2F;0.0.0.0:8080&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.tenant-id" env="CAMUNDA_CLIENT_TENANTID"/>

The tenant ID used for tenant-aware commands when no tenant ID is set.

Type: <code>string</code>

  <code>&quot;&lt;default&gt;&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.use-client-side-load-balancing" env="CAMUNDA_CLIENT_USECLIENTSIDELOADBALANCING"/>

If `true`, enables client-side load balancing by using DNS-based resolution and distributing requests across all resolved addresses. Useful for setups without an external load balancer, such as Docker Compose, Testcontainers, or Kubernetes headless services.

Type: <code>boolean</code>

  <code>false</code>

### `camunda.client.auth`

Properties for authenticating the Camunda client.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.audience" env="CAMUNDA_CLIENT_AUTH_AUDIENCE"/>

The resource for which the access token must be valid. A default is set by `camunda.client.mode: saas` and `camunda.client.auth.method: oidc`.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-id" env="CAMUNDA_CLIENT_AUTH_CLIENTID"/>

The client ID to use when requesting an access token from the OAuth authorization server.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-secret" env="CAMUNDA_CLIENT_AUTH_CLIENTSECRET"/>

The client secret to use when requesting an access token from the OAuth authorization server.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.connect-timeout" env="CAMUNDA_CLIENT_AUTH_CONNECTTIMEOUT"/>

The connection timeout for requests to the OAuth credentials provider.

Type: <code>duration</code>

  <code>&quot;PT5S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.credentials-cache-path" env="CAMUNDA_CLIENT_AUTH_CREDENTIALSCACHEPATH"/>

The path to the credentials cache file. If unset or empty, the OAuth provider caches credentials only in memory and does not persist them across restarts. Set this to a writable path to opt in to persistent file-based caching. See issue #13124.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.issuer-url" env="CAMUNDA_CLIENT_AUTH_ISSUERURL"/>

The url of the issuer for the access token. It is used to generate the well-known configuration url from which the `token-url` is retrieved. Only applied if the `camunda.client.auth.well-known-configuration-url` is not set. A default is set by `camunda.client.auth.method: oidc`.

Type: <code>url</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.keystore-key-password" env="CAMUNDA_CLIENT_AUTH_KEYSTOREKEYPASSWORD"/>

The keystore key password for the OAuth identity provider.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.keystore-password" env="CAMUNDA_CLIENT_AUTH_KEYSTOREPASSWORD"/>

The keystore password for the OAuth identity provider.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.keystore-path" env="CAMUNDA_CLIENT_AUTH_KEYSTOREPATH"/>

The path to the keystore for the OAuth identity provider.

Type: <code>file</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.method" env="CAMUNDA_CLIENT_AUTH_METHOD"/>

The authentication method to use. If not set, it is detected based on the presence of a username, password, client ID, and client secret. A default is set by `camunda.client.mode: saas`.

Type: <code>enum[none, basic, oidc]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.password" env="CAMUNDA_CLIENT_AUTH_PASSWORD"/>

The password to be use for basic authentication. A default is set by `camunda.client.auth.method: basic`.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.proactive-token-refresh-threshold" env="CAMUNDA_CLIENT_AUTH_PROACTIVETOKENREFRESHTHRESHOLD"/>

Controls how far before token expiry a background refresh is triggered. The token remains valid within this window, so callers don't block on a synchronous refresh at expiry. Must be strictly greater than the internal expiry grace period.

Type: <code>duration</code>

  <code>&quot;PT30S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.read-timeout" env="CAMUNDA_CLIENT_AUTH_READTIMEOUT"/>

The data read timeout for requests to the OAuth credentials provider.

Type: <code>duration</code>

  <code>&quot;PT5S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.resource" env="CAMUNDA_CLIENT_AUTH_RESOURCE"/>

The resource for which the access token must be valid.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.scope" env="CAMUNDA_CLIENT_AUTH_SCOPE"/>

The scopes of the access token.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-fetch-backoff-multiplier" env="CAMUNDA_CLIENT_AUTH_TOKENFETCHBACKOFFMULTIPLIER"/>

The multiplier applied to the backoff duration between successive token fetch retry attempts. Must be greater than or equal to 1.0.

Type: <code>double</code>

  <code>2</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-fetch-initial-backoff" env="CAMUNDA_CLIENT_AUTH_TOKENFETCHINITIALBACKOFF"/>

The initial backoff duration applied between token fetch retry attempts. Each subsequent delay is multiplied by `camunda.client.auth.token-fetch-backoff-multiplier`.

Type: <code>duration</code>

  <code>&quot;PT1S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-fetch-max-retries" env="CAMUNDA_CLIENT_AUTH_TOKENFETCHMAXRETRIES"/>

The maximum number of attempts (including the initial one) when fetching a token from the OAuth authorization server. Retries are only attempted on IOException or HTTP status codes configured via `token-fetch-retryable-status-codes`.

Type: <code>integer</code>

  <code>5</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-fetch-non-retryable-cooldown" env="CAMUNDA_CLIENT_AUTH_TOKENFETCHNONRETRYABLECOOLDOWN"/>

If the token endpoint returns a non-retryable response, subsequent token fetch attempts fail immediately without making a request. This property specifies the duration of this cooldown period. After the cooldown period elapses, the next request retries; if it also fails with a non-retryable error, the cooldown resets. Set to `duration.zero` to disable the cooldown.

Type: <code>duration</code>

  <code>&quot;PT5M&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-fetch-retryable-status-codes" env="CAMUNDA_CLIENT_AUTH_TOKENFETCHRETRYABLESTATUSCODES"/>

The set of HTTP status codes from the token endpoint that are retried with backoff. Any other non-200 status code triggers the `camunda.client.auth.token-fetch-non-retryable-cooldown` cooldown.

Type: <code>array[integer]</code>

  <code>[404,429,500,502,503,504]</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-url" env="CAMUNDA_CLIENT_AUTH_TOKENURL"/>

The authorization server URL from which to request the access token. A default is set by `camunda.client.mode: saas`.

Type: <code>url</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.truststore-password" env="CAMUNDA_CLIENT_AUTH_TRUSTSTOREPASSWORD"/>

The truststore password for the OAuth identity provider.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.truststore-path" env="CAMUNDA_CLIENT_AUTH_TRUSTSTOREPATH"/>

The path to the truststore for the OAuth identity provider.

Type: <code>file</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.username" env="CAMUNDA_CLIENT_AUTH_USERNAME"/>

The username to use for basic authentication. A default is set by `camunda.client.auth.method: basic`.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.well-known-configuration-url" env="CAMUNDA_CLIENT_AUTH_WELLKNOWNCONFIGURATIONURL"/>

The url of the well-known configuration of the issuer. It is used to retrieve the `token-url`. Only applied if `camunda.client.auth.token-url` is not set.

Type: <code>url</code>

  <code>null</code>

### `camunda.client.auth.client-assertion`

Properties for OIDC authentication using a client assertion instead of a client secret.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-assertion.keystore-key-alias" env="CAMUNDA_CLIENT_AUTH_CLIENTASSERTION_KEYSTOREKEYALIAS"/>

The alias of the key containing the certificate used to sign the client assertion certificate. If not set, the first alias from the keystore is used.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-assertion.keystore-key-password" env="CAMUNDA_CLIENT_AUTH_CLIENTASSERTION_KEYSTOREKEYPASSWORD"/>

The password of the key referenced by the alias. If not set, the keystore password is used.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-assertion.keystore-password" env="CAMUNDA_CLIENT_AUTH_CLIENTASSERTION_KEYSTOREPASSWORD"/>

The password of the referenced keystore.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-assertion.keystore-path" env="CAMUNDA_CLIENT_AUTH_CLIENTASSERTION_KEYSTOREPATH"/>

The path to the keystore where the client assertion certificate is stored.

Type: <code>file</code>

  <code>null</code>

### `camunda.client.cloud`

Properties for connecting the Camunda client to SaaS. These are used to compose default connection details when the client is configured to `camunda.client.mode: saas`.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.cluster-id" env="CAMUNDA_CLIENT_CLOUD_CLUSTERID"/>

The cluster ID the Camunda client connects to.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.domain" env="CAMUNDA_CLIENT_CLOUD_DOMAIN"/>

The domain the Camunda client connects to. Change this to connect to a non-production instance of Camunda Cloud.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.port" env="CAMUNDA_CLIENT_CLOUD_PORT"/>

The port the Camunda client connects to.

Type: <code>integer</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.region" env="CAMUNDA_CLIENT_CLOUD_REGION"/>

The region the Camunda client connects to.

Type: <code>string</code>

  <code>null</code>

### `camunda.client.cluster-variables`

Properties for setting cluster variables at startup.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cluster-variables.enabled" env="CAMUNDA_CLIENT_CLUSTERVARIABLES_ENABLED"/>

Indicates if cluster variable processing is enabled. When `true`, variables configured via `@ClusterVariables` annotations and via the `global`/`tenant` properties are applied at startup. When `false`, all cluster variable processing is skipped.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cluster-variables.global" env="CAMUNDA_CLIENT_CLUSTERVARIABLES_GLOBAL"/>

Globally-scoped cluster variables to set at startup as key-value pairs.

Type: <code>map[string,object]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cluster-variables.tenant" env="CAMUNDA_CLIENT_CLUSTERVARIABLES_TENANT"/>

Tenant-scoped cluster variables to set at startup, keyed by tenant ID.

Type: <code>map[string,map[string,object]]</code>

  <code>null</code>

### `camunda.client.deployment`

Properties for automatic deployment at startup.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.deployment.enabled" env="CAMUNDA_CLIENT_DEPLOYMENT_ENABLED"/>

Indicates if the `@Deployment` annotation is processed.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.deployment.own-jar-only" env="CAMUNDA_CLIENT_DEPLOYMENT_OWNJARONLY"/>

Indicates if the resources selected by the deployment annotation have to reside in the same jar as the annotated class. This property acts as the default behavior. If the `@Deployment` annotation explicitly sets its `ownJarOnly` parameter, that annotation-level value overrides this property for the annotated deployment.

Type: <code>boolean</code>

  <code>false</code>

### `camunda.client.worker.defaults`

Global default properties for job workers registered to the Camunda client.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.auto-complete" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_AUTOCOMPLETE"/>

Enable or disable automatic job completion after method invocation.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.enabled" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_ENABLED"/>

Enable or disable the job worker.

Type: <code>boolean</code>

  <code>true</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.fetch-variables" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_FETCHVARIABLES"/>

List of variable names to fetch on job activation. When set in defaults, it extends the list of variables to fetch from the annotation. When set in an override, it replaces the list of variables to fetch.

Type: <code>array[string]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.force-fetch-all-variables" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_FORCEFETCHALLVARIABLES"/>

Sets whether all variables are fetched. Overrides `fetch-variables`.

Type: <code>boolean</code>

  <code>false</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.max-jobs-active" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_MAXJOBSACTIVE"/>

The maximum number of jobs exclusively activated for this worker at the same time.

Type: <code>integer</code>

  <code>32</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.max-retries" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_MAXRETRIES"/>

The maximum number of retries before automatic responses (complete, fail, bpmn error) for jobs are no longer attempted.

Type: <code>integer</code>

  <code>0</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.name" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_NAME"/>

The name of the worker owner. If set to default, it is generated as `${beanName}#${methodName}`.

Type: <code>string</code>

  <code>&quot;default&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.poll-interval" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_POLLINTERVAL"/>

The maximal interval between polls for new jobs.

Type: <code>duration</code>

  <code>&quot;PT0.1S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.request-timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_REQUESTTIMEOUT"/>

The request timeout for the activate job request used to poll for new jobs.

Type: <code>duration</code>

  <code>&quot;PT10S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.retry-backoff" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_RETRYBACKOFF"/>

The backoff before a retry of a failed job is possible.

Type: <code>duration</code>

  <code>&quot;PT0S&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.stream-enabled" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_STREAMENABLED"/>

Opt-in feature flag that enables job streaming. When enabled, the job worker uses both streaming and polling to activate jobs. A long-lived stream eagerly pushes new jobs, and polling retrieves jobs created before any streams were opened.

Type: <code>boolean</code>

  <code>false</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.stream-inactivity-timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_STREAMINACTIVITYTIMEOUT"/>

If streaming is enabled, sets the maximum duration the worker will wait without receiving any job on the open stream before canceling and recreating it. The timer is reset every time a job is received. Must be strictly less than `stream-timeout` when both are set.

Type: <code>duration</code>

  <code>&quot;PT10M&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.stream-timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_STREAMTIMEOUT"/>

If streaming is enabled, sets the maximum lifetime for a stream. When this timeout is reached, the stream closes, and no more jobs are activated or received. If the worker is still open, a new stream opens immediately.

Type: <code>duration</code>

  <code>&quot;PT8H&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.tenant-filter" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TENANTFILTER"/>

Sets the tenant filter for the job worker, which determines how the worker considers tenant IDs when activating jobs.

Type: <code>enum[assigned, provided]</code>

  <code>&quot;PROVIDED&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.tenant-ids" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TENANTIDS"/>

Sets the tenants for which the job worker is registered. When set in defaults, it extends the list of tenant IDs from the annotation. When set in override, it replaces the list of tenant IDs.

Type: <code>array[string]</code>

  <code>[&quot;&lt;default&gt;&quot;]</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TIMEOUT"/>

The time a job remains exclusively assigned to the worker.

Type: <code>duration</code>

  <code>&quot;PT5M&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.type" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TYPE"/>

The type of jobs to work on.

Type: <code>string</code>

  <code>null</code>

### `management.endpoint.jobworkers`

Properties for configuring the `jobworkers` management endpoint.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="management.endpoint.jobworkers.access" env="MANAGEMENT_ENDPOINT_JOBWORKERS_ACCESS"/>

Permitted level of access for the jobworkers endpoint.

Type: <code>enum[none, read_only, unrestricted]</code>

  <code>&quot;unrestricted&quot;</code>

  <Property defaultValue="property" groupId="property-format" property="management.endpoint.jobworkers.cache.time-to-live" env="MANAGEMENT_ENDPOINT_JOBWORKERS_CACHE_TIMETOLIVE"/>

Maximum time that a response can be cached.

Type: <code>duration</code>

  <code>&quot;0ms&quot;</code>

### `camunda.client.worker.override`

Properties for overriding settings of individual job workers registered to the Camunda client. The key of the override is the job type or worker name.

  
    Property
    Description
    Default value
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.auto-complete" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_AUTOCOMPLETE"/>

Enable or disable automatic job completion after method invocation.

Type: <code>boolean</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.enabled" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_ENABLED"/>

Enable or disable the job worker.

Type: <code>boolean</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.fetch-variables" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_FETCHVARIABLES"/>

List of variable names to fetch on job activation. When set in defaults, it extends the list of variables to fetch from the annotation. When set in an override, it replaces the list of variables to fetch.

Type: <code>array[string]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.force-fetch-all-variables" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_FORCEFETCHALLVARIABLES"/>

Sets whether all variables are fetched. Overrides `fetch-variables`.

Type: <code>boolean</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.max-jobs-active" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_MAXJOBSACTIVE"/>

The maximum number of jobs exclusively activated for this worker at the same time.

Type: <code>integer</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.max-retries" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_MAXRETRIES"/>

The maximum number of retries before automatic responses (complete, fail, bpmn error) for jobs are no longer attempted.

Type: <code>integer</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.name" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_NAME"/>

The name of the worker owner. If set to default, it is generated as `${beanName}#${methodName}`.

Type: <code>string</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.poll-interval" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_POLLINTERVAL"/>

The maximal interval between polls for new jobs.

Type: <code>duration</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.request-timeout" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_REQUESTTIMEOUT"/>

The request timeout for the activate job request used to poll for new jobs.

Type: <code>duration</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.retry-backoff" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_RETRYBACKOFF"/>

The backoff before a retry of a failed job is possible.

Type: <code>duration</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.stream-enabled" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_STREAMENABLED"/>

Opt-in feature flag that enables job streaming. When enabled, the job worker uses both streaming and polling to activate jobs. A long-lived stream eagerly pushes new jobs, and polling retrieves jobs created before any streams were opened.

Type: <code>boolean</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.stream-inactivity-timeout" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_STREAMINACTIVITYTIMEOUT"/>

If streaming is enabled, sets the maximum duration the worker will wait without receiving any job on the open stream before canceling and recreating it. The timer is reset every time a job is received. Must be strictly less than `stream-timeout` when both are set.

Type: <code>duration</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.stream-timeout" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_STREAMTIMEOUT"/>

If streaming is enabled, sets the maximum lifetime for a stream. When this timeout is reached, the stream closes, and no more jobs are activated or received. If the worker is still open, a new stream opens immediately.

Type: <code>duration</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.tenant-filter" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_TENANTFILTER"/>

Sets the tenant filter for the job worker, which determines how the worker considers tenant IDs when activating jobs.

Type: <code>enum[assigned, provided]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.tenant-ids" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_TENANTIDS"/>

Sets the tenants for which the job worker is registered. When set in defaults, it extends the list of tenant IDs from the annotation. When set in override, it replaces the list of tenant IDs.

Type: <code>array[string]</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.timeout" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_TIMEOUT"/>

The time a job remains exclusively assigned to the worker.

Type: <code>duration</code>

  <code>null</code>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.override.&lt;job-type|worker-name&gt;.type" env="CAMUNDA_CLIENT_WORKER_OVERRIDE_&lt;JOBTYPE|WORKERNAME&gt;_TYPE"/>

The type of jobs to work on.

Type: <code>string</code>

  <code>null</code>

## Deprecated properties

:::caution
The following properties are deprecated. See the replacement property and related hints.

The deprecated properties are still effective if their replacement is not used yet. The SDK hints on the usage of deprecated properties by logging warn statements during startup.
:::

### `camunda.client`

Deprecated properties for the Camunda client.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cluster-id" env="CAMUNDA_CLIENT_CLUSTERID"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.cluster-id" env="CAMUNDA_CLIENT_CLOUD_CLUSTERID"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.region" env="CAMUNDA_CLIENT_REGION"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.region" env="CAMUNDA_CLIENT_CLOUD_REGION"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.tenant-ids" env="CAMUNDA_CLIENT_TENANTIDS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.tenant-ids" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TENANTIDS"/>

N/A

### `camunda.client.auth`

Deprecated properties for authenticating the Camunda client.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.issuer" env="CAMUNDA_CLIENT_AUTH_ISSUER"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-url" env="CAMUNDA_CLIENT_AUTH_TOKENURL"/>

N/A

### `camunda.client.cloud`

Deprecated properties for connecting the Camunda client to SaaS. These are used to compose default connection details when the client is configured to `camunda.client.mode: saas`.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.base-url" env="CAMUNDA_CLIENT_CLOUD_BASEURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.domain" env="CAMUNDA_CLIENT_CLOUD_DOMAIN"/>

N/A

### `camunda.client.identity`

Deprecated properties for identity settings.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.identity.audience" env="CAMUNDA_CLIENT_IDENTITY_AUDIENCE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.audience" env="CAMUNDA_CLIENT_AUTH_AUDIENCE"/>

Identity is now part of Camunda.

  <Property defaultValue="property" groupId="property-format" property="camunda.client.identity.base-url" env="CAMUNDA_CLIENT_IDENTITY_BASEURL"/>

Identity is now part of Camunda.

  <Property defaultValue="property" groupId="property-format" property="camunda.client.identity.enabled" env="CAMUNDA_CLIENT_IDENTITY_ENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.enabled" env="CAMUNDA_CLIENT_ENABLED"/>

Identity is now part of Camunda.

  <Property defaultValue="property" groupId="property-format" property="camunda.client.identity.scope" env="CAMUNDA_CLIENT_IDENTITY_SCOPE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.scope" env="CAMUNDA_CLIENT_AUTH_SCOPE"/>

Identity is now part of Camunda.

### `camunda.client.zeebe`

Deprecated properties for Zeebe client settings.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.audience" env="CAMUNDA_CLIENT_ZEEBE_AUDIENCE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.audience" env="CAMUNDA_CLIENT_AUTH_AUDIENCE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.base-url" env="CAMUNDA_CLIENT_ZEEBE_BASEURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.rest-address" env="CAMUNDA_CLIENT_RESTADDRESS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.ca-certificate-path" env="CAMUNDA_CLIENT_ZEEBE_CACERTIFICATEPATH"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.ca-certificate-path" env="CAMUNDA_CLIENT_CACERTIFICATEPATH"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.enabled" env="CAMUNDA_CLIENT_ZEEBE_ENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.enabled" env="CAMUNDA_CLIENT_ENABLED"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.execution-threads" env="CAMUNDA_CLIENT_ZEEBE_EXECUTIONTHREADS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.execution-threads" env="CAMUNDA_CLIENT_EXECUTIONTHREADS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.grpc-address" env="CAMUNDA_CLIENT_ZEEBE_GRPCADDRESS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.grpc-address" env="CAMUNDA_CLIENT_GRPCADDRESS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.keep-alive" env="CAMUNDA_CLIENT_ZEEBE_KEEPALIVE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.keep-alive" env="CAMUNDA_CLIENT_KEEPALIVE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.max-message-size" env="CAMUNDA_CLIENT_ZEEBE_MAXMESSAGESIZE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.max-message-size" env="CAMUNDA_CLIENT_MAXMESSAGESIZE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.max-metadata-size" env="CAMUNDA_CLIENT_ZEEBE_MAXMETADATASIZE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.max-metadata-size" env="CAMUNDA_CLIENT_MAXMETADATASIZE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.message-time-to-live" env="CAMUNDA_CLIENT_ZEEBE_MESSAGETIMETOLIVE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.message-time-to-live" env="CAMUNDA_CLIENT_MESSAGETIMETOLIVE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.override-authority" env="CAMUNDA_CLIENT_ZEEBE_OVERRIDEAUTHORITY"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.override-authority" env="CAMUNDA_CLIENT_OVERRIDEAUTHORITY"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.prefer-rest-over-grpc" env="CAMUNDA_CLIENT_ZEEBE_PREFERRESTOVERGRPC"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.prefer-rest-over-grpc" env="CAMUNDA_CLIENT_PREFERRESTOVERGRPC"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.request-timeout" env="CAMUNDA_CLIENT_ZEEBE_REQUESTTIMEOUT"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.request-timeout" env="CAMUNDA_CLIENT_REQUESTTIMEOUT"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.rest-address" env="CAMUNDA_CLIENT_ZEEBE_RESTADDRESS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.rest-address" env="CAMUNDA_CLIENT_RESTADDRESS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.scope" env="CAMUNDA_CLIENT_ZEEBE_SCOPE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.scope" env="CAMUNDA_CLIENT_AUTH_SCOPE"/>

N/A

### `camunda.client.zeebe.defaults`

Deprecated default properties for Zeebe job workers.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.auto-complete" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_AUTOCOMPLETE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.auto-complete" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_AUTOCOMPLETE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.enabled" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_ENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.enabled" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_ENABLED"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.fetch-variables" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_FETCHVARIABLES"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.fetch-variables" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_FETCHVARIABLES"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.force-fetch-all-variables" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_FORCEFETCHALLVARIABLES"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.force-fetch-all-variables" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_FORCEFETCHALLVARIABLES"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.max-jobs-active" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_MAXJOBSACTIVE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.max-jobs-active" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_MAXJOBSACTIVE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.max-retries" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_MAXRETRIES"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.max-retries" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_MAXRETRIES"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.name" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_NAME"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.name" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_NAME"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.poll-interval" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_POLLINTERVAL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.poll-interval" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_POLLINTERVAL"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.request-timeout" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_REQUESTTIMEOUT"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.request-timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_REQUESTTIMEOUT"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.stream-enabled" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_STREAMENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.stream-enabled" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_STREAMENABLED"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.stream-timeout" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_STREAMTIMEOUT"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.stream-timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_STREAMTIMEOUT"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.tenant-ids" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_TENANTIDS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.tenant-ids" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TENANTIDS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.timeout" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_TIMEOUT"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TIMEOUT"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.defaults.type" env="CAMUNDA_CLIENT_ZEEBE_DEFAULTS_TYPE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.type" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TYPE"/>

N/A

### `camunda.client.zeebe.deployment`

Deprecated deployment properties for Zeebe.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="camunda.client.zeebe.deployment.enabled" env="CAMUNDA_CLIENT_ZEEBE_DEPLOYMENT_ENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.deployment.enabled" env="CAMUNDA_CLIENT_DEPLOYMENT_ENABLED"/>

N/A

### `camunda.client.zeebe.override`

Deprecated properties for overriding individual job workers registered to the Camunda client. Replaced by `camunda.client.worker.override`.

### `common`

Deprecated common client properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="common.auth-url" env="COMMON_AUTHURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-url" env="CAMUNDA_CLIENT_AUTH_TOKENURL"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="common.base-url" env="COMMON_BASEURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.rest-address" env="CAMUNDA_CLIENT_RESTADDRESS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="common.client-id" env="COMMON_CLIENTID"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-id" env="CAMUNDA_CLIENT_AUTH_CLIENTID"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="common.client-secret" env="COMMON_CLIENTSECRET"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-secret" env="CAMUNDA_CLIENT_AUTH_CLIENTSECRET"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="common.enabled" env="COMMON_ENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.enabled" env="CAMUNDA_CLIENT_ENABLED"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="common.password" env="COMMON_PASSWORD"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.password" env="CAMUNDA_CLIENT_AUTH_PASSWORD"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="common.url" env="COMMON_URL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.rest-address" env="CAMUNDA_CLIENT_RESTADDRESS"/>

The REST address is the unified endpoint for all interaction with Camunda.

  <Property defaultValue="property" groupId="property-format" property="common.username" env="COMMON_USERNAME"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.username" env="CAMUNDA_CLIENT_AUTH_USERNAME"/>

N/A

### `common.keycloak`

Deprecated Keycloak-specific properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="common.keycloak.realm" env="COMMON_KEYCLOAK_REALM"/>

There is no keycloak-specific configuration for Camunda; the issuer is provided as a URL.

  <Property defaultValue="property" groupId="property-format" property="common.keycloak.token-url" env="COMMON_KEYCLOAK_TOKENURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-url" env="CAMUNDA_CLIENT_AUTH_TOKENURL"/>

There is no keycloak-specific configuration for Camunda; the issuer is provided as a URL.

  <Property defaultValue="property" groupId="property-format" property="common.keycloak.url" env="COMMON_KEYCLOAK_URL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-url" env="CAMUNDA_CLIENT_AUTH_TOKENURL"/>

There is no keycloak-specific configuration for Camunda; the issuer is provided as a URL.

### `zeebe.client`

Deprecated Zeebe client properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.apply-environment-variable-overrides" env="ZEEBE_CLIENT_APPLYENVIRONMENTVARIABLEOVERRIDES"/>

Only the environment variables belonging to the Spring SDK are applied.

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.connection-mode" env="ZEEBE_CLIENT_CONNECTIONMODE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.mode" env="CAMUNDA_CLIENT_MODE"/>

Client modes are now available.

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.default-job-worker-stream-enabled" env="ZEEBE_CLIENT_DEFAULTJOBWORKERSTREAMENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.stream-enabled" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_STREAMENABLED"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.default-job-worker-tenant-ids" env="ZEEBE_CLIENT_DEFAULTJOBWORKERTENANTIDS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.tenant-ids" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TENANTIDS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.default-tenant-id" env="ZEEBE_CLIENT_DEFAULTTENANTID"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.tenant-id" env="CAMUNDA_CLIENT_TENANTID"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.enabled" env="ZEEBE_CLIENT_ENABLED"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.enabled" env="CAMUNDA_CLIENT_ENABLED"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.request-timeout" env="ZEEBE_CLIENT_REQUESTTIMEOUT"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.request-timeout" env="CAMUNDA_CLIENT_REQUESTTIMEOUT"/>

N/A

### `zeebe.client.broker`

Deprecated Zeebe broker properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.broker.gateway-address" env="ZEEBE_CLIENT_BROKER_GATEWAYADDRESS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.grpc-address" env="CAMUNDA_CLIENT_GRPCADDRESS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.broker.grpc-address" env="ZEEBE_CLIENT_BROKER_GRPCADDRESS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.grpc-address" env="CAMUNDA_CLIENT_GRPCADDRESS"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.broker.keep-alive" env="ZEEBE_CLIENT_BROKER_KEEPALIVE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.keep-alive" env="CAMUNDA_CLIENT_KEEPALIVE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.broker.rest-address" env="ZEEBE_CLIENT_BROKER_RESTADDRESS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.rest-address" env="CAMUNDA_CLIENT_RESTADDRESS"/>

N/A

### `zeebe.client.cloud`

Deprecated Zeebe cloud connection properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.auth-url" env="ZEEBE_CLIENT_CLOUD_AUTHURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.token-url" env="CAMUNDA_CLIENT_AUTH_TOKENURL"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.base-url" env="ZEEBE_CLIENT_CLOUD_BASEURL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.domain" env="CAMUNDA_CLIENT_CLOUD_DOMAIN"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.client-id" env="ZEEBE_CLIENT_CLOUD_CLIENTID"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-id" env="CAMUNDA_CLIENT_AUTH_CLIENTID"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.client-secret" env="ZEEBE_CLIENT_CLOUD_CLIENTSECRET"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.client-secret" env="CAMUNDA_CLIENT_AUTH_CLIENTSECRET"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.cluster-id" env="ZEEBE_CLIENT_CLOUD_CLUSTERID"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.cluster-id" env="CAMUNDA_CLIENT_CLOUD_CLUSTERID"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.credentials-cache-path" env="ZEEBE_CLIENT_CLOUD_CREDENTIALSCACHEPATH"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.credentials-cache-path" env="CAMUNDA_CLIENT_AUTH_CREDENTIALSCACHEPATH"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.port" env="ZEEBE_CLIENT_CLOUD_PORT"/>

The Zeebe client URL is now configured as HTTP&#x2F;HTTPS URL.

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.region" env="ZEEBE_CLIENT_CLOUD_REGION"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.cloud.region" env="CAMUNDA_CLIENT_CLOUD_REGION"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.cloud.scope" env="ZEEBE_CLIENT_CLOUD_SCOPE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.auth.scope" env="CAMUNDA_CLIENT_AUTH_SCOPE"/>

N/A

### `zeebe.client.job`

Deprecated Zeebe job worker properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.job.poll-interval" env="ZEEBE_CLIENT_JOB_POLLINTERVAL"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.poll-interval" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_POLLINTERVAL"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.job.timeout" env="ZEEBE_CLIENT_JOB_TIMEOUT"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.timeout" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TIMEOUT"/>

N/A

### `zeebe.client.message`

Deprecated Zeebe message properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.message.max-message-size" env="ZEEBE_CLIENT_MESSAGE_MAXMESSAGESIZE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.max-message-size" env="CAMUNDA_CLIENT_MAXMESSAGESIZE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.message.time-to-live" env="ZEEBE_CLIENT_MESSAGE_TIMETOLIVE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.message-time-to-live" env="CAMUNDA_CLIENT_MESSAGETIMETOLIVE"/>

N/A

### `zeebe.client.security`

Deprecated Zeebe security properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.security.cert-path" env="ZEEBE_CLIENT_SECURITY_CERTPATH"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.ca-certificate-path" env="CAMUNDA_CLIENT_CACERTIFICATEPATH"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.security.override-authority" env="ZEEBE_CLIENT_SECURITY_OVERRIDEAUTHORITY"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.override-authority" env="CAMUNDA_CLIENT_OVERRIDEAUTHORITY"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.security.plaintext" env="ZEEBE_CLIENT_SECURITY_PLAINTEXT"/>

plaintext is now determined by the URL protocol (HTTP or HTTPS).

### `zeebe.client.worker`

Deprecated Zeebe job worker properties.

  
    Property
    Replacement
    Hint
  

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.worker.default-name" env="ZEEBE_CLIENT_WORKER_DEFAULTNAME"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.name" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_NAME"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.worker.default-type" env="ZEEBE_CLIENT_WORKER_DEFAULTTYPE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.type" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_TYPE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.worker.max-jobs-active" env="ZEEBE_CLIENT_WORKER_MAXJOBSACTIVE"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.worker.defaults.max-jobs-active" env="CAMUNDA_CLIENT_WORKER_DEFAULTS_MAXJOBSACTIVE"/>

N/A

  <Property defaultValue="property" groupId="property-format" property="zeebe.client.worker.threads" env="ZEEBE_CLIENT_WORKER_THREADS"/>

  <Property defaultValue="property" groupId="property-format" property="camunda.client.execution-threads" env="CAMUNDA_CLIENT_EXECUTIONTHREADS"/>

N/A

### `zeebe.client.worker.override`

Deprecated properties to override the individual job workers registered with the Camunda client. Replaced by `camunda.client.worker.override`.

---

## Community-supported component clients

:::note
Camunda extensions found in the [Camunda Community Hub](https://github.com/camunda-community-hub) are maintained by the community and are not part of the commercial Camunda product. Camunda does not support community extensions as part of its commercial services to enterprise customers. Please evaluate each client to make sure it meets your requirements before using.
:::

:::tip
Camunda now officially supports the [TypeScript SDK](/apis-tools/typescript/typescript-sdk.md) and the [Camunda Spring Boot Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md).
:::

In addition to the core Camunda-maintained clients, there are a number of community-maintained component libraries:

<Tabs groupId="clients" defaultValue="zeebe" queryString values={
[
{label: 'Zeebe', value: 'zeebe' },
{label: 'Tasklist', value: 'tasklist' },
{label: 'Operate', value: 'operate' },
{label: 'Other', value: 'other' }
]}>

<TabItem value='zeebe'>

- [Ballerina](https://github.com/camunda-community-hub/ballerina-zeebe)
- [C#](https://github.com/camunda-community-hub/zeebe-client-csharp)
- [CLI](https://github.com/camunda-community-hub/zeebe-client-go/blob/main/cmd/zbctl/zbctl.md)
- [Delphi](https://github.com/camunda-community-hub/DelphiZeeBeClient)
- [EJB](https://github.com/camunda-community-hub/zeebe-ejb-client)
- [Go](https://github.com/camunda-community-hub/zeebe-client-go)
- [Micronaut](https://github.com/camunda-community-hub/micronaut-zeebe-client)
- [Python](https://gitlab.com/stephane.ludwig/zeebe_python_grpc)
- [Quarkus](https://github.com/quarkiverse/quarkus-zeebe)
- [Ruby](https://github.com/zeebe-io/zeebe-client-ruby)
- [Rust](https://github.com/camunda-community-hub/zeebest)

</TabItem>

<TabItem value='tasklist'>

- [.NET](https://github.com/camunda-community-hub/dotnet-custom-tasklist)
- [Java](https://github.com/camunda-community-hub/camunda-tasklist-client-java)

</TabItem>

<TabItem value='operate'>

- [Java](https://github.com/camunda-community-hub/camunda-operate-client-java)

</TabItem>

<TabItem value='other'>

- [Web Modeler - Java](https://github.com/camunda-community-hub/web-modeler-java-client)
- [Console - Go](https://github.com/camunda-community-hub/console-customer-api-go)

</TabItem>

</Tabs>

---

## CamundaClient


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

## Creating a Client

Factory method for creating CamundaClient instances.

```csharp
public static CamundaClient CreateClient(CamundaOptions? options = null)
```

Create a new CamundaClient.

| Parameter | Type             | Description |
| --------- | ---------------- | ----------- |
| `options` | `CamundaOptions` |             |

## Dependency Injection

Extension methods for registering `CamundaClient` in an `DependencyInjection.IServiceCollection`.

### AddCamundaClient(IServiceCollection)

```csharp
public static IServiceCollection AddCamundaClient(this IServiceCollection services)
```

Registers a singleton `CamundaClient` using zero-config (environment variables only).

| Parameter  | Type                 | Description |
| ---------- | -------------------- | ----------- |
| `services` | `IServiceCollection` |             |

### AddCamundaClient(IServiceCollection, IConfiguration)

```csharp
public static IServiceCollection AddCamundaClient(this IServiceCollection services, IConfiguration configurationSection)
```

Registers a singleton `CamundaClient` using an `Configuration.IConfiguration` section.

Typically called as `services.AddCamundaClient(configuration.GetSection("Camunda"))`. PascalCase keys in the section are mapped to canonical `CAMUNDA_*` env-var names internally. Environment variables still apply as a base layer; section values override them.

| Parameter              | Type                 | Description |
| ---------------------- | -------------------- | ----------- |
| `services`             | `IServiceCollection` |             |
| `configurationSection` | `IConfiguration`     |             |

### AddCamundaClient(IServiceCollection, Action\<CamundaOptions\>)

```csharp
public static IServiceCollection AddCamundaClient(this IServiceCollection services, Action<CamundaOptions> configure)
```

Registers a singleton `CamundaClient` with an options callback for full control.

| Parameter   | Type                     | Description |
| ----------- | ------------------------ | ----------- |
| `services`  | `IServiceCollection`     |             |
| `configure` | `Action<CamundaOptions>` |             |

## Overview

Primary Camunda client. Provides typed methods for all Camunda 8 REST API operations.

Auto-generated operation methods are added in the Generated/ partial class files. This class provides the infrastructure: configuration, auth, retry, backpressure.

```csharp
public class CamundaClient : IDisposable, IAsyncDisposable
```

## Constructor

```csharp
public CamundaClient(CamundaOptions? options = null)
```

Create a new CamundaClient with the given options.

| Parameter | Type             | Description |
| --------- | ---------------- | ----------- |
| `options` | `CamundaOptions` |             |

## Properties

| Property | Type            | Description                                     |
| -------- | --------------- | ----------------------------------------------- |
| `Config` | `CamundaConfig` | The current hydrated configuration (read-only). |

## Methods

### Other

#### Create(CamundaOptions?)

```csharp
public static CamundaClient Create(CamundaOptions? options = null)
```

Create a new CamundaClient.

| Parameter | Type             | Description |
| --------- | ---------------- | ----------- |
| `options` | `CamundaOptions` |             |

**Returns:** `CamundaClient`

#### Dispose()

```csharp
public void Dispose()
```

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

#### DisposeAsync()

```csharp
public ValueTask DisposeAsync()
```

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources asynchronously.

**Returns:** `ValueTask` — A task that represents the asynchronous dispose operation.

#### ChangeClusterModeAsync(string, bool?, CancellationToken)

```csharp
public Task<ClusterModeChangeResponse> ChangeClusterModeAsync(string mode, bool? dryRun = null, CancellationToken ct = default)
```

Change cluster mode

Transitions the cluster between processing and recovery mode. This is a non-blocking operation: the request is acknowledged once the change has been accepted, before the transition itself has completed. Entering recovery mode deactivates all partitions so that only a restricted set of read-only operations remains available; exiting recovery mode returns the cluster to normal processing. Returns the planned cluster change so its progress can be monitored via the topology.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `mode`    | `String`            |             |
| `dryRun`  | `Nullable<Boolean>` |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<ClusterModeChangeResponse>`

**Example**

```csharp
public static async Task ChangeClusterModeExample()
{
    using var client = CamundaClient.Create();

    // Pass dryRun: true to validate the request and inspect the resulting plan
    // without applying it. Omit it (or set it to false) to trigger the transition.
    var change = await client.ChangeClusterModeAsync("RECOVERING", dryRun: true);

    Console.WriteLine($"Cluster change {change.ChangeId}:");
    foreach (var operation in change.PlannedChanges)
    {
        var suffix = operation.Mode is null ? "" : $" -> {operation.Mode}";
        Console.WriteLine($"  {operation.Operation}{suffix}");
    }
}
```

#### CreateAdminUserAsync(UserRequest, CancellationToken)

```csharp
public Task<UserCreateResult> CreateAdminUserAsync(UserRequest body, CancellationToken ct = default)
```

Create admin user

Creates a new user and assigns the admin role to it. This endpoint is only usable when users are managed in the Orchestration Cluster and while no user is assigned to the admin role.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `body`    | `UserRequest`       |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<UserCreateResult>`

**Example**

```csharp
public static async Task CreateAdminUserExample(Username username)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAdminUserAsync(new UserRequest
    {
        Username = username,
        Name = "Admin User",
        Email = "admin@example.com",
        Password = "admin-password",
    });

    Console.WriteLine($"Admin user key: {result.Username}");
}
```

#### CreateAgentInstanceAsync(AgentInstanceCreationRequest, CancellationToken)

```csharp
public Task<AgentInstanceCreationResult> CreateAgentInstanceAsync(AgentInstanceCreationRequest body, CancellationToken ct = default)
```

Create agent instance

Creates a new agent instance. The returned key identifies the instance and must be used in subsequent update and query calls.

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `body`    | `AgentInstanceCreationRequest` |             |
| `ct`      | `CancellationToken`            |             |

**Returns:** `Task<AgentInstanceCreationResult>`

**Example**

```csharp
public static async Task CreateAgentInstanceExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAgentInstanceAsync(new AgentInstanceCreationRequest
    {
        ElementInstanceKey = elementInstanceKey,
        Definition = new AgentInstanceDefinition
        {
            Model = "gpt-4o",
            Provider = "openai",
            SystemPrompt = "You are a helpful assistant.",
        },
    });

    Console.WriteLine($"Created agent instance: {result.AgentInstanceKey}");
}
```

#### CreateAgentInstanceHistoryItemAsync(AgentInstanceKey, AgentInstanceHistoryItemRequest, CancellationToken)

```csharp
public Task<AgentInstanceHistoryItemCreationResult> CreateAgentInstanceHistoryItemAsync(AgentInstanceKey agentInstanceKey, AgentInstanceHistoryItemRequest body, CancellationToken ct = default)
```

Create agent instance history item

Appends a single history item to an agent instance's conversation history. The created item has commitStatus PENDING until the job identified by jobLease completes successfully, at which point it transitions to COMMITTED. If the job fails or is superseded by a retry, the item is marked DISCARDED.

| Parameter          | Type                              | Description |
| ------------------ | --------------------------------- | ----------- |
| `agentInstanceKey` | `AgentInstanceKey`                |             |
| `body`             | `AgentInstanceHistoryItemRequest` |             |
| `ct`               | `CancellationToken`               |             |

**Returns:** `Task<AgentInstanceHistoryItemCreationResult>`

**Example**

```csharp
public static async Task CreateAgentInstanceHistoryItemExample(
    AgentInstanceKey agentInstanceKey,
    ElementInstanceKey elementInstanceKey,
    JobKey jobKey,
    string jobLease)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAgentInstanceHistoryItemAsync(
        agentInstanceKey,
        new AgentInstanceHistoryItemRequest
        {
            ElementInstanceKey = elementInstanceKey,
            JobKey = jobKey,
            JobLease = jobLease,
            Role = AgentInstanceHistoryRoleEnum.ASSISTANT,
            Content = new List<AgentInstanceMessageContent>
            {
                new AgentInstanceTextContent { Text = "How can I help you today?" },
            },
            ProducedAt = DateTimeOffset.UtcNow,
        });

    Console.WriteLine($"Created history item: {result.HistoryItemKey}");
}
```

#### CreateGlobalTaskListenerAsync(CreateGlobalTaskListenerRequest, CancellationToken)

```csharp
public Task<GlobalTaskListenerResult> CreateGlobalTaskListenerAsync(CreateGlobalTaskListenerRequest body, CancellationToken ct = default)
```

Create global user task listener

Create a new global user task listener.

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `body`    | `CreateGlobalTaskListenerRequest` |             |
| `ct`      | `CancellationToken`               |             |

**Returns:** `Task<GlobalTaskListenerResult>`

**Example**

```csharp
public static async Task CreateGlobalTaskListenerExample(GlobalListenerId id)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateGlobalTaskListenerAsync(
        new CreateGlobalTaskListenerRequest
        {
            EventTypes = new List<GlobalTaskListenerEventTypeEnum> { GlobalTaskListenerEventTypeEnum.Completing },
            Id = id,
        });

    Console.WriteLine($"Task listener: {result.Id}");
}
```

#### CreateUserAsync(UserRequest, CancellationToken)

```csharp
public Task<UserCreateResult> CreateUserAsync(UserRequest body, CancellationToken ct = default)
```

Create user

Create a new user.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `body`    | `UserRequest`       |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<UserCreateResult>`

**Example**

```csharp
public static async Task CreateUserExample(Username username)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateUserAsync(new UserRequest
    {
        Username = username,
        Name = "Jane Doe",
        Email = "jdoe@example.com",
        Password = "secure-password",
    });

    Console.WriteLine($"User key: {result.Username}");
}
```

#### DeleteGlobalTaskListenerAsync(GlobalListenerId, CancellationToken)

```csharp
public Task DeleteGlobalTaskListenerAsync(GlobalListenerId id, CancellationToken ct = default)
```

Delete global user task listener

Deletes a global user task listener.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `id`      | `GlobalListenerId`  |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteGlobalTaskListenerExample(GlobalListenerId globalListenerId)
{
    using var client = CamundaClient.Create();

    await client.DeleteGlobalTaskListenerAsync(
        globalListenerId);
}
```

#### DeleteUserAsync(Username, CancellationToken)

```csharp
public Task DeleteUserAsync(Username username, CancellationToken ct = default)
```

Delete user

Deletes a user.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteUserExample(Username username)
{
    using var client = CamundaClient.Create();

    await client.DeleteUserAsync(username);
}
```

#### EvaluateConditionalsAsync(ConditionalEvaluationInstruction, CancellationToken)

```csharp
public Task<EvaluateConditionalResult> EvaluateConditionalsAsync(ConditionalEvaluationInstruction body, CancellationToken ct = default)
```

Evaluate root level conditional start events

Evaluates root-level conditional start events for process definitions. If the evaluation is successful, it will return the keys of all created process instances, along with their associated process definition key. Multiple root-level conditional start events of the same process definition can trigger if their conditions evaluate to true.

| Parameter | Type                               | Description |
| --------- | ---------------------------------- | ----------- |
| `body`    | `ConditionalEvaluationInstruction` |             |
| `ct`      | `CancellationToken`                |             |

**Returns:** `Task<EvaluateConditionalResult>`

**Example**

```csharp
public static async Task EvaluateConditionalsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateConditionalsAsync(
        new ConditionalEvaluationInstruction());

    Console.WriteLine($"Result: {result}");
}
```

#### EvaluateExpressionAsync(ExpressionEvaluationRequest, CancellationToken)

```csharp
public Task<ExpressionEvaluationResult> EvaluateExpressionAsync(ExpressionEvaluationRequest body, CancellationToken ct = default)
```

Evaluate an expression

Evaluates a FEEL expression and returns the result. Supports references to tenant scoped cluster variables when a tenant ID is provided. Optionally, provide a `scopeKey` to make the variables of a specific process instance or element instance visible while evaluating the expression.

| Parameter | Type                          | Description |
| --------- | ----------------------------- | ----------- |
| `body`    | `ExpressionEvaluationRequest` |             |
| `ct`      | `CancellationToken`           |             |

**Returns:** `Task<ExpressionEvaluationResult>`

**Example**

```csharp
public static async Task EvaluateExpressionExample()
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateExpressionAsync(
        new ExpressionEvaluationRequest
        {
            Expression = "= 1 + 2",
        });

    Console.WriteLine($"Result: {result.Result}");
}
```

#### GetAgentInstanceAsync(AgentInstanceKey, ConsistencyOptions\<AgentInstanceResult\>?, CancellationToken)

```csharp
public Task<AgentInstanceResult> GetAgentInstanceAsync(AgentInstanceKey agentInstanceKey, ConsistencyOptions<AgentInstanceResult>? consistency = null, CancellationToken ct = default)
```

Get agent instance

Returns agent instance as JSON.

| Parameter          | Type                                      | Description |
| ------------------ | ----------------------------------------- | ----------- |
| `agentInstanceKey` | `AgentInstanceKey`                        |             |
| `consistency`      | `ConsistencyOptions<AgentInstanceResult>` |             |
| `ct`               | `CancellationToken`                       |             |

**Returns:** `Task<AgentInstanceResult>`

**Example**

```csharp
public static async Task GetAgentInstanceExample(AgentInstanceKey agentInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetAgentInstanceAsync(agentInstanceKey);
    Console.WriteLine($"Agent instance: {result.AgentInstanceKey}, status: {result.Status}");
}
```

#### GetFormByKeyAsync(FormKey, ConsistencyOptions\<FormResult\>?, CancellationToken)

```csharp
public Task<FormResult> GetFormByKeyAsync(FormKey formKey, ConsistencyOptions<FormResult>? consistency = null, CancellationToken ct = default)
```

Get form by key

Get a form by its unique form key.

| Parameter     | Type                             | Description |
| ------------- | -------------------------------- | ----------- |
| `formKey`     | `FormKey`                        |             |
| `consistency` | `ConsistencyOptions<FormResult>` |             |
| `ct`          | `CancellationToken`              |             |

**Returns:** `Task<FormResult>`

**Example**

```csharp
public static async Task GetFormByKeyExample(FormKey formKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetFormByKeyAsync(formKey);
    Console.WriteLine($"Form: {result.FormId}, version: {result.Version}");
}
```

#### GetGlobalTaskListenerAsync(GlobalListenerId, ConsistencyOptions\<GlobalTaskListenerResult\>?, CancellationToken)

```csharp
public Task<GlobalTaskListenerResult> GetGlobalTaskListenerAsync(GlobalListenerId id, ConsistencyOptions<GlobalTaskListenerResult>? consistency = null, CancellationToken ct = default)
```

Get global user task listener

Get a global user task listener by its id.

| Parameter     | Type                                           | Description |
| ------------- | ---------------------------------------------- | ----------- |
| `id`          | `GlobalListenerId`                             |             |
| `consistency` | `ConsistencyOptions<GlobalTaskListenerResult>` |             |
| `ct`          | `CancellationToken`                            |             |

**Returns:** `Task<GlobalTaskListenerResult>`

**Example**

```csharp
public static async Task GetGlobalTaskListenerExample(GlobalListenerId globalListenerId)
{
    using var client = CamundaClient.Create();

    var result = await client.GetGlobalTaskListenerAsync(
        globalListenerId);

    Console.WriteLine($"Task listener: {result.EventTypes}");
}
```

#### GetStatusAsync(CancellationToken)

```csharp
public Task GetStatusAsync(CancellationToken ct = default)
```

Get cluster status

Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task GetStatusExample()
{
    using var client = CamundaClient.Create();

    await client.GetStatusAsync();
    Console.WriteLine("Cluster is healthy");
}
```

#### GetSystemConfigurationAsync(CancellationToken)

```csharp
public Task<SystemConfigurationResponse> GetSystemConfigurationAsync(CancellationToken ct = default)
```

System configuration (alpha)

Returns the current system configuration. The response is an envelope that groups settings by feature area.

This endpoint is an alpha feature and may be subject to change in future releases.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<SystemConfigurationResponse>`

**Example**

```csharp
public static async Task GetSystemConfigurationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetSystemConfigurationAsync();
    Console.WriteLine($"System config: {result}");
}
```

#### GetUserAsync(Username, ConsistencyOptions\<UserResult\>?, CancellationToken)

```csharp
public Task<UserResult> GetUserAsync(Username username, ConsistencyOptions<UserResult>? consistency = null, CancellationToken ct = default)
```

Get user

Get a user by its username.

| Parameter     | Type                             | Description |
| ------------- | -------------------------------- | ----------- |
| `username`    | `Username`                       |             |
| `consistency` | `ConsistencyOptions<UserResult>` |             |
| `ct`          | `CancellationToken`              |             |

**Returns:** `Task<UserResult>`

#### ResolveSecretsAsync(SecretResolveRequest, CancellationToken)

```csharp
public Task<SecretResolveResult> ResolveSecretsAsync(SecretResolveRequest body, CancellationToken ct = default)
```

Resolve secrets (alpha)

Resolve a deduplicated batch of `camunda.secrets.*` references for the caller's physical tenant in a single round-trip.

Each reference is authorized and resolved independently. For valid requests, the endpoint always responds with HTTP 200: successfully resolved references are returned in `resolved`, while references that could not be resolved (for example not found, malformed or over-long, or the caller lacks `SECRET:REVEAL` on that reference) are returned in `errors`. A failure of one reference never fails the others. Only structurally invalid requests are rejected with HTTP 400: a missing or non-array `references` field, more than 20 references, or a null entry.

This endpoint is an alpha feature and may be subject to change in future releases.

Phase 1: the secret backend is mocked. Only a fixed allow-list of references resolves; every other authorized, valid reference returns `NOT_FOUND`.

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `body`    | `SecretResolveRequest` |             |
| `ct`      | `CancellationToken`    |             |

**Returns:** `Task<SecretResolveResult>`

**Example**

```csharp
public static async Task ResolveSecretsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ResolveSecretsAsync(new SecretResolveRequest
    {
        References = new List<string>
        {
            "camunda.secrets.myApiToken",
            "camunda.secrets.dbPassword",
        },
    });

    // Successfully resolved references are returned in Resolved; references that
    // could not be resolved are returned in Errors, each with a typed error code.
    // Never log resolved.Value — it holds secret material. Pass it directly to the
    // consumer that needs it (HTTP client, DB driver, ...) instead.
    foreach (var resolved in result.Resolved)
    {
        Console.WriteLine($"Resolved {resolved.Reference} (value redacted)");
        UseSecret(resolved.Value);
    }

    foreach (var error in result.Errors)
    {
        Console.WriteLine($"Failed to resolve {error.Reference}: {error.Code} - {error.Message}");
    }
}

// Hands the resolved secret to whatever needs it, without logging it.
private static void UseSecret(string value) { }
```

#### RestoreAsync(RestoreRequest, CancellationToken)

```csharp
public Task<ClusterModeChangeResponse> RestoreAsync(RestoreRequest body, CancellationToken ct = default)
```

Restore from a backup

Restores the cluster from a backup. The restore is described either by a single backup ID or by a time range (`from`/`to`) that selects the backups to restore. This endpoint is only accessible while the cluster is in recovery mode; requests are rejected otherwise. The request is validated and acknowledged, but the restore itself is performed asynchronously.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `body`    | `RestoreRequest`    |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<ClusterModeChangeResponse>`

**Example**

```csharp
public static async Task RestoreExample()
{
    using var client = CamundaClient.Create();

    // The cluster must be in recovery mode before a restore is accepted.
    // Provide either a list of backup IDs (one per partition) or a time
    // range (From/To) that selects the backups to restore, but not both.
    var change = await client.RestoreAsync(new RestoreRequest
    {
        BackupIds = new List<long> { 100, 101 },
    });

    Console.WriteLine($"Cluster change {change.ChangeId}:");
    foreach (var operation in change.PlannedChanges)
    {
        var suffix = operation.Mode is null ? "" : $" -> {operation.Mode}";
        Console.WriteLine($"  {operation.Operation}{suffix}");
    }
}
```

#### SearchAgentInstanceHistoryAsync(AgentInstanceKey, AgentInstanceHistorySearchQuery, ConsistencyOptions\<AgentInstanceHistorySearchQueryResult\>?, CancellationToken)

```csharp
public Task<AgentInstanceHistorySearchQueryResult> SearchAgentInstanceHistoryAsync(AgentInstanceKey agentInstanceKey, AgentInstanceHistorySearchQuery body, ConsistencyOptions<AgentInstanceHistorySearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search agent instance history

Searches the conversation history of an agent instance. Committed items are returned by default.

| Parameter          | Type                                                        | Description |
| ------------------ | ----------------------------------------------------------- | ----------- |
| `agentInstanceKey` | `AgentInstanceKey`                                          |             |
| `body`             | `AgentInstanceHistorySearchQuery`                           |             |
| `consistency`      | `ConsistencyOptions<AgentInstanceHistorySearchQueryResult>` |             |
| `ct`               | `CancellationToken`                                         |             |

**Returns:** `Task<AgentInstanceHistorySearchQueryResult>`

**Example**

```csharp
public static async Task SearchAgentInstanceHistoryExample(AgentInstanceKey agentInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAgentInstanceHistoryAsync(
        agentInstanceKey,
        new AgentInstanceHistorySearchQuery
        {
            Sort = new List<AgentInstanceHistorySearchQuerySortRequest>
            {
                new AgentInstanceHistorySearchQuerySortRequest
                {
                    Field = AgentInstanceHistorySearchQuerySortRequestField.ProducedAt,
                    Order = SortOrderEnum.ASC,
                },
            },
            Page = new LimitPagination { Limit = 20 },
        });

    foreach (var item in result.Items)
    {
        Console.WriteLine($"{item.HistoryItemKey} ({item.Role})");
    }
}
```

#### SearchAgentInstancesAsync(AgentInstanceSearchQuery, ConsistencyOptions\<AgentInstanceSearchQueryResult\>?, CancellationToken)

```csharp
public Task<AgentInstanceSearchQueryResult> SearchAgentInstancesAsync(AgentInstanceSearchQuery body, ConsistencyOptions<AgentInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search agent instances

Search for agent instances based on given criteria.

| Parameter     | Type                                                 | Description |
| ------------- | ---------------------------------------------------- | ----------- |
| `body`        | `AgentInstanceSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<AgentInstanceSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                  |             |

**Returns:** `Task<AgentInstanceSearchQueryResult>`

**Example**

```csharp
public static async Task SearchAgentInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAgentInstancesAsync(new AgentInstanceSearchQuery());

    foreach (var instance in result.Items)
    {
        Console.WriteLine($"Agent instance: {instance.AgentInstanceKey}, status: {instance.Status}");
    }
}
```

#### SearchGlobalTaskListenersAsync(GlobalTaskListenerSearchQueryRequest, ConsistencyOptions\<GlobalTaskListenerSearchQueryResult\>?, CancellationToken)

```csharp
public Task<GlobalTaskListenerSearchQueryResult> SearchGlobalTaskListenersAsync(GlobalTaskListenerSearchQueryRequest body, ConsistencyOptions<GlobalTaskListenerSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search global user task listeners

Search for global user task listeners based on given criteria.

| Parameter     | Type                                                      | Description |
| ------------- | --------------------------------------------------------- | ----------- |
| `body`        | `GlobalTaskListenerSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<GlobalTaskListenerSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                       |             |

**Returns:** `Task<GlobalTaskListenerSearchQueryResult>`

**Example**

```csharp
public static async Task SearchGlobalTaskListenersExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchGlobalTaskListenersAsync(
        new GlobalTaskListenerSearchQueryRequest());

    foreach (var listener in result.Items)
    {
        Console.WriteLine($"Listener: {listener.Id}");
    }
}
```

#### SearchUsersAsync(UserSearchQueryRequest, ConsistencyOptions\<UserSearchResult\>?, CancellationToken)

```csharp
public Task<UserSearchResult> SearchUsersAsync(UserSearchQueryRequest body, ConsistencyOptions<UserSearchResult>? consistency = null, CancellationToken ct = default)
```

Search users

Search for users based on given criteria.

| Parameter     | Type                                   | Description |
| ------------- | -------------------------------------- | ----------- |
| `body`        | `UserSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<UserSearchResult>` |             |
| `ct`          | `CancellationToken`                    |             |

**Returns:** `Task<UserSearchResult>`

#### UpdateAgentInstanceAsync(AgentInstanceKey, AgentInstanceUpdateRequest, CancellationToken)

```csharp
public Task UpdateAgentInstanceAsync(AgentInstanceKey agentInstanceKey, AgentInstanceUpdateRequest body, CancellationToken ct = default)
```

Update agent instance

Updates the mutable fields of an agent instance: status, metric counters, and tools. Metric values are treated as deltas and applied immediately to the aggregate counters. Tool updates replace the existing tool list.

| Parameter          | Type                         | Description |
| ------------------ | ---------------------------- | ----------- |
| `agentInstanceKey` | `AgentInstanceKey`           |             |
| `body`             | `AgentInstanceUpdateRequest` |             |
| `ct`               | `CancellationToken`          |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task UpdateAgentInstanceExample(AgentInstanceKey agentInstanceKey, ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateAgentInstanceAsync(
        agentInstanceKey,
        new AgentInstanceUpdateRequest
        {
            ElementInstanceKey = elementInstanceKey,
            Status = AgentInstanceUpdateStatusEnum.THINKING,
            Metrics = new AgentInstanceMetricsDelta
            {
                InputTokens = 150,
                OutputTokens = 50,
                ModelCalls = 1,
            },
        });

    Console.WriteLine($"Updated agent instance: {agentInstanceKey}");
}
```

#### UpdateGlobalTaskListenerAsync(GlobalListenerId, UpdateGlobalTaskListenerRequest, CancellationToken)

```csharp
public Task<GlobalTaskListenerResult> UpdateGlobalTaskListenerAsync(GlobalListenerId id, UpdateGlobalTaskListenerRequest body, CancellationToken ct = default)
```

Update global user task listener

Updates a global user task listener.

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `id`      | `GlobalListenerId`                |             |
| `body`    | `UpdateGlobalTaskListenerRequest` |             |
| `ct`      | `CancellationToken`               |             |

**Returns:** `Task<GlobalTaskListenerResult>`

**Example**

```csharp
public static async Task UpdateGlobalTaskListenerExample(GlobalListenerId globalListenerId)
{
    using var client = CamundaClient.Create();

    var result = await client.UpdateGlobalTaskListenerAsync(
        globalListenerId,
        new UpdateGlobalTaskListenerRequest
        {
            EventTypes = new List<GlobalTaskListenerEventTypeEnum> { GlobalTaskListenerEventTypeEnum.Completing },
            Type = "updated-task-listener",
        });

    Console.WriteLine($"Updated listener: {result.Id}");
}
```

#### UpdateUserAsync(Username, UserUpdateRequest, CancellationToken)

```csharp
public Task<UserUpdateResult> UpdateUserAsync(Username username, UserUpdateRequest body, CancellationToken ct = default)
```

Update user

Updates a user.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `username` | `Username`          |             |
| `body`     | `UserUpdateRequest` |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task<UserUpdateResult>`

**Example**

```csharp
public static async Task UpdateUserExample(Username username)
{
    using var client = CamundaClient.Create();

    await client.UpdateUserAsync(
        username,
        new UserUpdateRequest
        {
            Name = "Jane Smith",
            Email = "jsmith@example.com",
        });
}
```

### Cluster

#### GetBackpressureState()

```csharp
public BackpressureState GetBackpressureState()
```

Current backpressure state snapshot.

**Returns:** `BackpressureState`

**Example**

```csharp
public static void GetBackpressureStateExample()
{
    using var client = CamundaClient.Create();

    var state = client.GetBackpressureState();
    Console.WriteLine($"Severity: {state.Severity}, Permits: {state.PermitsMax}");
}
```

#### GetAuthenticationAsync(CancellationToken)

```csharp
public Task<CamundaUserResult> GetAuthenticationAsync(CancellationToken ct = default)
```

Get current user

Retrieves the current authenticated user.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<CamundaUserResult>`

**Example**

```csharp
public static async Task GetAuthenticationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetAuthenticationAsync();
    Console.WriteLine($"Authenticated user: {result.Username}");
}
```

#### GetLicenseAsync(CancellationToken)

```csharp
public Task<LicenseResponse> GetLicenseAsync(CancellationToken ct = default)
```

Get license status

Obtains the status of the current Camunda license.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<LicenseResponse>`

**Example**

```csharp
public static async Task GetLicenseExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetLicenseAsync();
    Console.WriteLine($"License type: {result.LicenseType}");
}
```

#### GetTopologyAsync(CancellationToken)

```csharp
public Task<TopologyResponse> GetTopologyAsync(CancellationToken ct = default)
```

Get cluster topology

Obtains the current topology of the cluster the gateway is part of.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<TopologyResponse>`

**Example**

```csharp
public static async Task GetTopologyExample()
{
    using var client = CamundaClient.Create();

    var topology = await client.GetTopologyAsync();
    Console.WriteLine($"Cluster size: {topology.ClusterSize}");
}
```

#### PinClockAsync(ClockPinRequest, CancellationToken)

```csharp
public Task PinClockAsync(ClockPinRequest body, CancellationToken ct = default)
```

Pin internal clock (alpha)

Set a precise, static time for the Zeebe engine's internal clock. When the clock is pinned, it remains at the specified time and does not advance. To change the time, the clock must be pinned again with a new timestamp.

This endpoint is an alpha feature and may be subject to change in future releases.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `body`    | `ClockPinRequest`   |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task PinClockExample()
{
    using var client = CamundaClient.Create();

    await client.PinClockAsync(new ClockPinRequest
    {
        Timestamp = 1700000000000,
    });
}
```

#### ResetClockAsync(CancellationToken)

```csharp
public Task ResetClockAsync(CancellationToken ct = default)
```

Reset internal clock (alpha)

Resets the Zeebe engine's internal clock to the current system time, enabling it to tick in real-time. This operation is useful for returning the clock to normal behavior after it has been pinned to a specific time.

This endpoint is an alpha feature and may be subject to change in future releases.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ResetClockExample()
{
    using var client = CamundaClient.Create();

    await client.ResetClockAsync();
}
```

### Resources

#### DeployResourcesFromFilesAsync(string[], string?, CancellationToken)

```csharp
public Task<ExtendedDeploymentResponse> DeployResourcesFromFilesAsync(string[] resourceFilePaths, string? tenantId = null, CancellationToken ct = default)
```

Deploy resources from local filesystem paths.

Reads the specified files, infers MIME types from their extensions, and calls `CamundaClient.CreateDeploymentAsync` with the loaded content.

| Parameter           | Type                | Description                                                            |
| ------------------- | ------------------- | ---------------------------------------------------------------------- |
| `resourceFilePaths` | `String[]`          | Absolute or relative file paths to BPMN, DMN, form, or resource files. |
| `tenantId`          | `String`            | Optional tenant ID for multi-tenant deployments.                       |
| `ct`                | `CancellationToken` | Cancellation token.                                                    |

**Returns:** `Task<ExtendedDeploymentResponse>` — An `ExtendedDeploymentResponse` with typed access to deployed artifacts.

**Example**

```csharp
public static async Task DeployResourcesFromFilesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.DeployResourcesFromFilesAsync(
        ["process.bpmn", "decision.dmn"]);
    Console.WriteLine($"Deployment key: {result.DeploymentKey}");
}
```

#### DeleteResourceAsync(ResourceKey, DeleteResourceRequest, CancellationToken)

```csharp
public Task<DeleteResourceResponse> DeleteResourceAsync(ResourceKey resourceKey, DeleteResourceRequest body, CancellationToken ct = default)
```

Delete resource

Deletes a deployed resource. This can be a process definition, decision requirements definition, or form definition deployed using the deploy resources endpoint. Specify the resource you want to delete in the `resourceKey` parameter.

Once a resource has been deleted it cannot be recovered. If the resource needs to be available again, a new deployment of the resource is required.

By default, only the resource itself is deleted from the runtime state. To also delete the historic data associated with a resource, set the `deleteHistory` flag in the request body to `true`. The historic data is deleted asynchronously via a batch operation. The details of the created batch operation are included in the response. Note that history deletion is only supported for process resources; for other resource types this flag is ignored and no history will be deleted.

| Parameter     | Type                    | Description |
| ------------- | ----------------------- | ----------- |
| `resourceKey` | `ResourceKey`           |             |
| `body`        | `DeleteResourceRequest` |             |
| `ct`          | `CancellationToken`     |             |

**Returns:** `Task<DeleteResourceResponse>`

**Example**

```csharp
public static async Task DeleteResourceExample(ResourceKey resourceKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteResourceAsync(
        resourceKey,
        new DeleteResourceRequest());
}
```

#### GetResourceAsync(ResourceKey, ConsistencyOptions\<ResourceResult\>?, CancellationToken)

```csharp
public Task<ResourceResult> GetResourceAsync(ResourceKey resourceKey, ConsistencyOptions<ResourceResult>? consistency = null, CancellationToken ct = default)
```

Get resource

Returns a deployed resource.

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form resources. To query BPMN process definitions or DMN decision definitions, use their respective APIs.
:::

| Parameter     | Type                                 | Description |
| ------------- | ------------------------------------ | ----------- |
| `resourceKey` | `ResourceKey`                        |             |
| `consistency` | `ConsistencyOptions<ResourceResult>` |             |
| `ct`          | `CancellationToken`                  |             |

**Returns:** `Task<ResourceResult>`

#### GetResourceContentAsync(ResourceKey, ConsistencyOptions\<object\>?, CancellationToken)

```csharp
public Task<object> GetResourceContentAsync(ResourceKey resourceKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)
```

Get RPA resource content (deprecated)

**Deprecated** — use `/resources/{resourceKey}/content/binary` instead, which supports all resource types and returns content as binary (octet-stream).

Returns the content of a deployed RPA resource as JSON.

:::info
This endpoint only supports RPA resources. For generic resource content in binary format, use the `/resources/{resourceKey}/content/binary` endpoint.
:::

| Parameter     | Type                         | Description |
| ------------- | ---------------------------- | ----------- |
| `resourceKey` | `ResourceKey`                |             |
| `consistency` | `ConsistencyOptions<Object>` |             |
| `ct`          | `CancellationToken`          |             |

**Returns:** `Task<Object>`

#### GetResourceContentBinaryAsync(ResourceKey, ConsistencyOptions\<byte[]\>?, CancellationToken)

```csharp
public Task<byte[]> GetResourceContentBinaryAsync(ResourceKey resourceKey, ConsistencyOptions<byte[]>? consistency = null, CancellationToken ct = default)
```

Get resource content as binary

Returns the content of a deployed resource in binary format (octet-stream).

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form resources. To query BPMN process definitions or DMN decision definitions, use their respective APIs.
:::

| Parameter     | Type                         | Description |
| ------------- | ---------------------------- | ----------- |
| `resourceKey` | `ResourceKey`                |             |
| `consistency` | `ConsistencyOptions<Byte[]>` |             |
| `ct`          | `CancellationToken`          |             |

**Returns:** `Task<Byte[]>`

**Example**

```csharp
public static async Task GetResourceContentBinaryExample(ResourceKey resourceKey)
{
    using var client = CamundaClient.Create();

    byte[] content = await client.GetResourceContentBinaryAsync(resourceKey);
    Console.WriteLine($"Binary content length: {content.Length} bytes");
}
```

#### SearchResourcesAsync(ResourceSearchQuery, ConsistencyOptions\<ResourceSearchQueryResult\>?, CancellationToken)

```csharp
public Task<ResourceSearchQueryResult> SearchResourcesAsync(ResourceSearchQuery body, ConsistencyOptions<ResourceSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search resources

Search for deployed resources based on given criteria.

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form resources. To query BPMN process definitions or DMN decision definitions, use their respective search APIs.
:::

| Parameter     | Type                                            | Description |
| ------------- | ----------------------------------------------- | ----------- |
| `body`        | `ResourceSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<ResourceSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                             |             |

**Returns:** `Task<ResourceSearchQueryResult>`

**Example**

```csharp
public static async Task SearchResourcesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchResourcesAsync(new ResourceSearchQuery());
    foreach (var resource in result.Items!)
    {
        Console.WriteLine($"Resource: {resource.ResourceName}");
    }
}
```

### Process Instances

#### SearchVariablesAsDtoAsync\<T\>(ProcessInstanceKey, ScopeKey?, TenantId?, int, CancellationToken)

```csharp
public Task<VariableMap<T>> SearchVariablesAsDtoAsync<T>(ProcessInstanceKey processInstanceKey, ScopeKey? scopeKey = null, TenantId? tenantId = null, int pageSize = 100, CancellationToken ct = default) where T : class
```

Fetch the variables declared by a DTO type for a process instance, mapping them onto a strongly-typed result.

The query is derived from the DTO's members (honouring `[JsonPropertyName]`): only the declared variable names are fetched via a `name $in [...]` filter, so memory is bounded by the DTO shape rather than the total number of variables on the process instance. Results are paged to exhaustion over the filtered set, collapsed by name, and parsed into a `VariableMap`.

Access modes on the returned map:

- Lenient — `VariableMap.Get` / `VariableMap.Get` tolerate absent variables.
- Strict — `VariableMap.Validate` constructs the DTO and throws if a required member is absent.

```csharp
public record OrderVars(string OrderId, decimal? Amount);

var vars = await client.SearchVariablesAsDtoAsync<OrderVars>(processInstanceKey);
var amount = vars.Get<decimal>("amount");   // lenient
var typed = vars.Validate();                    // strict: throws if OrderId missing
```

| Parameter            | Type                 | Description                                                                                                                                                                                      |
| -------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `processInstanceKey` | `ProcessInstanceKey` | The process instance whose variables to search.                                                                                                                                                  |
| `scopeKey`           | `Nullable<ScopeKey>` | Optional scope key to disambiguate variables that exist at multiple scopes. When omitted and a declared variable resolves to more than one scope, a `VariableScopeCollisionException` is thrown. |
| `tenantId`           | `Nullable<TenantId>` | Optional tenant ID filter.                                                                                                                                                                       |
| `pageSize`           | `Int32`              | The page size used while paging the filtered result set.                                                                                                                                         |
| `ct`                 | `CancellationToken`  | Cancellation token.                                                                                                                                                                              |

**Returns:** `Task<VariableMap<T>>` — A `VariableMap` over the declared variables.

**Example**

```csharp
public record OrderVariables(string OrderId, decimal Amount, string? Notes);

public static async Task SearchVariablesAsDtoExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    // Search a process instance for exactly the variables declared on the DTO,
    // pages and all, and collapse them into a single typed object.
    var map = await client.SearchVariablesAsDtoAsync<OrderVariables>(processInstanceKey);

    // Read individual values lazily without materializing the whole DTO.
    if (map.Contains("amount"))
    {
        var amount = map.Get<decimal>("amount");
        Console.WriteLine($"Amount: {amount}");
    }

    // Validate() enforces that every non-nullable member is present,
    // throwing VariableValidationException if a required variable is missing.
    OrderVariables order = map.Validate();
    Console.WriteLine($"Order {order.OrderId}: {order.Amount}");
}
```

#### AssignProcessInstanceBusinessIdAsync(ProcessInstanceKey, ProcessInstanceBusinessIdAssignmentInstruction, CancellationToken)

```csharp
public Task AssignProcessInstanceBusinessIdAsync(ProcessInstanceKey processInstanceKey, ProcessInstanceBusinessIdAssignmentInstruction body, CancellationToken ct = default)
```

Assign business id to process instance

Assigns a business id to an already-running process instance that currently has none.

The assignment is single and irreversible: only artifacts created after the assignment (for example future jobs, user tasks, decision instances, and message subscriptions) carry the business id, while existing artifacts are not retroactively enriched. Re-sending the same business id succeeds as a no-op. This endpoint is only useful while business id uniqueness enforcement is disabled; when it is enabled, the request is rejected with a 409 response.

| Parameter            | Type                                             | Description |
| -------------------- | ------------------------------------------------ | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                             |             |
| `body`               | `ProcessInstanceBusinessIdAssignmentInstruction` |             |
| `ct`                 | `CancellationToken`                              |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task AssignProcessInstanceBusinessIdExample(ProcessInstanceKey processInstanceKey, BusinessId businessId)
{
    using var client = CamundaClient.Create();

    await client.AssignProcessInstanceBusinessIdAsync(
        processInstanceKey,
        new ProcessInstanceBusinessIdAssignmentInstruction
        {
            BusinessId = businessId,
        });
}
```

#### CancelProcessInstanceAsync(ProcessInstanceKey, CancelProcessInstanceRequest, CancellationToken)

```csharp
public Task CancelProcessInstanceAsync(ProcessInstanceKey processInstanceKey, CancelProcessInstanceRequest body, CancellationToken ct = default)
```

Cancel process instance

Cancels a running process instance. As a cancellation includes more than just the removal of the process instance resource, the cancellation resource must be posted. Cancellation can wait on listener-related processing; when that processing does not complete in time, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

| Parameter            | Type                           | Description |
| -------------------- | ------------------------------ | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`           |             |
| `body`               | `CancelProcessInstanceRequest` |             |
| `ct`                 | `CancellationToken`            |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task CancelProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.CancelProcessInstanceAsync(
        processInstanceKey,
        new CancelProcessInstanceRequest());
}
```

#### CancelProcessInstancesBatchOperationAsync(ProcessInstanceCancellationBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> CancelProcessInstancesBatchOperationAsync(ProcessInstanceCancellationBatchOperationRequest body, CancellationToken ct = default)
```

Cancel process instances (batch)

Cancels multiple running process instances. Since only ACTIVE root instances can be cancelled, any given filters for state and parentProcessInstanceKey are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                               | Description |
| --------- | -------------------------------------------------- | ----------- |
| `body`    | `ProcessInstanceCancellationBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                                |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task CancelProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CancelProcessInstancesBatchOperationAsync(
        new ProcessInstanceCancellationBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### CreateProcessInstanceAsync(ProcessInstanceCreationInstruction, CancellationToken)

```csharp
public Task<CreateProcessInstanceResult> CreateProcessInstanceAsync(ProcessInstanceCreationInstruction body, CancellationToken ct = default)
```

Create process instance

Creates and starts an instance of the specified process. The process definition to use to create the instance can be specified either using its unique key (as returned by Deploy resources), or using the BPMN process id and a version.

Waits for the completion of the process instance before returning a result when awaitCompletion is enabled.

| Parameter | Type                                 | Description |
| --------- | ------------------------------------ | ----------- |
| `body`    | `ProcessInstanceCreationInstruction` |             |
| `ct`      | `CancellationToken`                  |             |

**Returns:** `Task<CreateProcessInstanceResult>`

**Example**

```csharp
public static async Task CreateProcessInstanceByIdExample(ProcessDefinitionId processDefinitionId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
    {
        ProcessDefinitionId = processDefinitionId,
    });

    Console.WriteLine($"Process instance key: {result.ProcessInstanceKey}");
}

public static async Task CreateProcessInstanceByKeyExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionByKey
    {
        ProcessDefinitionKey = processDefinitionKey,
    });

    Console.WriteLine($"Process instance key: {result.ProcessInstanceKey}");
}
```

#### DeleteProcessInstanceAsync(ProcessInstanceKey, DeleteProcessInstanceRequest, CancellationToken)

```csharp
public Task DeleteProcessInstanceAsync(ProcessInstanceKey processInstanceKey, DeleteProcessInstanceRequest body, CancellationToken ct = default)
```

Delete process instance

Deletes a process instance. Only instances that are completed or terminated can be deleted.

| Parameter            | Type                           | Description |
| -------------------- | ------------------------------ | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`           |             |
| `body`               | `DeleteProcessInstanceRequest` |             |
| `ct`                 | `CancellationToken`            |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteProcessInstanceAsync(
        processInstanceKey,
        new DeleteProcessInstanceRequest());
}
```

#### DeleteProcessInstancesBatchOperationAsync(ProcessInstanceDeletionBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> DeleteProcessInstancesBatchOperationAsync(ProcessInstanceDeletionBatchOperationRequest body, CancellationToken ct = default)
```

Delete process instances (batch)

Delete multiple process instances. This will delete the historic data from secondary storage. Only process instances in a final state (COMPLETED or TERMINATED) can be deleted. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                           | Description |
| --------- | ---------------------------------------------- | ----------- |
| `body`    | `ProcessInstanceDeletionBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                            |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task DeleteProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.DeleteProcessInstancesBatchOperationAsync(
        new ProcessInstanceDeletionBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### GetProcessInstanceAsync(ProcessInstanceKey, ConsistencyOptions\<ProcessInstanceResult\>?, CancellationToken)

```csharp
public Task<ProcessInstanceResult> GetProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceResult>? consistency = null, CancellationToken ct = default)
```

Get process instance

Get the process instance by the process instance key.

| Parameter            | Type                                        | Description |
| -------------------- | ------------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                        |             |
| `consistency`        | `ConsistencyOptions<ProcessInstanceResult>` |             |
| `ct`                 | `CancellationToken`                         |             |

**Returns:** `Task<ProcessInstanceResult>`

**Example**

```csharp
public static async Task GetProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceAsync(processInstanceKey);
    Console.WriteLine($"Process instance: {result.ProcessDefinitionId}");
}
```

#### GetProcessInstanceCallHierarchyAsync(ProcessInstanceKey, ConsistencyOptions\<object\>?, CancellationToken)

```csharp
public Task<object> GetProcessInstanceCallHierarchyAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)
```

Get call hierarchy

Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance.

| Parameter            | Type                         | Description |
| -------------------- | ---------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`         |             |
| `consistency`        | `ConsistencyOptions<Object>` |             |
| `ct`                 | `CancellationToken`          |             |

**Returns:** `Task<Object>`

**Example**

```csharp
public static async Task GetProcessInstanceCallHierarchyExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceCallHierarchyAsync(
        processInstanceKey);

    Console.WriteLine($"Call hierarchy: {result}");
}
```

#### GetProcessInstanceSequenceFlowsAsync(ProcessInstanceKey, ConsistencyOptions\<ProcessInstanceSequenceFlowsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessInstanceSequenceFlowsQueryResult> GetProcessInstanceSequenceFlowsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceSequenceFlowsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get sequence flows

Get sequence flows taken by the process instance.

| Parameter            | Type                                                          | Description |
| -------------------- | ------------------------------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                                          |             |
| `consistency`        | `ConsistencyOptions<ProcessInstanceSequenceFlowsQueryResult>` |             |
| `ct`                 | `CancellationToken`                                           |             |

**Returns:** `Task<ProcessInstanceSequenceFlowsQueryResult>`

**Example**

```csharp
public static async Task GetProcessInstanceSequenceFlowsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceSequenceFlowsAsync(
        processInstanceKey);

    foreach (var flow in result.Items)
    {
        Console.WriteLine($"Sequence flow: {flow}");
    }
}
```

#### GetProcessInstanceStatisticsAsync(ProcessInstanceKey, ConsistencyOptions\<ProcessInstanceElementStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessInstanceElementStatisticsQueryResult> GetProcessInstanceStatisticsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get element instance statistics

Get statistics about elements by the process instance key.

| Parameter            | Type                                                              | Description |
| -------------------- | ----------------------------------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                                              |             |
| `consistency`        | `ConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>` |             |
| `ct`                 | `CancellationToken`                                               |             |

**Returns:** `Task<ProcessInstanceElementStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetProcessInstanceStatisticsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceStatisticsAsync(
        processInstanceKey);

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Element: {stat.ElementId}");
    }
}
```

#### GetProcessInstanceStatisticsByDefinitionAsync(IncidentProcessInstanceStatisticsByDefinitionQuery, ConsistencyOptions\<IncidentProcessInstanceStatisticsByDefinitionQueryResult\>?, CancellationToken)

```csharp
public Task<IncidentProcessInstanceStatisticsByDefinitionQueryResult> GetProcessInstanceStatisticsByDefinitionAsync(IncidentProcessInstanceStatisticsByDefinitionQuery body, ConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>? consistency = null, CancellationToken ct = default)
```

Get process instance statistics by definition

Returns statistics for active process instances with incidents, grouped by process definition. The result set is scoped to a specific incident error hash code, which must be provided as a filter in the request body.

| Parameter     | Type                                                                           | Description |
| ------------- | ------------------------------------------------------------------------------ | ----------- |
| `body`        | `IncidentProcessInstanceStatisticsByDefinitionQuery`                           |             |
| `consistency` | `ConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>` |             |
| `ct`          | `CancellationToken`                                                            |             |

**Returns:** `Task<IncidentProcessInstanceStatisticsByDefinitionQueryResult>`

**Example**

```csharp
public static async Task GetProcessInstanceStatisticsByDefinitionExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceStatisticsByDefinitionAsync(
        new IncidentProcessInstanceStatisticsByDefinitionQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Definition: {stat.ProcessDefinitionKey}");
    }
}
```

#### GetProcessInstanceStatisticsByErrorAsync(IncidentProcessInstanceStatisticsByErrorQuery, ConsistencyOptions\<IncidentProcessInstanceStatisticsByErrorQueryResult\>?, CancellationToken)

```csharp
public Task<IncidentProcessInstanceStatisticsByErrorQueryResult> GetProcessInstanceStatisticsByErrorAsync(IncidentProcessInstanceStatisticsByErrorQuery body, ConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>? consistency = null, CancellationToken ct = default)
```

Get process instance statistics by error

Returns statistics for active process instances that currently have active incidents, grouped by incident error hash code.

| Parameter     | Type                                                                      | Description |
| ------------- | ------------------------------------------------------------------------- | ----------- |
| `body`        | `IncidentProcessInstanceStatisticsByErrorQuery`                           |             |
| `consistency` | `ConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>` |             |
| `ct`          | `CancellationToken`                                                       |             |

**Returns:** `Task<IncidentProcessInstanceStatisticsByErrorQueryResult>`

**Example**

```csharp
public static async Task GetProcessInstanceStatisticsByErrorExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceStatisticsByErrorAsync(
        new IncidentProcessInstanceStatisticsByErrorQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Error: {stat.ErrorMessage}");
    }
}
```

#### GetProcessInstanceWaitStateStatisticsAsync(ProcessInstanceKey, ConsistencyOptions\<ProcessInstanceWaitStateStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessInstanceWaitStateStatisticsQueryResult> GetProcessInstanceWaitStateStatisticsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceWaitStateStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get wait state statistics

Get statistics about waiting element instances by the process instance key, grouped by element id.

| Parameter            | Type                                                                | Description |
| -------------------- | ------------------------------------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                                                |             |
| `consistency`        | `ConsistencyOptions<ProcessInstanceWaitStateStatisticsQueryResult>` |             |
| `ct`                 | `CancellationToken`                                                 |             |

**Returns:** `Task<ProcessInstanceWaitStateStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetProcessInstanceWaitStateStatisticsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceWaitStateStatisticsAsync(
        processInstanceKey);

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Element: {stat.ElementId}, waiting: {stat.WaitingCount}");
    }
}
```

#### MigrateProcessInstanceAsync(ProcessInstanceKey, ProcessInstanceMigrationInstruction, CancellationToken)

```csharp
public Task MigrateProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ProcessInstanceMigrationInstruction body, CancellationToken ct = default)
```

Migrate process instance

Migrates a process instance to a new process definition. This request can contain multiple mapping instructions to define mapping between the active process instance's elements and target process definition elements.

Use this to upgrade a process instance to a new version of a process or to a different process definition, e.g. to keep your running instances up-to-date with the latest process improvements.

| Parameter            | Type                                  | Description |
| -------------------- | ------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                  |             |
| `body`               | `ProcessInstanceMigrationInstruction` |             |
| `ct`                 | `CancellationToken`                   |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task MigrateProcessInstanceExample(ProcessInstanceKey processInstanceKey, ProcessDefinitionKey targetProcessDefinitionKey)
{
    using var client = CamundaClient.Create();

    await client.MigrateProcessInstanceAsync(
        processInstanceKey,
        new ProcessInstanceMigrationInstruction
        {
            TargetProcessDefinitionKey = targetProcessDefinitionKey,
        });
}
```

#### MigrateProcessInstancesBatchOperationAsync(ProcessInstanceMigrationBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> MigrateProcessInstancesBatchOperationAsync(ProcessInstanceMigrationBatchOperationRequest body, CancellationToken ct = default)
```

Migrate process instances (batch)

Migrate multiple process instances. Since only process instances with ACTIVE state can be migrated, any given filters for state are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                            | Description |
| --------- | ----------------------------------------------- | ----------- |
| `body`    | `ProcessInstanceMigrationBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                             |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task MigrateProcessInstancesBatchOperationExample(ProcessDefinitionKey targetProcessDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.MigrateProcessInstancesBatchOperationAsync(
        new ProcessInstanceMigrationBatchOperationRequest
        {
            Filter = new ProcessInstanceFilter(),
            MigrationPlan = new ProcessInstanceMigrationBatchOperationPlan
            {
                TargetProcessDefinitionKey = targetProcessDefinitionKey,
            },
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### ModifyProcessInstanceAsync(ProcessInstanceKey, ProcessInstanceModificationInstruction, CancellationToken)

```csharp
public Task ModifyProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ProcessInstanceModificationInstruction body, CancellationToken ct = default)
```

Modify process instance

Modifies a running process instance. This request can contain multiple instructions to activate an element of the process or to terminate an active instance of an element.

Use this to repair a process instance that is stuck on an element or took an unintended path. For example, because an external system is not available or doesn't respond as expected.

| Parameter            | Type                                     | Description |
| -------------------- | ---------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                     |             |
| `body`               | `ProcessInstanceModificationInstruction` |             |
| `ct`                 | `CancellationToken`                      |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ModifyProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.ModifyProcessInstanceAsync(
        processInstanceKey,
        new ProcessInstanceModificationInstruction());
}
```

#### ModifyProcessInstancesBatchOperationAsync(ProcessInstanceModificationBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> ModifyProcessInstancesBatchOperationAsync(ProcessInstanceModificationBatchOperationRequest body, CancellationToken ct = default)
```

Modify process instances (batch)

Modify multiple process instances. Since only process instances with ACTIVE state can be modified, any given filters for state are ignored and overridden during this batch operation. In contrast to single modification operation, it is not possible to add variable instructions or modify by element key. It is only possible to use the element id of the source and target. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                               | Description |
| --------- | -------------------------------------------------- | ----------- |
| `body`    | `ProcessInstanceModificationBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                                |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task ModifyProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ModifyProcessInstancesBatchOperationAsync(
        new ProcessInstanceModificationBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### ResolveIncidentsBatchOperationAsync(ProcessInstanceIncidentResolutionBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> ResolveIncidentsBatchOperationAsync(ProcessInstanceIncidentResolutionBatchOperationRequest body, CancellationToken ct = default)
```

Resolve related incidents (batch)

Resolves multiple instances of process instances. Since only process instances with ACTIVE state can have unresolved incidents, any given filters for state are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                                     | Description |
| --------- | -------------------------------------------------------- | ----------- |
| `body`    | `ProcessInstanceIncidentResolutionBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                                      |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task ResolveIncidentsBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ResolveIncidentsBatchOperationAsync(
        new ProcessInstanceIncidentResolutionBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### ResolveProcessInstanceIncidentsAsync(ProcessInstanceKey, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> ResolveProcessInstanceIncidentsAsync(ProcessInstanceKey processInstanceKey, CancellationToken ct = default)
```

Resolve related incidents

Creates a batch operation to resolve multiple incidents of a process instance.

| Parameter            | Type                 | Description |
| -------------------- | -------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey` |             |
| `ct`                 | `CancellationToken`  |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task ResolveProcessInstanceIncidentsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.ResolveProcessInstanceIncidentsAsync(
        processInstanceKey);

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### ResumeProcessInstanceAsync(ProcessInstanceKey, ResumeProcessInstanceRequest, CancellationToken)

```csharp
public Task ResumeProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ResumeProcessInstanceRequest body, CancellationToken ct = default)
```

Resume process instance

Resumes a suspended process instance, returning it to the ACTIVE state and continuing processing. Only process instances in the SUSPENDED state can be resumed.

| Parameter            | Type                           | Description |
| -------------------- | ------------------------------ | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`           |             |
| `body`               | `ResumeProcessInstanceRequest` |             |
| `ct`                 | `CancellationToken`            |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ResumeProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.ResumeProcessInstanceAsync(
        processInstanceKey,
        new ResumeProcessInstanceRequest());
}
```

#### ResumeProcessInstancesBatchOperationAsync(ProcessInstanceResumptionBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> ResumeProcessInstancesBatchOperationAsync(ProcessInstanceResumptionBatchOperationRequest body, CancellationToken ct = default)
```

Resume process instances (batch)

Resumes multiple suspended process instances. Since only SUSPENDED root instances can be resumed, any given filters for state and parentProcessInstanceKey are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                             | Description |
| --------- | ------------------------------------------------ | ----------- |
| `body`    | `ProcessInstanceResumptionBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                              |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task ResumeProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ResumeProcessInstancesBatchOperationAsync(
        new ProcessInstanceResumptionBatchOperationRequest
        {
            Filter = new ProcessInstanceFilter(),
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### SearchProcessInstanceIncidentsAsync(ProcessInstanceKey, IncidentSearchQuery, ConsistencyOptions\<IncidentSearchQueryResult\>?, CancellationToken)

```csharp
public Task<IncidentSearchQueryResult> SearchProcessInstanceIncidentsAsync(ProcessInstanceKey processInstanceKey, IncidentSearchQuery body, ConsistencyOptions<IncidentSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search related incidents

Search for incidents caused by the process instance or any of its called process or decision instances.

Although the `processInstanceKey` is provided as a path parameter to indicate the root process instance, you may also include a `processInstanceKey` within the filter object to narrow results to specific child process instances. This is useful, for example, if you want to isolate incidents associated with subprocesses or called processes under the root instance while excluding incidents directly tied to the root.

| Parameter            | Type                                            | Description |
| -------------------- | ----------------------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`                            |             |
| `body`               | `IncidentSearchQuery`                           |             |
| `consistency`        | `ConsistencyOptions<IncidentSearchQueryResult>` |             |
| `ct`                 | `CancellationToken`                             |             |

**Returns:** `Task<IncidentSearchQueryResult>`

**Example**

```csharp
public static async Task SearchProcessInstanceIncidentsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessInstanceIncidentsAsync(
        processInstanceKey,
        new IncidentSearchQuery());

    foreach (var incident in result.Items)
    {
        Console.WriteLine($"Incident: {incident.IncidentKey}");
    }
}
```

#### SearchProcessInstancesAsync(ProcessInstanceSearchQuery, ConsistencyOptions\<ProcessInstanceSearchQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessInstanceSearchQueryResult> SearchProcessInstancesAsync(ProcessInstanceSearchQuery body, ConsistencyOptions<ProcessInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search process instances

Search for process instances based on given criteria.

| Parameter     | Type                                                   | Description |
| ------------- | ------------------------------------------------------ | ----------- |
| `body`        | `ProcessInstanceSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<ProcessInstanceSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                    |             |

**Returns:** `Task<ProcessInstanceSearchQueryResult>`

**Example**

```csharp
public static async Task SearchProcessInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessInstancesAsync(new ProcessInstanceSearchQuery());

    foreach (var instance in result.Items)
    {
        Console.WriteLine($"Process instance: {instance.ProcessInstanceKey}");
    }
}
```

#### SuspendProcessInstanceAsync(ProcessInstanceKey, SuspendProcessInstanceRequest, CancellationToken)

```csharp
public Task SuspendProcessInstanceAsync(ProcessInstanceKey processInstanceKey, SuspendProcessInstanceRequest body, CancellationToken ct = default)
```

Suspend process instance

Suspends a running process instance, pausing further processing until it is resumed. Only process instances in the ACTIVE state can be suspended.

| Parameter            | Type                            | Description |
| -------------------- | ------------------------------- | ----------- |
| `processInstanceKey` | `ProcessInstanceKey`            |             |
| `body`               | `SuspendProcessInstanceRequest` |             |
| `ct`                 | `CancellationToken`             |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task SuspendProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.SuspendProcessInstanceAsync(
        processInstanceKey,
        new SuspendProcessInstanceRequest());
}
```

#### SuspendProcessInstancesBatchOperationAsync(ProcessInstanceSuspensionBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> SuspendProcessInstancesBatchOperationAsync(ProcessInstanceSuspensionBatchOperationRequest body, CancellationToken ct = default)
```

Suspend process instances (batch)

Suspends multiple running process instances. Since only ACTIVE root instances can be suspended, any given filters for state and parentProcessInstanceKey are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                             | Description |
| --------- | ------------------------------------------------ | ----------- |
| `body`    | `ProcessInstanceSuspensionBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                              |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task SuspendProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SuspendProcessInstancesBatchOperationAsync(
        new ProcessInstanceSuspensionBatchOperationRequest
        {
            Filter = new ProcessInstanceFilter(),
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

### Jobs

#### CreateJobWorker(JobWorkerConfig, JobHandler)

```csharp
public JobWorker CreateJobWorker(JobWorkerConfig config, JobHandler handler)
```

Create a job worker that polls for and processes jobs of the specified type.

The handler receives an `ActivatedJob` and returns variables to auto-complete. Throw `BpmnErrorException` for BPMN errors, `JobFailureException` for explicit failures, or any other exception to auto-fail with `retries - 1`.

| Parameter | Type              | Description                                                                           |
| --------- | ----------------- | ------------------------------------------------------------------------------------- |
| `config`  | `JobWorkerConfig` | Worker configuration (job type, timeout, concurrency).                                |
| `handler` | `JobHandler`      | Async handler that processes each job. Return output variables (or null) to complete. |

**Returns:** `JobWorker` — The running `JobWorker` instance.

**Example**

```csharp
public static void CreateJobWorkerExample()
{
    using var client = CamundaClient.Create();

    var worker = client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return new { Success = true };
        });
}
```

#### CreateJobWorker(JobWorkerConfig, Func\<ActivatedJob, CancellationToken, Task\>)

```csharp
public JobWorker CreateJobWorker(JobWorkerConfig config, Func<ActivatedJob, CancellationToken, Task> handler)
```

Create a job worker with a handler that doesn't return output variables. The job is auto-completed with no variables on success.

| Parameter | Type                                          | Description |
| --------- | --------------------------------------------- | ----------- |
| `config`  | `JobWorkerConfig`                             |             |
| `handler` | `Func<ActivatedJob, CancellationToken, Task>` |             |

**Returns:** `JobWorker`

**Example**

```csharp
public static void CreateJobWorkerExample()
{
    using var client = CamundaClient.Create();

    var worker = client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return new { Success = true };
        });
}
```

#### ActivateJobsAsync(JobActivationRequest, CancellationToken)

```csharp
public Task<JobActivationResult> ActivateJobsAsync(JobActivationRequest body, CancellationToken ct = default)
```

Activate jobs

Iterate through all known partitions and activate jobs up to the requested maximum.

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `body`    | `JobActivationRequest` |             |
| `ct`      | `CancellationToken`    |             |

**Returns:** `Task<JobActivationResult>`

**Example**

```csharp
public static async Task ActivateJobsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ActivateJobsAsync(new JobActivationRequest
    {
        Type = "my-job-type",
        MaxJobsToActivate = 10,
        Timeout = 300000,
        Worker = "my-worker",
    });

    foreach (var job in result.Jobs)
    {
        Console.WriteLine($"Job: {job.JobKey}");
    }
}
```

#### CompleteJobAsync(JobKey, JobCompletionRequest, CancellationToken)

```csharp
public Task CompleteJobAsync(JobKey jobKey, JobCompletionRequest body, CancellationToken ct = default)
```

Complete job

Complete a job with the given payload, which allows completing the associated service task.

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `jobKey`  | `JobKey`               |             |
| `body`    | `JobCompletionRequest` |             |
| `ct`      | `CancellationToken`    |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task CompleteJobExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.CompleteJobAsync(
        jobKey,
        new JobCompletionRequest());
}
```

#### FailJobAsync(JobKey, JobFailRequest, CancellationToken)

```csharp
public Task FailJobAsync(JobKey jobKey, JobFailRequest body, CancellationToken ct = default)
```

Fail job

Mark the job as failed.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `jobKey`  | `JobKey`            |             |
| `body`    | `JobFailRequest`    |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task FailJobExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.FailJobAsync(
        jobKey,
        new JobFailRequest
        {
            Retries = 3,
            RetryBackOff = 5000,
            ErrorMessage = "Something went wrong",
        });
}
```

#### GetGlobalJobStatisticsAsync(DateTimeOffset, DateTimeOffset, string?, ConsistencyOptions\<GlobalJobStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<GlobalJobStatisticsQueryResult> GetGlobalJobStatisticsAsync(DateTimeOffset from, DateTimeOffset to, string? jobType = null, ConsistencyOptions<GlobalJobStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Global job statistics

Returns global aggregated counts for jobs. Filter by the creation time window (required) and optionally by jobType.

| Parameter     | Type                                                 | Description |
| ------------- | ---------------------------------------------------- | ----------- |
| `from`        | `DateTimeOffset`                                     |             |
| `to`          | `DateTimeOffset`                                     |             |
| `jobType`     | `String`                                             |             |
| `consistency` | `ConsistencyOptions<GlobalJobStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                  |             |

**Returns:** `Task<GlobalJobStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetGlobalJobStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetGlobalJobStatisticsAsync(
        from: new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero),
        to: new DateTimeOffset(2024, 12, 31, 23, 59, 59, TimeSpan.Zero));

    Console.WriteLine($"Global job stats: {result}");
}
```

#### GetJobErrorStatisticsAsync(JobErrorStatisticsQuery, ConsistencyOptions\<JobErrorStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<JobErrorStatisticsQueryResult> GetJobErrorStatisticsAsync(JobErrorStatisticsQuery body, ConsistencyOptions<JobErrorStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get error metrics for a job type

Returns aggregated metrics per error for the given jobType.

| Parameter     | Type                                                | Description |
| ------------- | --------------------------------------------------- | ----------- |
| `body`        | `JobErrorStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<JobErrorStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                 |             |

**Returns:** `Task<JobErrorStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetJobErrorStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobErrorStatisticsAsync(
        new JobErrorStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Error: {stat.ErrorCode}");
    }
}
```

#### GetJobTimeSeriesStatisticsAsync(JobTimeSeriesStatisticsQuery, ConsistencyOptions\<JobTimeSeriesStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<JobTimeSeriesStatisticsQueryResult> GetJobTimeSeriesStatisticsAsync(JobTimeSeriesStatisticsQuery body, ConsistencyOptions<JobTimeSeriesStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get time-series metrics for a job type

Returns a list of time-bucketed metrics ordered ascending by time. The `from` and `to` fields select the time window of interest. Each item in the response corresponds to one time bucket of the requested resolution.

| Parameter     | Type                                                     | Description |
| ------------- | -------------------------------------------------------- | ----------- |
| `body`        | `JobTimeSeriesStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<JobTimeSeriesStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                      |             |

**Returns:** `Task<JobTimeSeriesStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetJobTimeSeriesStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobTimeSeriesStatisticsAsync(
        new JobTimeSeriesStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Time series: {stat}");
    }
}
```

#### GetJobTypeStatisticsAsync(JobTypeStatisticsQuery, ConsistencyOptions\<JobTypeStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<JobTypeStatisticsQueryResult> GetJobTypeStatisticsAsync(JobTypeStatisticsQuery body, ConsistencyOptions<JobTypeStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get job statistics by type

Get statistics about jobs, grouped by job type.

| Parameter     | Type                                               | Description |
| ------------- | -------------------------------------------------- | ----------- |
| `body`        | `JobTypeStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<JobTypeStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                |             |

**Returns:** `Task<JobTypeStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetJobTypeStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobTypeStatisticsAsync(
        new JobTypeStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Job type: {stat.JobType}");
    }
}
```

#### GetJobWorkerStatisticsAsync(JobWorkerStatisticsQuery, ConsistencyOptions\<JobWorkerStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<JobWorkerStatisticsQueryResult> GetJobWorkerStatisticsAsync(JobWorkerStatisticsQuery body, ConsistencyOptions<JobWorkerStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get job statistics by worker

Get statistics about jobs, grouped by worker, for a given job type.

| Parameter     | Type                                                 | Description |
| ------------- | ---------------------------------------------------- | ----------- |
| `body`        | `JobWorkerStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<JobWorkerStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                  |             |

**Returns:** `Task<JobWorkerStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetJobWorkerStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobWorkerStatisticsAsync(
        new JobWorkerStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Worker: {stat.Worker}");
    }
}
```

#### SearchJobsAsync(JobSearchQuery, ConsistencyOptions\<JobSearchQueryResult\>?, CancellationToken)

```csharp
public Task<JobSearchQueryResult> SearchJobsAsync(JobSearchQuery body, ConsistencyOptions<JobSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search jobs

Search for jobs based on given criteria.

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `body`        | `JobSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<JobSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                        |             |

**Returns:** `Task<JobSearchQueryResult>`

**Example**

```csharp
public static async Task SearchJobsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchJobsAsync(new JobSearchQuery());

    foreach (var job in result.Items)
    {
        Console.WriteLine($"Job: {job.JobKey}");
    }
}
```

#### ThrowJobErrorAsync(JobKey, JobErrorRequest, CancellationToken)

```csharp
public Task ThrowJobErrorAsync(JobKey jobKey, JobErrorRequest body, CancellationToken ct = default)
```

Throw error for job

Reports a business error (i.e. non-technical) that occurs while processing a job.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `jobKey`  | `JobKey`            |             |
| `body`    | `JobErrorRequest`   |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ThrowJobErrorExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.ThrowJobErrorAsync(
        jobKey,
        new JobErrorRequest
        {
            ErrorCode = "VALIDATION_ERROR",
            ErrorMessage = "Input validation failed",
        });
}
```

#### UpdateJobAsync(JobKey, JobUpdateRequest, CancellationToken)

```csharp
public Task UpdateJobAsync(JobKey jobKey, JobUpdateRequest body, CancellationToken ct = default)
```

Update job

Update a job with the given key.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `jobKey`  | `JobKey`            |             |
| `body`    | `JobUpdateRequest`  |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task UpdateJobExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateJobAsync(
        jobKey,
        new JobUpdateRequest
        {
            Changeset = new JobChangeset { Retries = 3 },
        });
}
```

#### UpdateJobsBatchOperationAsync(JobBatchUpdateRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> UpdateJobsBatchOperationAsync(JobBatchUpdateRequest body, CancellationToken ct = default)
```

Update jobs (batch)

Creates a batch operation to update jobs matching the given filter. At least one changeset field must be non-null. This is done asynchronously; the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                    | Description |
| --------- | ----------------------- | ----------- |
| `body`    | `JobBatchUpdateRequest` |             |
| `ct`      | `CancellationToken`     |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task UpdateJobsBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.UpdateJobsBatchOperationAsync(
        new JobBatchUpdateRequest
        {
            Filter = new JobFilter
            {
                Type = new StringFilterProperty { Eq = "my-job-type" },
            },
            Changeset = new JobChangeset { Retries = 3 },
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

### Job Workers

#### RunWorkersAsync(TimeSpan?, CancellationToken)

```csharp
public Task RunWorkersAsync(TimeSpan? gracePeriod = null, CancellationToken ct = default)
```

Block until cancellation is requested, keeping all registered workers alive. This is the typical entry point for worker-only applications.

When the token is cancelled, all workers are stopped gracefully.

| Parameter     | Type                 | Description                                                                     |
| ------------- | -------------------- | ------------------------------------------------------------------------------- |
| `gracePeriod` | `Nullable<TimeSpan>` | Time to wait for in-flight jobs to finish during shutdown. Default: 10 seconds. |
| `ct`          | `CancellationToken`  | Cancellation token that signals shutdown.                                       |

**Returns:** `Task`

**Example**

```csharp
public static async Task RunWorkersExample(CancellationToken ct)
{
    using var client = CamundaClient.Create();

    client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, jobCt) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return null;
        });

    await client.RunWorkersAsync(gracePeriod: TimeSpan.FromSeconds(10), ct);
}
```

#### StopAllWorkersAsync(TimeSpan?)

```csharp
public Task StopAllWorkersAsync(TimeSpan? gracePeriod = null)
```

Stop all registered workers and wait for in-flight jobs to drain.

| Parameter     | Type                 | Description |
| ------------- | -------------------- | ----------- |
| `gracePeriod` | `Nullable<TimeSpan>` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task StopAllWorkersExample()
{
    using var client = CamundaClient.Create();

    client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return null;
        });

    await client.StopAllWorkersAsync(gracePeriod: TimeSpan.FromSeconds(5));
}
```

#### GetWorkers()

```csharp
public IReadOnlyList<JobWorker> GetWorkers()
```

Returns a snapshot of all registered workers.

**Returns:** `IReadOnlyList<JobWorker>`

**Example**

```csharp
public static void GetWorkersExample()
{
    using var client = CamundaClient.Create();

    client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return null;
        });

    var workers = client.GetWorkers();
    foreach (var worker in workers)
    {
        Console.WriteLine($"Worker: {worker.Name}, Active: {worker.ActiveJobs}");
    }
}
```

### Elements

#### ActivateAdHocSubProcessActivitiesAsync(ElementInstanceKey, AdHocSubProcessActivateActivitiesInstruction, CancellationToken)

```csharp
public Task ActivateAdHocSubProcessActivitiesAsync(ElementInstanceKey adHocSubProcessInstanceKey, AdHocSubProcessActivateActivitiesInstruction body, CancellationToken ct = default)
```

Activate activities within an ad-hoc sub-process

Activates selected activities within an ad-hoc sub-process identified by element ID. The provided element IDs must exist within the ad-hoc sub-process instance identified by the provided adHocSubProcessInstanceKey.

| Parameter                    | Type                                           | Description |
| ---------------------------- | ---------------------------------------------- | ----------- |
| `adHocSubProcessInstanceKey` | `ElementInstanceKey`                           |             |
| `body`                       | `AdHocSubProcessActivateActivitiesInstruction` |             |
| `ct`                         | `CancellationToken`                            |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ActivateAdHocSubProcessActivitiesExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.ActivateAdHocSubProcessActivitiesAsync(
        elementInstanceKey,
        new AdHocSubProcessActivateActivitiesInstruction());
}
```

#### GetElementInstanceAsync(ElementInstanceKey, ConsistencyOptions\<ElementInstanceResult\>?, CancellationToken)

```csharp
public Task<ElementInstanceResult> GetElementInstanceAsync(ElementInstanceKey elementInstanceKey, ConsistencyOptions<ElementInstanceResult>? consistency = null, CancellationToken ct = default)
```

Get element instance

Returns element instance as JSON.

| Parameter            | Type                                        | Description |
| -------------------- | ------------------------------------------- | ----------- |
| `elementInstanceKey` | `ElementInstanceKey`                        |             |
| `consistency`        | `ConsistencyOptions<ElementInstanceResult>` |             |
| `ct`                 | `CancellationToken`                         |             |

**Returns:** `Task<ElementInstanceResult>`

**Example**

```csharp
public static async Task GetElementInstanceExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetElementInstanceAsync(
        elementInstanceKey);

    Console.WriteLine($"Element: {result.ElementId}");
}
```

#### SearchElementInstanceWaitStatesAsync(ElementInstanceWaitStateQuery, ConsistencyOptions\<ElementInstanceWaitStateQueryResult\>?, CancellationToken)

```csharp
public Task<ElementInstanceWaitStateQueryResult> SearchElementInstanceWaitStatesAsync(ElementInstanceWaitStateQuery body, ConsistencyOptions<ElementInstanceWaitStateQueryResult>? consistency = null, CancellationToken ct = default)
```

Search element instance wait states

Returns the wait states for element instances matching the given filter.

| Parameter     | Type                                                      | Description |
| ------------- | --------------------------------------------------------- | ----------- |
| `body`        | `ElementInstanceWaitStateQuery`                           |             |
| `consistency` | `ConsistencyOptions<ElementInstanceWaitStateQueryResult>` |             |
| `ct`          | `CancellationToken`                                       |             |

**Returns:** `Task<ElementInstanceWaitStateQueryResult>`

**Example**

```csharp
public static async Task SearchElementInstanceWaitStatesExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchElementInstanceWaitStatesAsync(
        new ElementInstanceWaitStateQuery
        {
            Filter = new ElementInstanceWaitStateFilter
            {
                ProcessInstanceKey = new ProcessInstanceKeyFilterProperty
                {
                    Eq = processInstanceKey,
                },
            },
        });

    foreach (var waitState in result.Items)
    {
        var details = waitState.Details switch
        {
            JobWaitStateDetails job => $"waiting on job '{job.JobType}'",
            MessageWaitStateDetails message => $"waiting for message '{message.MessageName}'",
            _ => "waiting",
        };
        Console.WriteLine($"{waitState.ElementId}: {details}");
    }
}
```

#### SearchElementInstancesAsync(ElementInstanceSearchQuery, ConsistencyOptions\<ElementInstanceSearchQueryResult\>?, CancellationToken)

```csharp
public Task<ElementInstanceSearchQueryResult> SearchElementInstancesAsync(ElementInstanceSearchQuery body, ConsistencyOptions<ElementInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search element instances

Search for element instances based on given criteria.

| Parameter     | Type                                                   | Description |
| ------------- | ------------------------------------------------------ | ----------- |
| `body`        | `ElementInstanceSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<ElementInstanceSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                    |             |

**Returns:** `Task<ElementInstanceSearchQueryResult>`

**Example**

```csharp
public static async Task SearchElementInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchElementInstancesAsync(
        new ElementInstanceSearchQuery());

    foreach (var ei in result.Items)
    {
        Console.WriteLine($"Element instance: {ei.ElementInstanceKey}");
    }
}
```

### Groups

#### AssignClientToGroupAsync(GroupId, ClientId, CancellationToken)

```csharp
public Task AssignClientToGroupAsync(GroupId groupId, ClientId clientId, CancellationToken ct = default)
```

Assign a client to a group

Assigns a client to a group, making it a member of the group. Members of the group inherit the group authorizations, roles, and tenant assignments.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `groupId`  | `GroupId`           |             |
| `clientId` | `ClientId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### AssignMappingRuleToGroupAsync(GroupId, MappingRuleId, CancellationToken)

```csharp
public Task AssignMappingRuleToGroupAsync(GroupId groupId, MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Assign a mapping rule to a group

Assigns a mapping rule to a group.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `groupId`       | `GroupId`           |             |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### AssignUserToGroupAsync(GroupId, Username, CancellationToken)

```csharp
public Task AssignUserToGroupAsync(GroupId groupId, Username username, CancellationToken ct = default)
```

Assign a user to a group

Assigns a user to a group, making the user a member of the group. Group members inherit the group authorizations, roles, and tenant assignments.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `groupId`  | `GroupId`           |             |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### CreateGroupAsync(GroupCreateRequest, CancellationToken)

```csharp
public Task<GroupCreateResult> CreateGroupAsync(GroupCreateRequest body, CancellationToken ct = default)
```

Create group

Create a new group.

The supplied `groupId` is validated against `^[a-zA-Z0-9_~@.+-]+$` (max 256 characters) by `IdentifierValidator.validateId` in the runtime. This strict validation applies wherever the Groups API is available: in OIDC deployments that set `camunda.security.authentication.oidc.groupsClaim` the Groups API (including this endpoint) is disabled entirely, so group CRUD never sees externally-minted IdP IDs. The BYOG relaxation only loosens validation when a group is referenced _as a member_ of a role or tenant (`assignRoleToGroup`, `assignGroupToTenant`); group CRUD itself always uses the strict default-id regex. The constraint is not advertised on the `GroupId` schema so that the same schema can be reused at member-reference sites without falsely rejecting externally-minted IdP group IDs there.

| Parameter | Type                 | Description |
| --------- | -------------------- | ----------- |
| `body`    | `GroupCreateRequest` |             |
| `ct`      | `CancellationToken`  |             |

**Returns:** `Task<GroupCreateResult>`

**Example**

```csharp
public static async Task CreateGroupExample(GroupId groupId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateGroupAsync(new GroupCreateRequest
    {
        GroupId = groupId,
        Name = "Engineering",
    });

    Console.WriteLine($"Group key: {result.GroupId}");
}
```

#### DeleteGroupAsync(GroupId, CancellationToken)

```csharp
public Task DeleteGroupAsync(GroupId groupId, CancellationToken ct = default)
```

Delete group

Deletes the group with the given ID.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `groupId` | `GroupId`           |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

#### GetGroupAsync(GroupId, ConsistencyOptions\<GroupResult\>?, CancellationToken)

```csharp
public Task<GroupResult> GetGroupAsync(GroupId groupId, ConsistencyOptions<GroupResult>? consistency = null, CancellationToken ct = default)
```

Get group

Get a group by its ID.

| Parameter     | Type                              | Description |
| ------------- | --------------------------------- | ----------- |
| `groupId`     | `GroupId`                         |             |
| `consistency` | `ConsistencyOptions<GroupResult>` |             |
| `ct`          | `CancellationToken`               |             |

**Returns:** `Task<GroupResult>`

#### SearchClientsForGroupAsync(GroupId, GroupClientSearchQueryRequest, ConsistencyOptions\<GroupClientSearchResult\>?, CancellationToken)

```csharp
public Task<GroupClientSearchResult> SearchClientsForGroupAsync(GroupId groupId, GroupClientSearchQueryRequest body, ConsistencyOptions<GroupClientSearchResult>? consistency = null, CancellationToken ct = default)
```

Search group clients

Search clients assigned to a group.

| Parameter     | Type                                          | Description |
| ------------- | --------------------------------------------- | ----------- |
| `groupId`     | `GroupId`                                     |             |
| `body`        | `GroupClientSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<GroupClientSearchResult>` |             |
| `ct`          | `CancellationToken`                           |             |

**Returns:** `Task<GroupClientSearchResult>`

#### SearchGroupsAsync(GroupSearchQueryRequest, ConsistencyOptions\<GroupSearchQueryResult\>?, CancellationToken)

```csharp
public Task<GroupSearchQueryResult> SearchGroupsAsync(GroupSearchQueryRequest body, ConsistencyOptions<GroupSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search groups

Search for groups based on given criteria.

| Parameter     | Type                                         | Description |
| ------------- | -------------------------------------------- | ----------- |
| `body`        | `GroupSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<GroupSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                          |             |

**Returns:** `Task<GroupSearchQueryResult>`

**Example**

```csharp
public static async Task SearchGroupsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchGroupsAsync(new GroupSearchQueryRequest());

    foreach (var group in result.Items)
    {
        Console.WriteLine($"Group: {group.Name}");
    }
}
```

#### SearchMappingRulesForGroupAsync(GroupId, MappingRuleSearchQueryRequest, ConsistencyOptions\<GroupMappingRuleSearchResult\>?, CancellationToken)

```csharp
public Task<GroupMappingRuleSearchResult> SearchMappingRulesForGroupAsync(GroupId groupId, MappingRuleSearchQueryRequest body, ConsistencyOptions<GroupMappingRuleSearchResult>? consistency = null, CancellationToken ct = default)
```

Search group mapping rules

Search mapping rules assigned to a group.

| Parameter     | Type                                               | Description |
| ------------- | -------------------------------------------------- | ----------- |
| `groupId`     | `GroupId`                                          |             |
| `body`        | `MappingRuleSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<GroupMappingRuleSearchResult>` |             |
| `ct`          | `CancellationToken`                                |             |

**Returns:** `Task<GroupMappingRuleSearchResult>`

#### SearchUsersForGroupAsync(GroupId, GroupUserSearchQueryRequest, ConsistencyOptions\<GroupUserSearchResult\>?, CancellationToken)

```csharp
public Task<GroupUserSearchResult> SearchUsersForGroupAsync(GroupId groupId, GroupUserSearchQueryRequest body, ConsistencyOptions<GroupUserSearchResult>? consistency = null, CancellationToken ct = default)
```

Search group users

Search users assigned to a group.

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `groupId`     | `GroupId`                                   |             |
| `body`        | `GroupUserSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<GroupUserSearchResult>` |             |
| `ct`          | `CancellationToken`                         |             |

**Returns:** `Task<GroupUserSearchResult>`

#### UnassignClientFromGroupAsync(GroupId, ClientId, CancellationToken)

```csharp
public Task UnassignClientFromGroupAsync(GroupId groupId, ClientId clientId, CancellationToken ct = default)
```

Unassign a client from a group

Unassigns a client from a group. The client is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `groupId`  | `GroupId`           |             |
| `clientId` | `ClientId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignMappingRuleFromGroupAsync(GroupId, MappingRuleId, CancellationToken)

```csharp
public Task UnassignMappingRuleFromGroupAsync(GroupId groupId, MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Unassign a mapping rule from a group

Unassigns a mapping rule from a group.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `groupId`       | `GroupId`           |             |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignUserFromGroupAsync(GroupId, Username, CancellationToken)

```csharp
public Task UnassignUserFromGroupAsync(GroupId groupId, Username username, CancellationToken ct = default)
```

Unassign a user from a group

Unassigns a user from a group. The user is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `groupId`  | `GroupId`           |             |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UpdateGroupAsync(GroupId, GroupUpdateRequest, CancellationToken)

```csharp
public Task<GroupUpdateResult> UpdateGroupAsync(GroupId groupId, GroupUpdateRequest body, CancellationToken ct = default)
```

Update group

Update a group with the given ID.

| Parameter | Type                 | Description |
| --------- | -------------------- | ----------- |
| `groupId` | `GroupId`            |             |
| `body`    | `GroupUpdateRequest` |             |
| `ct`      | `CancellationToken`  |             |

**Returns:** `Task<GroupUpdateResult>`

### Tenants

#### AssignClientToTenantAsync(TenantId, ClientId, CancellationToken)

```csharp
public Task AssignClientToTenantAsync(TenantId tenantId, ClientId clientId, CancellationToken ct = default)
```

Assign a client to a tenant

Assign the client to the specified tenant. The client can then access tenant data and perform authorized actions.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `clientId` | `ClientId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### AssignGroupToTenantAsync(TenantId, GroupId, CancellationToken)

```csharp
public Task AssignGroupToTenantAsync(TenantId tenantId, GroupId groupId, CancellationToken ct = default)
```

Assign a group to a tenant

Assigns a group to a specified tenant. Group members (users, clients) can then access tenant data and perform authorized actions.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `groupId`  | `GroupId`           |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### AssignMappingRuleToTenantAsync(TenantId, MappingRuleId, CancellationToken)

```csharp
public Task AssignMappingRuleToTenantAsync(TenantId tenantId, MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Assign a mapping rule to a tenant

Assign a single mapping rule to a specified tenant.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `tenantId`      | `TenantId`          |             |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### AssignRoleToTenantAsync(TenantId, RoleId, CancellationToken)

```csharp
public Task AssignRoleToTenantAsync(TenantId tenantId, RoleId roleId, CancellationToken ct = default)
```

Assign a role to a tenant

Assigns a role to a specified tenant. Users, Clients or Groups, that have the role assigned, will get access to the tenant's data and can perform actions according to their authorizations.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `roleId`   | `RoleId`            |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### AssignUserToTenantAsync(TenantId, Username, CancellationToken)

```csharp
public Task AssignUserToTenantAsync(TenantId tenantId, Username username, CancellationToken ct = default)
```

Assign a user to a tenant

Assign a single user to a specified tenant. The user can then access tenant data and perform authorized actions.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task AssignUserToTenantExample(TenantId tenantId, Username username)
{
    using var client = CamundaClient.Create();

    await client.AssignUserToTenantAsync(
        tenantId,
        username);
}
```

#### CreateTenantAsync(TenantCreateRequest, CancellationToken)

```csharp
public Task<TenantCreateResult> CreateTenantAsync(TenantCreateRequest body, CancellationToken ct = default)
```

Create tenant

Creates a new tenant.

| Parameter | Type                  | Description |
| --------- | --------------------- | ----------- |
| `body`    | `TenantCreateRequest` |             |
| `ct`      | `CancellationToken`   |             |

**Returns:** `Task<TenantCreateResult>`

**Example**

```csharp
public static async Task CreateTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateTenantAsync(new TenantCreateRequest
    {
        TenantId = tenantId,
        Name = "Acme Corporation",
    });

    Console.WriteLine($"Tenant key: {result.TenantId}");
}
```

#### DeleteTenantAsync(TenantId, CancellationToken)

```csharp
public Task DeleteTenantAsync(TenantId tenantId, CancellationToken ct = default)
```

Delete tenant

Deletes an existing tenant.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    await client.DeleteTenantAsync(tenantId);
}
```

#### GetTenantAsync(TenantId, ConsistencyOptions\<TenantResult\>?, CancellationToken)

```csharp
public Task<TenantResult> GetTenantAsync(TenantId tenantId, ConsistencyOptions<TenantResult>? consistency = null, CancellationToken ct = default)
```

Get tenant

Retrieves a single tenant by tenant ID.

| Parameter     | Type                               | Description |
| ------------- | ---------------------------------- | ----------- |
| `tenantId`    | `TenantId`                         |             |
| `consistency` | `ConsistencyOptions<TenantResult>` |             |
| `ct`          | `CancellationToken`                |             |

**Returns:** `Task<TenantResult>`

**Example**

```csharp
public static async Task GetTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    var result = await client.GetTenantAsync(tenantId);
    Console.WriteLine($"Tenant: {result.Name}");
}
```

#### GetUsageMetricsAsync(DateTimeOffset, DateTimeOffset, TenantId?, bool?, ConsistencyOptions\<UsageMetricsResponse\>?, CancellationToken)

```csharp
public Task<UsageMetricsResponse> GetUsageMetricsAsync(DateTimeOffset startTime, DateTimeOffset endTime, TenantId? tenantId = null, bool? withTenants = null, ConsistencyOptions<UsageMetricsResponse>? consistency = null, CancellationToken ct = default)
```

Get usage metrics

Retrieve the usage metrics based on given criteria.

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `startTime`   | `DateTimeOffset`                           |             |
| `endTime`     | `DateTimeOffset`                           |             |
| `tenantId`    | `Nullable<TenantId>`                       |             |
| `withTenants` | `Nullable<Boolean>`                        |             |
| `consistency` | `ConsistencyOptions<UsageMetricsResponse>` |             |
| `ct`          | `CancellationToken`                        |             |

**Returns:** `Task<UsageMetricsResponse>`

**Example**

```csharp
public static async Task GetUsageMetricsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetUsageMetricsAsync(
        startTime: new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero),
        endTime: new DateTimeOffset(2024, 12, 31, 23, 59, 59, TimeSpan.Zero));

    Console.WriteLine($"Metrics: {result}");
}
```

#### SearchClientsForTenantAsync(TenantId, TenantClientSearchQueryRequest, ConsistencyOptions\<TenantClientSearchResult\>?, CancellationToken)

```csharp
public Task<TenantClientSearchResult> SearchClientsForTenantAsync(TenantId tenantId, TenantClientSearchQueryRequest body, ConsistencyOptions<TenantClientSearchResult>? consistency = null, CancellationToken ct = default)
```

Search clients for tenant

Retrieves a filtered and sorted list of clients for a specified tenant.

| Parameter     | Type                                           | Description |
| ------------- | ---------------------------------------------- | ----------- |
| `tenantId`    | `TenantId`                                     |             |
| `body`        | `TenantClientSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<TenantClientSearchResult>` |             |
| `ct`          | `CancellationToken`                            |             |

**Returns:** `Task<TenantClientSearchResult>`

#### SearchGroupIdsForTenantAsync(TenantId, TenantGroupSearchQueryRequest, ConsistencyOptions\<TenantGroupSearchResult\>?, CancellationToken)

```csharp
public Task<TenantGroupSearchResult> SearchGroupIdsForTenantAsync(TenantId tenantId, TenantGroupSearchQueryRequest body, ConsistencyOptions<TenantGroupSearchResult>? consistency = null, CancellationToken ct = default)
```

Search groups for tenant

Retrieves a filtered and sorted list of groups for a specified tenant.

| Parameter     | Type                                          | Description |
| ------------- | --------------------------------------------- | ----------- |
| `tenantId`    | `TenantId`                                    |             |
| `body`        | `TenantGroupSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<TenantGroupSearchResult>` |             |
| `ct`          | `CancellationToken`                           |             |

**Returns:** `Task<TenantGroupSearchResult>`

**Example**

```csharp
public static async Task SearchGroupIdsForTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchGroupIdsForTenantAsync(
        tenantId,
        new TenantGroupSearchQueryRequest());

    foreach (var group in result.Items)
    {
        Console.WriteLine($"Group: {group.GroupId}");
    }
}
```

#### SearchMappingRulesForTenantAsync(TenantId, MappingRuleSearchQueryRequest, ConsistencyOptions\<TenantMappingRuleSearchResult\>?, CancellationToken)

```csharp
public Task<TenantMappingRuleSearchResult> SearchMappingRulesForTenantAsync(TenantId tenantId, MappingRuleSearchQueryRequest body, ConsistencyOptions<TenantMappingRuleSearchResult>? consistency = null, CancellationToken ct = default)
```

Search mapping rules for tenant

Retrieves a filtered and sorted list of MappingRules for a specified tenant.

| Parameter     | Type                                                | Description |
| ------------- | --------------------------------------------------- | ----------- |
| `tenantId`    | `TenantId`                                          |             |
| `body`        | `MappingRuleSearchQueryRequest`                     |             |
| `consistency` | `ConsistencyOptions<TenantMappingRuleSearchResult>` |             |
| `ct`          | `CancellationToken`                                 |             |

**Returns:** `Task<TenantMappingRuleSearchResult>`

#### SearchRolesForTenantAsync(TenantId, RoleSearchQueryRequest, ConsistencyOptions\<TenantRoleSearchResult\>?, CancellationToken)

```csharp
public Task<TenantRoleSearchResult> SearchRolesForTenantAsync(TenantId tenantId, RoleSearchQueryRequest body, ConsistencyOptions<TenantRoleSearchResult>? consistency = null, CancellationToken ct = default)
```

Search roles for tenant

Retrieves a filtered and sorted list of roles for a specified tenant.

| Parameter     | Type                                         | Description |
| ------------- | -------------------------------------------- | ----------- |
| `tenantId`    | `TenantId`                                   |             |
| `body`        | `RoleSearchQueryRequest`                     |             |
| `consistency` | `ConsistencyOptions<TenantRoleSearchResult>` |             |
| `ct`          | `CancellationToken`                          |             |

**Returns:** `Task<TenantRoleSearchResult>`

#### SearchTenantsAsync(TenantSearchQueryRequest, ConsistencyOptions\<TenantSearchQueryResult\>?, CancellationToken)

```csharp
public Task<TenantSearchQueryResult> SearchTenantsAsync(TenantSearchQueryRequest body, ConsistencyOptions<TenantSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search tenants

Retrieves a filtered and sorted list of tenants.

| Parameter     | Type                                          | Description |
| ------------- | --------------------------------------------- | ----------- |
| `body`        | `TenantSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<TenantSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                           |             |

**Returns:** `Task<TenantSearchQueryResult>`

**Example**

```csharp
public static async Task SearchTenantsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchTenantsAsync(new TenantSearchQueryRequest());

    foreach (var tenant in result.Items)
    {
        Console.WriteLine($"Tenant: {tenant.Name}");
    }
}
```

#### SearchUsersForTenantAsync(TenantId, TenantUserSearchQueryRequest, ConsistencyOptions\<TenantUserSearchResult\>?, CancellationToken)

```csharp
public Task<TenantUserSearchResult> SearchUsersForTenantAsync(TenantId tenantId, TenantUserSearchQueryRequest body, ConsistencyOptions<TenantUserSearchResult>? consistency = null, CancellationToken ct = default)
```

Search users for tenant

Retrieves a filtered and sorted list of users for a specified tenant.

| Parameter     | Type                                         | Description |
| ------------- | -------------------------------------------- | ----------- |
| `tenantId`    | `TenantId`                                   |             |
| `body`        | `TenantUserSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<TenantUserSearchResult>` |             |
| `ct`          | `CancellationToken`                          |             |

**Returns:** `Task<TenantUserSearchResult>`

#### UnassignClientFromTenantAsync(TenantId, ClientId, CancellationToken)

```csharp
public Task UnassignClientFromTenantAsync(TenantId tenantId, ClientId clientId, CancellationToken ct = default)
```

Unassign a client from a tenant

Unassigns the client from the specified tenant. The client can no longer access tenant data.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `clientId` | `ClientId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignGroupFromTenantAsync(TenantId, GroupId, CancellationToken)

```csharp
public Task UnassignGroupFromTenantAsync(TenantId tenantId, GroupId groupId, CancellationToken ct = default)
```

Unassign a group from a tenant

Unassigns a group from a specified tenant. Members of the group (users, clients) will no longer have access to the tenant's data - except they are assigned directly to the tenant.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `groupId`  | `GroupId`           |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignMappingRuleFromTenantAsync(TenantId, MappingRuleId, CancellationToken)

```csharp
public Task UnassignMappingRuleFromTenantAsync(TenantId tenantId, MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Unassign a mapping rule from a tenant

Unassigns a single mapping rule from a specified tenant without deleting the rule.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `tenantId`      | `TenantId`          |             |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignRoleFromTenantAsync(TenantId, RoleId, CancellationToken)

```csharp
public Task UnassignRoleFromTenantAsync(TenantId tenantId, RoleId roleId, CancellationToken ct = default)
```

Unassign a role from a tenant

Unassigns a role from a specified tenant. Users, Clients or Groups, that have the role assigned, will no longer have access to the tenant's data - unless they are assigned directly to the tenant.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `roleId`   | `RoleId`            |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignUserFromTenantAsync(TenantId, Username, CancellationToken)

```csharp
public Task UnassignUserFromTenantAsync(TenantId tenantId, Username username, CancellationToken ct = default)
```

Unassign a user from a tenant

Unassigns the user from the specified tenant. The user can no longer access tenant data.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `tenantId` | `TenantId`          |             |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task UnassignUserFromTenantExample(TenantId tenantId, Username username)
{
    using var client = CamundaClient.Create();

    await client.UnassignUserFromTenantAsync(
        tenantId,
        username);
}
```

#### UpdateTenantAsync(TenantId, TenantUpdateRequest, CancellationToken)

```csharp
public Task<TenantUpdateResult> UpdateTenantAsync(TenantId tenantId, TenantUpdateRequest body, CancellationToken ct = default)
```

Update tenant

Updates an existing tenant.

| Parameter  | Type                  | Description |
| ---------- | --------------------- | ----------- |
| `tenantId` | `TenantId`            |             |
| `body`     | `TenantUpdateRequest` |             |
| `ct`       | `CancellationToken`   |             |

**Returns:** `Task<TenantUpdateResult>`

**Example**

```csharp
public static async Task UpdateTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    await client.UpdateTenantAsync(
        tenantId,
        new TenantUpdateRequest
        {
            Name = "Acme Corp International",
        });
}
```

### Roles

#### AssignRoleToClientAsync(RoleId, ClientId, CancellationToken)

```csharp
public Task AssignRoleToClientAsync(RoleId roleId, ClientId clientId, CancellationToken ct = default)
```

Assign a role to a client

Assigns the specified role to the client. The client will inherit the authorizations associated with this role.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `roleId`   | `RoleId`            |             |
| `clientId` | `ClientId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### AssignRoleToGroupAsync(RoleId, GroupId, CancellationToken)

```csharp
public Task AssignRoleToGroupAsync(RoleId roleId, GroupId groupId, CancellationToken ct = default)
```

Assign a role to a group

Assigns the specified role to the group. Every member of the group (user or client) will inherit the authorizations associated with this role.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `roleId`  | `RoleId`            |             |
| `groupId` | `GroupId`           |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

#### AssignRoleToMappingRuleAsync(RoleId, MappingRuleId, CancellationToken)

```csharp
public Task AssignRoleToMappingRuleAsync(RoleId roleId, MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Assign a role to a mapping rule

Assigns a role to a mapping rule.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `roleId`        | `RoleId`            |             |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### AssignRoleToUserAsync(RoleId, Username, CancellationToken)

```csharp
public Task AssignRoleToUserAsync(RoleId roleId, Username username, CancellationToken ct = default)
```

Assign a role to a user

Assigns the specified role to the user. The user will inherit the authorizations associated with this role.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `roleId`   | `RoleId`            |             |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### CreateRoleAsync(RoleCreateRequest, CancellationToken)

```csharp
public Task<RoleCreateResult> CreateRoleAsync(RoleCreateRequest body, CancellationToken ct = default)
```

Create role

Create a new role.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `body`    | `RoleCreateRequest` |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<RoleCreateResult>`

**Example**

```csharp
public static async Task CreateRoleExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CreateRoleAsync(new RoleCreateRequest
    {
        Name = "developer",
    });

    Console.WriteLine($"Role key: {result.RoleId}");
}
```

#### DeleteRoleAsync(RoleId, CancellationToken)

```csharp
public Task DeleteRoleAsync(RoleId roleId, CancellationToken ct = default)
```

Delete role

Deletes the role with the given ID.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `roleId`  | `RoleId`            |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

#### GetRoleAsync(RoleId, ConsistencyOptions\<RoleResult\>?, CancellationToken)

```csharp
public Task<RoleResult> GetRoleAsync(RoleId roleId, ConsistencyOptions<RoleResult>? consistency = null, CancellationToken ct = default)
```

Get role

Get a role by its ID.

| Parameter     | Type                             | Description |
| ------------- | -------------------------------- | ----------- |
| `roleId`      | `RoleId`                         |             |
| `consistency` | `ConsistencyOptions<RoleResult>` |             |
| `ct`          | `CancellationToken`              |             |

**Returns:** `Task<RoleResult>`

#### SearchClientsForRoleAsync(RoleId, RoleClientSearchQueryRequest, ConsistencyOptions\<RoleClientSearchResult\>?, CancellationToken)

```csharp
public Task<RoleClientSearchResult> SearchClientsForRoleAsync(RoleId roleId, RoleClientSearchQueryRequest body, ConsistencyOptions<RoleClientSearchResult>? consistency = null, CancellationToken ct = default)
```

Search role clients

Search clients with assigned role.

| Parameter     | Type                                         | Description |
| ------------- | -------------------------------------------- | ----------- |
| `roleId`      | `RoleId`                                     |             |
| `body`        | `RoleClientSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<RoleClientSearchResult>` |             |
| `ct`          | `CancellationToken`                          |             |

**Returns:** `Task<RoleClientSearchResult>`

#### SearchGroupsForRoleAsync(RoleId, RoleGroupSearchQueryRequest, ConsistencyOptions\<RoleGroupSearchResult\>?, CancellationToken)

```csharp
public Task<RoleGroupSearchResult> SearchGroupsForRoleAsync(RoleId roleId, RoleGroupSearchQueryRequest body, ConsistencyOptions<RoleGroupSearchResult>? consistency = null, CancellationToken ct = default)
```

Search role groups

Search groups with assigned role.

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `roleId`      | `RoleId`                                    |             |
| `body`        | `RoleGroupSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<RoleGroupSearchResult>` |             |
| `ct`          | `CancellationToken`                         |             |

**Returns:** `Task<RoleGroupSearchResult>`

#### SearchMappingRulesForRoleAsync(RoleId, MappingRuleSearchQueryRequest, ConsistencyOptions\<RoleMappingRuleSearchResult\>?, CancellationToken)

```csharp
public Task<RoleMappingRuleSearchResult> SearchMappingRulesForRoleAsync(RoleId roleId, MappingRuleSearchQueryRequest body, ConsistencyOptions<RoleMappingRuleSearchResult>? consistency = null, CancellationToken ct = default)
```

Search role mapping rules

Search mapping rules with assigned role.

| Parameter     | Type                                              | Description |
| ------------- | ------------------------------------------------- | ----------- |
| `roleId`      | `RoleId`                                          |             |
| `body`        | `MappingRuleSearchQueryRequest`                   |             |
| `consistency` | `ConsistencyOptions<RoleMappingRuleSearchResult>` |             |
| `ct`          | `CancellationToken`                               |             |

**Returns:** `Task<RoleMappingRuleSearchResult>`

#### SearchRolesAsync(RoleSearchQueryRequest, ConsistencyOptions\<RoleSearchQueryResult\>?, CancellationToken)

```csharp
public Task<RoleSearchQueryResult> SearchRolesAsync(RoleSearchQueryRequest body, ConsistencyOptions<RoleSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search roles

Search for roles based on given criteria.

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `body`        | `RoleSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<RoleSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                         |             |

**Returns:** `Task<RoleSearchQueryResult>`

**Example**

```csharp
public static async Task SearchRolesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchRolesAsync(new RoleSearchQueryRequest());

    foreach (var role in result.Items)
    {
        Console.WriteLine($"Role: {role.Name}");
    }
}
```

#### SearchRolesForGroupAsync(GroupId, RoleSearchQueryRequest, ConsistencyOptions\<GroupRoleSearchResult\>?, CancellationToken)

```csharp
public Task<GroupRoleSearchResult> SearchRolesForGroupAsync(GroupId groupId, RoleSearchQueryRequest body, ConsistencyOptions<GroupRoleSearchResult>? consistency = null, CancellationToken ct = default)
```

Search group roles

Search roles assigned to a group.

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `groupId`     | `GroupId`                                   |             |
| `body`        | `RoleSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<GroupRoleSearchResult>` |             |
| `ct`          | `CancellationToken`                         |             |

**Returns:** `Task<GroupRoleSearchResult>`

#### SearchUsersForRoleAsync(RoleId, RoleUserSearchQueryRequest, ConsistencyOptions\<RoleUserSearchResult\>?, CancellationToken)

```csharp
public Task<RoleUserSearchResult> SearchUsersForRoleAsync(RoleId roleId, RoleUserSearchQueryRequest body, ConsistencyOptions<RoleUserSearchResult>? consistency = null, CancellationToken ct = default)
```

Search role users

Search users with assigned role.

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `roleId`      | `RoleId`                                   |             |
| `body`        | `RoleUserSearchQueryRequest`               |             |
| `consistency` | `ConsistencyOptions<RoleUserSearchResult>` |             |
| `ct`          | `CancellationToken`                        |             |

**Returns:** `Task<RoleUserSearchResult>`

#### UnassignRoleFromClientAsync(RoleId, ClientId, CancellationToken)

```csharp
public Task UnassignRoleFromClientAsync(RoleId roleId, ClientId clientId, CancellationToken ct = default)
```

Unassign a role from a client

Unassigns the specified role from the client. The client will no longer inherit the authorizations associated with this role.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `roleId`   | `RoleId`            |             |
| `clientId` | `ClientId`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignRoleFromGroupAsync(RoleId, GroupId, CancellationToken)

```csharp
public Task UnassignRoleFromGroupAsync(RoleId roleId, GroupId groupId, CancellationToken ct = default)
```

Unassign a role from a group

Unassigns the specified role from the group. All group members (user or client) no longer inherit the authorizations associated with this role.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `roleId`  | `RoleId`            |             |
| `groupId` | `GroupId`           |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignRoleFromMappingRuleAsync(RoleId, MappingRuleId, CancellationToken)

```csharp
public Task UnassignRoleFromMappingRuleAsync(RoleId roleId, MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Unassign a role from a mapping rule

Unassigns a role from a mapping rule.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `roleId`        | `RoleId`            |             |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### UnassignRoleFromUserAsync(RoleId, Username, CancellationToken)

```csharp
public Task UnassignRoleFromUserAsync(RoleId roleId, Username username, CancellationToken ct = default)
```

Unassign a role from a user

Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role.

| Parameter  | Type                | Description |
| ---------- | ------------------- | ----------- |
| `roleId`   | `RoleId`            |             |
| `username` | `Username`          |             |
| `ct`       | `CancellationToken` |             |

**Returns:** `Task`

#### UpdateRoleAsync(RoleId, RoleUpdateRequest, CancellationToken)

```csharp
public Task<RoleUpdateResult> UpdateRoleAsync(RoleId roleId, RoleUpdateRequest body, CancellationToken ct = default)
```

Update role

Update a role with the given ID.

| Parameter | Type                | Description |
| --------- | ------------------- | ----------- |
| `roleId`  | `RoleId`            |             |
| `body`    | `RoleUpdateRequest` |             |
| `ct`      | `CancellationToken` |             |

**Returns:** `Task<RoleUpdateResult>`

### User Tasks

#### AssignUserTaskAsync(UserTaskKey, UserTaskAssignmentRequest, CancellationToken)

```csharp
public Task AssignUserTaskAsync(UserTaskKey userTaskKey, UserTaskAssignmentRequest body, CancellationToken ct = default)
```

Assign user task

Assigns a user task with the given key to the given assignee. Assignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

| Parameter     | Type                        | Description |
| ------------- | --------------------------- | ----------- |
| `userTaskKey` | `UserTaskKey`               |             |
| `body`        | `UserTaskAssignmentRequest` |             |
| `ct`          | `CancellationToken`         |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task AssignUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.AssignUserTaskAsync(
        userTaskKey,
        new UserTaskAssignmentRequest
        {
            Assignee = "user@example.com",
        });
}
```

#### CompleteUserTaskAsync(UserTaskKey, UserTaskCompletionRequest, CancellationToken)

```csharp
public Task CompleteUserTaskAsync(UserTaskKey userTaskKey, UserTaskCompletionRequest body, CancellationToken ct = default)
```

Complete user task

Completes a user task with the given key. Completion waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

| Parameter     | Type                        | Description |
| ------------- | --------------------------- | ----------- |
| `userTaskKey` | `UserTaskKey`               |             |
| `body`        | `UserTaskCompletionRequest` |             |
| `ct`          | `CancellationToken`         |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task CompleteUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.CompleteUserTaskAsync(
        userTaskKey,
        new UserTaskCompletionRequest());
}
```

#### GetUserTaskAsync(UserTaskKey, ConsistencyOptions\<UserTaskResult\>?, CancellationToken)

```csharp
public Task<UserTaskResult> GetUserTaskAsync(UserTaskKey userTaskKey, ConsistencyOptions<UserTaskResult>? consistency = null, CancellationToken ct = default)
```

Get user task

Get the user task by the user task key.

| Parameter     | Type                                 | Description |
| ------------- | ------------------------------------ | ----------- |
| `userTaskKey` | `UserTaskKey`                        |             |
| `consistency` | `ConsistencyOptions<UserTaskResult>` |             |
| `ct`          | `CancellationToken`                  |             |

**Returns:** `Task<UserTaskResult>`

**Example**

```csharp
public static async Task GetUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetUserTaskAsync(userTaskKey);
    Console.WriteLine($"User task: {result.UserTaskKey}");
}
```

#### GetUserTaskFormAsync(UserTaskKey, ConsistencyOptions\<FormResult\>?, CancellationToken)

```csharp
public Task<FormResult> GetUserTaskFormAsync(UserTaskKey userTaskKey, ConsistencyOptions<FormResult>? consistency = null, CancellationToken ct = default)
```

Get user task form

Get the form of a user task. Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.

| Parameter     | Type                             | Description |
| ------------- | -------------------------------- | ----------- |
| `userTaskKey` | `UserTaskKey`                    |             |
| `consistency` | `ConsistencyOptions<FormResult>` |             |
| `ct`          | `CancellationToken`              |             |

**Returns:** `Task<FormResult>`

**Example**

```csharp
public static async Task GetUserTaskFormExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetUserTaskFormAsync(userTaskKey);
    Console.WriteLine($"Form: {result.FormKey}");
}
```

#### SearchUserTaskAuditLogsAsync(UserTaskKey, UserTaskAuditLogSearchQueryRequest, ConsistencyOptions\<AuditLogSearchQueryResult\>?, CancellationToken)

```csharp
public Task<AuditLogSearchQueryResult> SearchUserTaskAuditLogsAsync(UserTaskKey userTaskKey, UserTaskAuditLogSearchQueryRequest body, ConsistencyOptions<AuditLogSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search user task audit logs

Search for user task audit logs based on given criteria.

| Parameter     | Type                                            | Description |
| ------------- | ----------------------------------------------- | ----------- |
| `userTaskKey` | `UserTaskKey`                                   |             |
| `body`        | `UserTaskAuditLogSearchQueryRequest`            |             |
| `consistency` | `ConsistencyOptions<AuditLogSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                             |             |

**Returns:** `Task<AuditLogSearchQueryResult>`

**Example**

```csharp
public static async Task SearchUserTaskAuditLogsExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchUserTaskAuditLogsAsync(
        userTaskKey,
        new UserTaskAuditLogSearchQueryRequest());

    foreach (var log in result.Items)
    {
        Console.WriteLine($"Audit log: {log.AuditLogKey}");
    }
}
```

#### SearchUserTaskEffectiveVariablesAsync(UserTaskKey, UserTaskEffectiveVariableSearchQueryRequest, bool?, ConsistencyOptions\<VariableSearchQueryResult\>?, CancellationToken)

```csharp
public Task<VariableSearchQueryResult> SearchUserTaskEffectiveVariablesAsync(UserTaskKey userTaskKey, UserTaskEffectiveVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<VariableSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search user task effective variables

Search for the effective variables of a user task. This endpoint returns deduplicated variables where each variable name appears at most once. When the same variable name exists at multiple scope levels in the scope hierarchy, the value from the innermost scope (closest to the user task) takes precedence. This is useful for retrieving the actual runtime state of variables as seen by the user task. By default, long variable values in the response are truncated.

| Parameter        | Type                                            | Description |
| ---------------- | ----------------------------------------------- | ----------- |
| `userTaskKey`    | `UserTaskKey`                                   |             |
| `body`           | `UserTaskEffectiveVariableSearchQueryRequest`   |             |
| `truncateValues` | `Nullable<Boolean>`                             |             |
| `consistency`    | `ConsistencyOptions<VariableSearchQueryResult>` |             |
| `ct`             | `CancellationToken`                             |             |

**Returns:** `Task<VariableSearchQueryResult>`

#### SearchUserTaskVariablesAsync(UserTaskKey, UserTaskVariableSearchQueryRequest, bool?, ConsistencyOptions\<VariableSearchQueryResult\>?, CancellationToken)

```csharp
public Task<VariableSearchQueryResult> SearchUserTaskVariablesAsync(UserTaskKey userTaskKey, UserTaskVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<VariableSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search user task variables

Search for user task variables based on given criteria. This endpoint returns all variable documents visible from the user task's scope, including variables from parent scopes in the scope hierarchy. If the same variable name exists at multiple scope levels, each scope's variable is returned as a separate result. Use the `/user-tasks/{userTaskKey}/effective-variables/search` endpoint to get deduplicated variables where the innermost scope takes precedence. By default, long variable values in the response are truncated.

| Parameter        | Type                                            | Description |
| ---------------- | ----------------------------------------------- | ----------- |
| `userTaskKey`    | `UserTaskKey`                                   |             |
| `body`           | `UserTaskVariableSearchQueryRequest`            |             |
| `truncateValues` | `Nullable<Boolean>`                             |             |
| `consistency`    | `ConsistencyOptions<VariableSearchQueryResult>` |             |
| `ct`             | `CancellationToken`                             |             |

**Returns:** `Task<VariableSearchQueryResult>`

#### SearchUserTasksAsync(UserTaskSearchQuery, ConsistencyOptions\<UserTaskSearchQueryResult\>?, CancellationToken)

```csharp
public Task<UserTaskSearchQueryResult> SearchUserTasksAsync(UserTaskSearchQuery body, ConsistencyOptions<UserTaskSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search user tasks

Search for user tasks based on given criteria.

| Parameter     | Type                                            | Description |
| ------------- | ----------------------------------------------- | ----------- |
| `body`        | `UserTaskSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<UserTaskSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                             |             |

**Returns:** `Task<UserTaskSearchQueryResult>`

**Example**

```csharp
public static async Task SearchUserTasksExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchUserTasksAsync(new UserTaskSearchQuery());

    foreach (var task in result.Items)
    {
        Console.WriteLine($"User task: {task.UserTaskKey}");
    }
}
```

#### UnassignUserTaskAsync(UserTaskKey, CancellationToken)

```csharp
public Task UnassignUserTaskAsync(UserTaskKey userTaskKey, CancellationToken ct = default)
```

Unassign user task

Removes the assignee of a task with the given key. Unassignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

| Parameter     | Type                | Description |
| ------------- | ------------------- | ----------- |
| `userTaskKey` | `UserTaskKey`       |             |
| `ct`          | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task UnassignUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.UnassignUserTaskAsync(userTaskKey);
}
```

#### UpdateUserTaskAsync(UserTaskKey, UserTaskUpdateRequest, CancellationToken)

```csharp
public Task UpdateUserTaskAsync(UserTaskKey userTaskKey, UserTaskUpdateRequest body, CancellationToken ct = default)
```

Update user task

Update a user task with the given key. Updates wait for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

| Parameter     | Type                    | Description |
| ------------- | ----------------------- | ----------- |
| `userTaskKey` | `UserTaskKey`           |             |
| `body`        | `UserTaskUpdateRequest` |             |
| `ct`          | `CancellationToken`     |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task UpdateUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateUserTaskAsync(
        userTaskKey,
        new UserTaskUpdateRequest());
}
```

### Signals

#### BroadcastSignalAsync(SignalBroadcastRequest, CancellationToken)

```csharp
public Task<SignalBroadcastResult> BroadcastSignalAsync(SignalBroadcastRequest body, CancellationToken ct = default)
```

Broadcast signal

Broadcasts a signal.

| Parameter | Type                     | Description |
| --------- | ------------------------ | ----------- |
| `body`    | `SignalBroadcastRequest` |             |
| `ct`      | `CancellationToken`      |             |

**Returns:** `Task<SignalBroadcastResult>`

**Example**

```csharp
public static async Task BroadcastSignalExample()
{
    using var client = CamundaClient.Create();

    var result = await client.BroadcastSignalAsync(new SignalBroadcastRequest
    {
        SignalName = "orderCancelled",
    });

    Console.WriteLine($"Signal key: {result.SignalKey}");
}
```

### Batch Operations

#### CancelBatchOperationAsync(BatchOperationKey, CancellationToken)

```csharp
public Task CancelBatchOperationAsync(BatchOperationKey batchOperationKey, CancellationToken ct = default)
```

Cancel Batch operation

Cancels a running batch operation. This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter           | Type                | Description |
| ------------------- | ------------------- | ----------- |
| `batchOperationKey` | `BatchOperationKey` |             |
| `ct`                | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task CancelBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    await client.CancelBatchOperationAsync(batchOperationKey);
}
```

#### GetBatchOperationAsync(BatchOperationKey, ConsistencyOptions\<BatchOperationResponse\>?, CancellationToken)

```csharp
public Task<BatchOperationResponse> GetBatchOperationAsync(BatchOperationKey batchOperationKey, ConsistencyOptions<BatchOperationResponse>? consistency = null, CancellationToken ct = default)
```

Get batch operation

Get batch operation by key.

| Parameter           | Type                                         | Description |
| ------------------- | -------------------------------------------- | ----------- |
| `batchOperationKey` | `BatchOperationKey`                          |             |
| `consistency`       | `ConsistencyOptions<BatchOperationResponse>` |             |
| `ct`                | `CancellationToken`                          |             |

**Returns:** `Task<BatchOperationResponse>`

**Example**

```csharp
public static async Task GetBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetBatchOperationAsync(
        batchOperationKey);

    Console.WriteLine($"Batch operation: {result.BatchOperationKey}");
}
```

#### ResumeBatchOperationAsync(BatchOperationKey, CancellationToken)

```csharp
public Task ResumeBatchOperationAsync(BatchOperationKey batchOperationKey, CancellationToken ct = default)
```

Resume Batch operation

Resumes a suspended batch operation. This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter           | Type                | Description |
| ------------------- | ------------------- | ----------- |
| `batchOperationKey` | `BatchOperationKey` |             |
| `ct`                | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ResumeBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    await client.ResumeBatchOperationAsync(batchOperationKey);
}
```

#### SearchBatchOperationItemsAsync(BatchOperationItemSearchQuery, ConsistencyOptions\<BatchOperationItemSearchQueryResult\>?, CancellationToken)

```csharp
public Task<BatchOperationItemSearchQueryResult> SearchBatchOperationItemsAsync(BatchOperationItemSearchQuery body, ConsistencyOptions<BatchOperationItemSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search batch operation items

Search for batch operation items based on given criteria.

| Parameter     | Type                                                      | Description |
| ------------- | --------------------------------------------------------- | ----------- |
| `body`        | `BatchOperationItemSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<BatchOperationItemSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                       |             |

**Returns:** `Task<BatchOperationItemSearchQueryResult>`

**Example**

```csharp
public static async Task SearchBatchOperationItemsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchBatchOperationItemsAsync(
        new BatchOperationItemSearchQuery());

    foreach (var item in result.Items)
    {
        Console.WriteLine($"Item: {item.ItemKey}");
    }
}
```

#### SearchBatchOperationsAsync(BatchOperationSearchQuery, ConsistencyOptions\<BatchOperationSearchQueryResult\>?, CancellationToken)

```csharp
public Task<BatchOperationSearchQueryResult> SearchBatchOperationsAsync(BatchOperationSearchQuery body, ConsistencyOptions<BatchOperationSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search batch operations

Search for batch operations based on given criteria.

| Parameter     | Type                                                  | Description |
| ------------- | ----------------------------------------------------- | ----------- |
| `body`        | `BatchOperationSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<BatchOperationSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                   |             |

**Returns:** `Task<BatchOperationSearchQueryResult>`

**Example**

```csharp
public static async Task SearchBatchOperationsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchBatchOperationsAsync(
        new BatchOperationSearchQuery());

    foreach (var op in result.Items)
    {
        Console.WriteLine($"Batch operation: {op.BatchOperationKey}");
    }
}
```

#### SuspendBatchOperationAsync(BatchOperationKey, CancellationToken)

```csharp
public Task SuspendBatchOperationAsync(BatchOperationKey batchOperationKey, CancellationToken ct = default)
```

Suspend Batch operation

Suspends a running batch operation. This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter           | Type                | Description |
| ------------------- | ------------------- | ----------- |
| `batchOperationKey` | `BatchOperationKey` |             |
| `ct`                | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task SuspendBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    await client.SuspendBatchOperationAsync(batchOperationKey);
}
```

### Messages

#### CorrelateMessageAsync(MessageCorrelationRequest, CancellationToken)

```csharp
public Task<MessageCorrelationResult> CorrelateMessageAsync(MessageCorrelationRequest body, CancellationToken ct = default)
```

Correlate message

Publishes a message and correlates it to a subscription. If correlation is successful it will return the first process instance key the message correlated with. The message is not buffered. Use the publish message endpoint to send messages that can be buffered.

| Parameter | Type                        | Description |
| --------- | --------------------------- | ----------- |
| `body`    | `MessageCorrelationRequest` |             |
| `ct`      | `CancellationToken`         |             |

**Returns:** `Task<MessageCorrelationResult>`

**Example**

```csharp
public static async Task CorrelateMessageExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CorrelateMessageAsync(new MessageCorrelationRequest
    {
        Name = "paymentReceived",
        CorrelationKey = "order-123",
    });

    Console.WriteLine($"Message key: {result.MessageKey}");
}
```

#### PublishMessageAsync(MessagePublicationRequest, CancellationToken)

```csharp
public Task<MessagePublicationResult> PublishMessageAsync(MessagePublicationRequest body, CancellationToken ct = default)
```

Publish message

Publishes a single message. Messages are published to specific partitions computed from their correlation keys. Messages can be buffered. The endpoint does not wait for a correlation result. Use the message correlation endpoint for such use cases.

| Parameter | Type                        | Description |
| --------- | --------------------------- | ----------- |
| `body`    | `MessagePublicationRequest` |             |
| `ct`      | `CancellationToken`         |             |

**Returns:** `Task<MessagePublicationResult>`

**Example**

```csharp
public static async Task PublishMessageExample()
{
    using var client = CamundaClient.Create();

    var result = await client.PublishMessageAsync(new MessagePublicationRequest
    {
        Name = "paymentReceived",
        CorrelationKey = "order-123",
        TimeToLive = 60000,
    });

    Console.WriteLine($"Message key: {result.MessageKey}");
}
```

#### SearchCorrelatedMessageSubscriptionsAsync(CorrelatedMessageSubscriptionSearchQuery, ConsistencyOptions\<CorrelatedMessageSubscriptionSearchQueryResult\>?, CancellationToken)

```csharp
public Task<CorrelatedMessageSubscriptionSearchQueryResult> SearchCorrelatedMessageSubscriptionsAsync(CorrelatedMessageSubscriptionSearchQuery body, ConsistencyOptions<CorrelatedMessageSubscriptionSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search correlated message subscriptions

Search correlated message subscriptions based on given criteria.

| Parameter     | Type                                                                 | Description |
| ------------- | -------------------------------------------------------------------- | ----------- |
| `body`        | `CorrelatedMessageSubscriptionSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<CorrelatedMessageSubscriptionSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                                  |             |

**Returns:** `Task<CorrelatedMessageSubscriptionSearchQueryResult>`

**Example**

```csharp
public static async Task SearchCorrelatedMessageSubscriptionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchCorrelatedMessageSubscriptionsAsync(
        new CorrelatedMessageSubscriptionSearchQuery());

    foreach (var sub in result.Items)
    {
        Console.WriteLine($"Correlated subscription: {sub.MessageName}");
    }
}
```

#### SearchMessageSubscriptionsAsync(MessageSubscriptionSearchQuery, ConsistencyOptions\<MessageSubscriptionSearchQueryResult\>?, CancellationToken)

```csharp
public Task<MessageSubscriptionSearchQueryResult> SearchMessageSubscriptionsAsync(MessageSubscriptionSearchQuery body, ConsistencyOptions<MessageSubscriptionSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search message subscriptions

Search for message subscriptions based on given criteria.

By default, both start and intermediate event subscriptions are returned. Use the `messageSubscriptionType` filter to restrict results to a single type.

**Version notes:**

- Start event subscriptions are only captured for deployments made with 8.10 or later.
- The `messageSubscriptionType` field is only populated for data created

with Camunda 8.10 or later. For pre-8.10 data, intermediate event entries have no `messageSubscriptionType` value stored. For convenience, the API returns `PROCESS_EVENT` as a default for such search results, though.

- Searching for intermediate event subscriptions **including legacy data** can be achieved

by filtering for `messageSubscriptionType` not matching `START_EVENT`.

| Parameter     | Type                                                       | Description |
| ------------- | ---------------------------------------------------------- | ----------- |
| `body`        | `MessageSubscriptionSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<MessageSubscriptionSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                        |             |

**Returns:** `Task<MessageSubscriptionSearchQueryResult>`

**Example**

```csharp
public static async Task SearchMessageSubscriptionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchMessageSubscriptionsAsync(
        new MessageSubscriptionSearchQuery());

    foreach (var sub in result.Items)
    {
        Console.WriteLine($"Subscription: {sub.MessageName}");
    }
}
```

### Authorizations

#### CreateAuthorizationAsync(AuthorizationRequest, CancellationToken)

```csharp
public Task<AuthorizationCreateResult> CreateAuthorizationAsync(AuthorizationRequest body, CancellationToken ct = default)
```

Create authorization

Create the authorization.

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `body`    | `AuthorizationRequest` |             |
| `ct`      | `CancellationToken`    |             |

**Returns:** `Task<AuthorizationCreateResult>`

**Example**

```csharp
public static async Task CreateAuthorizationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAuthorizationAsync(new AuthorizationPropertyBasedRequest
    {
        ResourceType = ResourceTypeEnum.PROCESSDEFINITION,
        PermissionTypes = new List<PermissionTypeEnum> { PermissionTypeEnum.READ, PermissionTypeEnum.UPDATE },
        ResourcePropertyName = "my-process",
        OwnerType = OwnerTypeEnum.USER,
        OwnerId = "user@example.com",
    });

    Console.WriteLine($"Authorization key: {result.AuthorizationKey}");
}
```

#### DeleteAuthorizationAsync(AuthorizationKey, CancellationToken)

```csharp
public Task DeleteAuthorizationAsync(AuthorizationKey authorizationKey, CancellationToken ct = default)
```

Delete authorization

Deletes the authorization with the given key.

| Parameter          | Type                | Description |
| ------------------ | ------------------- | ----------- |
| `authorizationKey` | `AuthorizationKey`  |             |
| `ct`               | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteAuthorizationExample(AuthorizationKey authorizationKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteAuthorizationAsync(authorizationKey);
}
```

#### GetAuthorizationAsync(AuthorizationKey, ConsistencyOptions\<AuthorizationResult\>?, CancellationToken)

```csharp
public Task<AuthorizationResult> GetAuthorizationAsync(AuthorizationKey authorizationKey, ConsistencyOptions<AuthorizationResult>? consistency = null, CancellationToken ct = default)
```

Get authorization

Get authorization by the given key.

| Parameter          | Type                                      | Description |
| ------------------ | ----------------------------------------- | ----------- |
| `authorizationKey` | `AuthorizationKey`                        |             |
| `consistency`      | `ConsistencyOptions<AuthorizationResult>` |             |
| `ct`               | `CancellationToken`                       |             |

**Returns:** `Task<AuthorizationResult>`

**Example**

```csharp
public static async Task GetAuthorizationExample(AuthorizationKey authorizationKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetAuthorizationAsync(
        authorizationKey);

    Console.WriteLine($"Resource type: {result.ResourceType}");
}
```

#### SearchAuthorizationsAsync(AuthorizationSearchQuery, ConsistencyOptions\<AuthorizationSearchResult\>?, CancellationToken)

```csharp
public Task<AuthorizationSearchResult> SearchAuthorizationsAsync(AuthorizationSearchQuery body, ConsistencyOptions<AuthorizationSearchResult>? consistency = null, CancellationToken ct = default)
```

Search authorizations

Search for authorizations based on given criteria.

| Parameter     | Type                                            | Description |
| ------------- | ----------------------------------------------- | ----------- |
| `body`        | `AuthorizationSearchQuery`                      |             |
| `consistency` | `ConsistencyOptions<AuthorizationSearchResult>` |             |
| `ct`          | `CancellationToken`                             |             |

**Returns:** `Task<AuthorizationSearchResult>`

**Example**

```csharp
public static async Task SearchAuthorizationsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAuthorizationsAsync(
        new AuthorizationSearchQuery());

    foreach (var auth in result.Items)
    {
        Console.WriteLine($"Authorization: {auth.AuthorizationKey}");
    }
}
```

#### UpdateAuthorizationAsync(AuthorizationKey, AuthorizationRequest, CancellationToken)

```csharp
public Task UpdateAuthorizationAsync(AuthorizationKey authorizationKey, AuthorizationRequest body, CancellationToken ct = default)
```

Update authorization

Update the authorization with the given key.

| Parameter          | Type                   | Description |
| ------------------ | ---------------------- | ----------- |
| `authorizationKey` | `AuthorizationKey`     |             |
| `body`             | `AuthorizationRequest` |             |
| `ct`               | `CancellationToken`    |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task UpdateAuthorizationExample(AuthorizationKey authorizationKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateAuthorizationAsync(
        authorizationKey,
        new AuthorizationPropertyBasedRequest
        {
            ResourceType = ResourceTypeEnum.PROCESSDEFINITION,
            PermissionTypes = new List<PermissionTypeEnum> { PermissionTypeEnum.READ, PermissionTypeEnum.UPDATE, PermissionTypeEnum.DELETE },
            ResourcePropertyName = "my-process",
            OwnerType = OwnerTypeEnum.USER,
            OwnerId = "user@example.com",
        });
}
```

### Deployments

#### CreateDeploymentAsync(MultipartFormDataContent, CancellationToken)

```csharp
public Task<DeploymentResult> CreateDeploymentAsync(MultipartFormDataContent content, CancellationToken ct = default)
```

Deploy resources

Deploys one or more resources, including BPMN processes, DMN decision models, forms, RPA resources, and generic files. A deployment can contain any file type. Files that are not interpreted as BPMN, DMN, form, or RPA resources are stored as deployable generic resources in the engine. This is an atomic call, i.e. either all resources are deployed or none of them are.

| Parameter | Type                       | Description |
| --------- | -------------------------- | ----------- |
| `content` | `MultipartFormDataContent` |             |
| `ct`      | `CancellationToken`        |             |

**Returns:** `Task<DeploymentResult>`

**Example**

```csharp
public static async Task CreateDeploymentExample()
{
    using var client = CamundaClient.Create();

    var content = new MultipartFormDataContent();
    var fileContent = new ByteArrayContent(File.ReadAllBytes("process.bpmn"));
    content.Add(fileContent, "resources", "process.bpmn");

    var result = await client.CreateDeploymentAsync(content);
    Console.WriteLine($"Deployment key: {result.DeploymentKey}");
}
```

### Documents

#### CreateDocumentAsync(MultipartFormDataContent, string?, DocumentId?, CancellationToken)

```csharp
public Task<DocumentReference> CreateDocumentAsync(MultipartFormDataContent content, string? storeId = null, DocumentId? documentId = null, CancellationToken ct = default)
```

Upload document

Upload a document to the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

| Parameter    | Type                       | Description |
| ------------ | -------------------------- | ----------- |
| `content`    | `MultipartFormDataContent` |             |
| `storeId`    | `String`                   |             |
| `documentId` | `Nullable<DocumentId>`     |             |
| `ct`         | `CancellationToken`        |             |

**Returns:** `Task<DocumentReference>`

**Example**

```csharp
public static async Task CreateDocumentExample()
{
    using var client = CamundaClient.Create();

    using var content = new MultipartFormDataContent();
    content.Add(new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes("Hello, world!")), "file", "hello.txt");

    var result = await client.CreateDocumentAsync(content);

    Console.WriteLine($"Document ID: {result.DocumentId}");
}
```

#### CreateDocumentLinkAsync(DocumentId, DocumentLinkRequest, string?, string?, CancellationToken)

```csharp
public Task<DocumentLink> CreateDocumentLinkAsync(DocumentId documentId, DocumentLinkRequest body, string? storeId = null, string? contentHash = null, CancellationToken ct = default)
```

Create document link

Create a link to a document in the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP

| Parameter     | Type                  | Description |
| ------------- | --------------------- | ----------- |
| `documentId`  | `DocumentId`          |             |
| `body`        | `DocumentLinkRequest` |             |
| `storeId`     | `String`              |             |
| `contentHash` | `String`              |             |
| `ct`          | `CancellationToken`   |             |

**Returns:** `Task<DocumentLink>`

**Example**

```csharp
public static async Task CreateDocumentLinkExample(DocumentId documentId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateDocumentLinkAsync(
        documentId,
        new DocumentLinkRequest());

    Console.WriteLine($"Document link: {result.Url}");
}
```

#### CreateDocumentsAsync(MultipartFormDataContent, string?, CancellationToken)

```csharp
public Task<DocumentCreationBatchResponse> CreateDocumentsAsync(MultipartFormDataContent content, string? storeId = null, CancellationToken ct = default)
```

Upload multiple documents

Upload multiple documents to the Camunda 8 cluster.

The caller must provide a file name for each document, which will be used in case of a multi-status response to identify which documents failed to upload. The file name can be provided in the `Content-Disposition` header of the file part or in the `fileName` field of the metadata. You can add a parallel array of metadata objects. These are matched with the files based on index, and must have the same length as the files array. To pass homogenous metadata for all files, spread the metadata over the metadata array. A filename value provided explicitly via the metadata array in the request overrides the `Content-Disposition` header of the file part.

In case of a multi-status response, the response body will contain a list of `DocumentBatchProblemDetail` objects, each of which contains the file name of the document that failed to upload and the reason for the failure. The client can choose to retry the whole batch or individual documents based on the response.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

| Parameter | Type                       | Description |
| --------- | -------------------------- | ----------- |
| `content` | `MultipartFormDataContent` |             |
| `storeId` | `String`                   |             |
| `ct`      | `CancellationToken`        |             |

**Returns:** `Task<DocumentCreationBatchResponse>`

**Example**

```csharp
public static async Task CreateDocumentsExample()
{
    using var client = CamundaClient.Create();

    using var content = new MultipartFormDataContent();
    content.Add(new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes("File one")), "files", "one.txt");
    content.Add(new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes("File two")), "files", "two.txt");

    var result = await client.CreateDocumentsAsync(content);

    foreach (var doc in result.CreatedDocuments)
    {
        Console.WriteLine($"Created: {doc.DocumentId}");
    }
}
```

#### DeleteDocumentAsync(DocumentId, string?, CancellationToken)

```csharp
public Task DeleteDocumentAsync(DocumentId documentId, string? storeId = null, CancellationToken ct = default)
```

Delete document

Delete a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

| Parameter    | Type                | Description |
| ------------ | ------------------- | ----------- |
| `documentId` | `DocumentId`        |             |
| `storeId`    | `String`            |             |
| `ct`         | `CancellationToken` |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteDocumentExample(DocumentId documentId)
{
    using var client = CamundaClient.Create();

    await client.DeleteDocumentAsync(documentId);
}
```

#### GetDocumentAsync(DocumentId, string?, string?, CancellationToken)

```csharp
public Task<byte[]> GetDocumentAsync(DocumentId documentId, string? storeId = null, string? contentHash = null, CancellationToken ct = default)
```

Download document

Download a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

| Parameter     | Type                | Description |
| ------------- | ------------------- | ----------- |
| `documentId`  | `DocumentId`        |             |
| `storeId`     | `String`            |             |
| `contentHash` | `String`            |             |
| `ct`          | `CancellationToken` |             |

**Returns:** `Task<Byte[]>`

**Example**

```csharp
public static async Task GetDocumentExample(DocumentId documentId)
{
    using var client = CamundaClient.Create();

    var content = await client.GetDocumentAsync(documentId);

    Console.WriteLine($"Downloaded document: {documentId}");
}
```

### Variables

#### CreateElementInstanceVariablesAsync(ElementInstanceKey, SetVariableRequest, CancellationToken)

```csharp
public Task CreateElementInstanceVariablesAsync(ElementInstanceKey elementInstanceKey, SetVariableRequest body, CancellationToken ct = default)
```

Update element instance variables

Updates all the variables of a particular scope (for example, process instance, element instance) with the given variable data. Specify the element instance in the `elementInstanceKey` parameter. Variable updates can be delayed by listener-related processing; if processing exceeds the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

| Parameter            | Type                 | Description |
| -------------------- | -------------------- | ----------- |
| `elementInstanceKey` | `ElementInstanceKey` |             |
| `body`               | `SetVariableRequest` |             |
| `ct`                 | `CancellationToken`  |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task CreateElementInstanceVariablesExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.CreateElementInstanceVariablesAsync(
        elementInstanceKey,
        new SetVariableRequest());
}
```

#### CreateGlobalClusterVariableAsync(CreateClusterVariableRequest, CancellationToken)

```csharp
public Task<ClusterVariableResult> CreateGlobalClusterVariableAsync(CreateClusterVariableRequest body, CancellationToken ct = default)
```

Create a global-scoped cluster variable

Create a global-scoped cluster variable.

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `body`    | `CreateClusterVariableRequest` |             |
| `ct`      | `CancellationToken`            |             |

**Returns:** `Task<ClusterVariableResult>`

**Example**

```csharp
public static async Task CreateGlobalClusterVariableExample(ClusterVariableName name)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateGlobalClusterVariableAsync(
        new CreateClusterVariableRequest
        {
            Name = name,
            Value = "my-value",
        });

    Console.WriteLine($"Created variable: {result.Name}");
}
```

#### CreateTenantClusterVariableAsync(TenantId, CreateClusterVariableRequest, CancellationToken)

```csharp
public Task<ClusterVariableResult> CreateTenantClusterVariableAsync(TenantId tenantId, CreateClusterVariableRequest body, CancellationToken ct = default)
```

Create a tenant-scoped cluster variable

Create a new cluster variable for the given tenant.

| Parameter  | Type                           | Description |
| ---------- | ------------------------------ | ----------- |
| `tenantId` | `TenantId`                     |             |
| `body`     | `CreateClusterVariableRequest` |             |
| `ct`       | `CancellationToken`            |             |

**Returns:** `Task<ClusterVariableResult>`

**Example**

```csharp
public static async Task CreateTenantClusterVariableExample(TenantId tenantId, ClusterVariableName name)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateTenantClusterVariableAsync(
        tenantId,
        new CreateClusterVariableRequest
        {
            Name = name,
            Value = "tenant-value",
        });

    Console.WriteLine($"Created variable: {result.Name}");
}
```

#### DeleteGlobalClusterVariableAsync(ClusterVariableName, CancellationToken)

```csharp
public Task DeleteGlobalClusterVariableAsync(ClusterVariableName name, CancellationToken ct = default)
```

Delete a global-scoped cluster variable

Delete a global-scoped cluster variable.

| Parameter | Type                  | Description |
| --------- | --------------------- | ----------- |
| `name`    | `ClusterVariableName` |             |
| `ct`      | `CancellationToken`   |             |

**Returns:** `Task`

#### DeleteTenantClusterVariableAsync(TenantId, ClusterVariableName, CancellationToken)

```csharp
public Task DeleteTenantClusterVariableAsync(TenantId tenantId, ClusterVariableName name, CancellationToken ct = default)
```

Delete a tenant-scoped cluster variable

Delete a tenant-scoped cluster variable.

| Parameter  | Type                  | Description |
| ---------- | --------------------- | ----------- |
| `tenantId` | `TenantId`            |             |
| `name`     | `ClusterVariableName` |             |
| `ct`       | `CancellationToken`   |             |

**Returns:** `Task`

#### GetGlobalClusterVariableAsync(ClusterVariableName, ConsistencyOptions\<ClusterVariableResult\>?, CancellationToken)

```csharp
public Task<ClusterVariableResult> GetGlobalClusterVariableAsync(ClusterVariableName name, ConsistencyOptions<ClusterVariableResult>? consistency = null, CancellationToken ct = default)
```

Get a global-scoped cluster variable

Get a global-scoped cluster variable.

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `name`        | `ClusterVariableName`                       |             |
| `consistency` | `ConsistencyOptions<ClusterVariableResult>` |             |
| `ct`          | `CancellationToken`                         |             |

**Returns:** `Task<ClusterVariableResult>`

#### GetTenantClusterVariableAsync(TenantId, ClusterVariableName, ConsistencyOptions\<ClusterVariableResult\>?, CancellationToken)

```csharp
public Task<ClusterVariableResult> GetTenantClusterVariableAsync(TenantId tenantId, ClusterVariableName name, ConsistencyOptions<ClusterVariableResult>? consistency = null, CancellationToken ct = default)
```

Get a tenant-scoped cluster variable

Get a tenant-scoped cluster variable.

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `tenantId`    | `TenantId`                                  |             |
| `name`        | `ClusterVariableName`                       |             |
| `consistency` | `ConsistencyOptions<ClusterVariableResult>` |             |
| `ct`          | `CancellationToken`                         |             |

**Returns:** `Task<ClusterVariableResult>`

#### GetVariableAsync(VariableKey, ConsistencyOptions\<VariableResult\>?, CancellationToken)

```csharp
public Task<VariableResult> GetVariableAsync(VariableKey variableKey, ConsistencyOptions<VariableResult>? consistency = null, CancellationToken ct = default)
```

Get variable

Get a variable by its key.

This endpoint returns both process-level and local (element-scoped) variables. The variable's scopeKey indicates whether it's a process-level variable or scoped to a specific element instance.

| Parameter     | Type                                 | Description |
| ------------- | ------------------------------------ | ----------- |
| `variableKey` | `VariableKey`                        |             |
| `consistency` | `ConsistencyOptions<VariableResult>` |             |
| `ct`          | `CancellationToken`                  |             |

**Returns:** `Task<VariableResult>`

**Example**

```csharp
public static async Task GetVariableExample(VariableKey variableKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetVariableAsync(variableKey);
    Console.WriteLine($"Variable: {result.Name} = {result.Value}");
}
```

#### SearchClusterVariablesAsync(ClusterVariableSearchQueryRequest, bool?, ConsistencyOptions\<ClusterVariableSearchQueryResult\>?, CancellationToken)

```csharp
public Task<ClusterVariableSearchQueryResult> SearchClusterVariablesAsync(ClusterVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<ClusterVariableSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search for cluster variables based on given criteria. By default, long variable values in the response are truncated.

| Parameter        | Type                                                   | Description |
| ---------------- | ------------------------------------------------------ | ----------- |
| `body`           | `ClusterVariableSearchQueryRequest`                    |             |
| `truncateValues` | `Nullable<Boolean>`                                    |             |
| `consistency`    | `ConsistencyOptions<ClusterVariableSearchQueryResult>` |             |
| `ct`             | `CancellationToken`                                    |             |

**Returns:** `Task<ClusterVariableSearchQueryResult>`

**Example**

```csharp
public static async Task SearchClusterVariablesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchClusterVariablesAsync(
        new ClusterVariableSearchQueryRequest());

    foreach (var variable in result.Items)
    {
        Console.WriteLine($"Variable: {variable.Name}");
    }
}
```

#### SearchVariablesAsync(VariableSearchQuery, bool?, ConsistencyOptions\<VariableSearchQueryResult\>?, CancellationToken)

```csharp
public Task<VariableSearchQueryResult> SearchVariablesAsync(VariableSearchQuery body, bool? truncateValues = null, ConsistencyOptions<VariableSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search variables

Search for variables based on given criteria.

This endpoint returns variables that exist directly at the specified scopes - it does not include variables from parent scopes that would be visible through the scope hierarchy.

Variables can be process-level (scoped to the process instance) or local (scoped to specific BPMN elements like tasks, subprocesses, etc.).

By default, long variable values in the response are truncated.

| Parameter        | Type                                            | Description |
| ---------------- | ----------------------------------------------- | ----------- |
| `body`           | `VariableSearchQuery`                           |             |
| `truncateValues` | `Nullable<Boolean>`                             |             |
| `consistency`    | `ConsistencyOptions<VariableSearchQueryResult>` |             |
| `ct`             | `CancellationToken`                             |             |

**Returns:** `Task<VariableSearchQueryResult>`

#### UpdateGlobalClusterVariableAsync(ClusterVariableName, UpdateClusterVariableRequest, CancellationToken)

```csharp
public Task<ClusterVariableResult> UpdateGlobalClusterVariableAsync(ClusterVariableName name, UpdateClusterVariableRequest body, CancellationToken ct = default)
```

Update a global-scoped cluster variable

Updates the value of an existing global cluster variable. The variable must exist, otherwise a 404 error is returned.

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `name`    | `ClusterVariableName`          |             |
| `body`    | `UpdateClusterVariableRequest` |             |
| `ct`      | `CancellationToken`            |             |

**Returns:** `Task<ClusterVariableResult>`

#### UpdateTenantClusterVariableAsync(TenantId, ClusterVariableName, UpdateClusterVariableRequest, CancellationToken)

```csharp
public Task<ClusterVariableResult> UpdateTenantClusterVariableAsync(TenantId tenantId, ClusterVariableName name, UpdateClusterVariableRequest body, CancellationToken ct = default)
```

Update a tenant-scoped cluster variable

Updates the value of an existing tenant-scoped cluster variable. The variable must exist, otherwise a 404 error is returned.

| Parameter  | Type                           | Description |
| ---------- | ------------------------------ | ----------- |
| `tenantId` | `TenantId`                     |             |
| `name`     | `ClusterVariableName`          |             |
| `body`     | `UpdateClusterVariableRequest` |             |
| `ct`       | `CancellationToken`            |             |

**Returns:** `Task<ClusterVariableResult>`

### Mappings

#### CreateMappingRuleAsync(MappingRuleCreateRequest, CancellationToken)

```csharp
public Task<MappingRuleCreateResult> CreateMappingRuleAsync(MappingRuleCreateRequest body, CancellationToken ct = default)
```

Create mapping rule

Create a new mapping rule

| Parameter | Type                       | Description |
| --------- | -------------------------- | ----------- |
| `body`    | `MappingRuleCreateRequest` |             |
| `ct`      | `CancellationToken`        |             |

**Returns:** `Task<MappingRuleCreateResult>`

**Example**

```csharp
public static async Task CreateMappingRuleExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CreateMappingRuleAsync(new MappingRuleCreateRequest
    {
        ClaimName = "groups",
        ClaimValue = "engineering",
        Name = "Engineering Group Mapping",
    });

    Console.WriteLine($"Mapping rule: {result.MappingRuleId}");
}
```

#### DeleteMappingRuleAsync(MappingRuleId, CancellationToken)

```csharp
public Task DeleteMappingRuleAsync(MappingRuleId mappingRuleId, CancellationToken ct = default)
```

Delete a mapping rule

Deletes the mapping rule with the given ID.

| Parameter       | Type                | Description |
| --------------- | ------------------- | ----------- |
| `mappingRuleId` | `MappingRuleId`     |             |
| `ct`            | `CancellationToken` |             |

**Returns:** `Task`

#### GetMappingRuleAsync(MappingRuleId, ConsistencyOptions\<MappingRuleResult\>?, CancellationToken)

```csharp
public Task<MappingRuleResult> GetMappingRuleAsync(MappingRuleId mappingRuleId, ConsistencyOptions<MappingRuleResult>? consistency = null, CancellationToken ct = default)
```

Get a mapping rule

Gets the mapping rule with the given ID.

| Parameter       | Type                                    | Description |
| --------------- | --------------------------------------- | ----------- |
| `mappingRuleId` | `MappingRuleId`                         |             |
| `consistency`   | `ConsistencyOptions<MappingRuleResult>` |             |
| `ct`            | `CancellationToken`                     |             |

**Returns:** `Task<MappingRuleResult>`

#### SearchMappingRuleAsync(MappingRuleSearchQueryRequest, ConsistencyOptions\<MappingRuleSearchQueryResult\>?, CancellationToken)

```csharp
public Task<MappingRuleSearchQueryResult> SearchMappingRuleAsync(MappingRuleSearchQueryRequest body, ConsistencyOptions<MappingRuleSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search mapping rules

Search for mapping rules based on given criteria.

| Parameter     | Type                                               | Description |
| ------------- | -------------------------------------------------- | ----------- |
| `body`        | `MappingRuleSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<MappingRuleSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                |             |

**Returns:** `Task<MappingRuleSearchQueryResult>`

#### UpdateMappingRuleAsync(MappingRuleId, MappingRuleUpdateRequest, CancellationToken)

```csharp
public Task<MappingRuleUpdateResult> UpdateMappingRuleAsync(MappingRuleId mappingRuleId, MappingRuleUpdateRequest body, CancellationToken ct = default)
```

Update mapping rule

Update a mapping rule.

| Parameter       | Type                       | Description |
| --------------- | -------------------------- | ----------- |
| `mappingRuleId` | `MappingRuleId`            |             |
| `body`          | `MappingRuleUpdateRequest` |             |
| `ct`            | `CancellationToken`        |             |

**Returns:** `Task<MappingRuleUpdateResult>`

### Decision Instances

#### DeleteDecisionInstanceAsync(DecisionEvaluationKey, DeleteDecisionInstanceRequest, CancellationToken)

```csharp
public Task DeleteDecisionInstanceAsync(DecisionEvaluationKey decisionEvaluationKey, DeleteDecisionInstanceRequest body, CancellationToken ct = default)
```

Delete decision instance

Delete all associated decision evaluations based on provided key.

| Parameter               | Type                            | Description |
| ----------------------- | ------------------------------- | ----------- |
| `decisionEvaluationKey` | `DecisionEvaluationKey`         |             |
| `body`                  | `DeleteDecisionInstanceRequest` |             |
| `ct`                    | `CancellationToken`             |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task DeleteDecisionInstanceExample(DecisionEvaluationKey decisionEvaluationKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteDecisionInstanceAsync(
        decisionEvaluationKey,
        new DeleteDecisionInstanceRequest());
}
```

#### DeleteDecisionInstancesBatchOperationAsync(DecisionInstanceDeletionBatchOperationRequest, CancellationToken)

```csharp
public Task<BatchOperationCreatedResult> DeleteDecisionInstancesBatchOperationAsync(DecisionInstanceDeletionBatchOperationRequest body, CancellationToken ct = default)
```

Delete decision instances (batch)

Delete multiple decision instances. This will delete the historic data from secondary storage. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

| Parameter | Type                                            | Description |
| --------- | ----------------------------------------------- | ----------- |
| `body`    | `DecisionInstanceDeletionBatchOperationRequest` |             |
| `ct`      | `CancellationToken`                             |             |

**Returns:** `Task<BatchOperationCreatedResult>`

**Example**

```csharp
public static async Task DeleteDecisionInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.DeleteDecisionInstancesBatchOperationAsync(
        new DecisionInstanceDeletionBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}
```

#### GetDecisionInstanceAsync(DecisionEvaluationInstanceKey, ConsistencyOptions\<DecisionInstanceGetQueryResult\>?, CancellationToken)

```csharp
public Task<DecisionInstanceGetQueryResult> GetDecisionInstanceAsync(DecisionEvaluationInstanceKey decisionEvaluationInstanceKey, ConsistencyOptions<DecisionInstanceGetQueryResult>? consistency = null, CancellationToken ct = default)
```

Get decision instance

Returns a decision instance.

| Parameter                       | Type                                                 | Description |
| ------------------------------- | ---------------------------------------------------- | ----------- |
| `decisionEvaluationInstanceKey` | `DecisionEvaluationInstanceKey`                      |             |
| `consistency`                   | `ConsistencyOptions<DecisionInstanceGetQueryResult>` |             |
| `ct`                            | `CancellationToken`                                  |             |

**Returns:** `Task<DecisionInstanceGetQueryResult>`

**Example**

```csharp
public static async Task GetDecisionInstanceExample(DecisionEvaluationInstanceKey decisionEvaluationInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionInstanceAsync(
        decisionEvaluationInstanceKey);

    Console.WriteLine($"Decision instance: {result.DecisionDefinitionId}");
}
```

#### SearchDecisionInstancesAsync(DecisionInstanceSearchQuery, ConsistencyOptions\<DecisionInstanceSearchQueryResult\>?, CancellationToken)

```csharp
public Task<DecisionInstanceSearchQueryResult> SearchDecisionInstancesAsync(DecisionInstanceSearchQuery body, ConsistencyOptions<DecisionInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search decision instances

Search for decision instances based on given criteria.

| Parameter     | Type                                                    | Description |
| ------------- | ------------------------------------------------------- | ----------- |
| `body`        | `DecisionInstanceSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<DecisionInstanceSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                     |             |

**Returns:** `Task<DecisionInstanceSearchQueryResult>`

**Example**

```csharp
public static async Task SearchDecisionInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchDecisionInstancesAsync(
        new DecisionInstanceSearchQuery());

    foreach (var di in result.Items)
    {
        Console.WriteLine($"Decision instance: {di.DecisionDefinitionId}");
    }
}
```

### Decisions

#### EvaluateDecisionAsync(DecisionEvaluationInstruction, CancellationToken)

```csharp
public Task<EvaluateDecisionResult> EvaluateDecisionAsync(DecisionEvaluationInstruction body, CancellationToken ct = default)
```

Evaluate decision

Evaluates a decision. You specify the decision to evaluate either by using its unique key (as returned by DeployResource), or using the decision ID. When using the decision ID, the latest deployed version of the decision is used.

| Parameter | Type                            | Description |
| --------- | ------------------------------- | ----------- |
| `body`    | `DecisionEvaluationInstruction` |             |
| `ct`      | `CancellationToken`             |             |

**Returns:** `Task<EvaluateDecisionResult>`

**Example**

```csharp
public static async Task EvaluateDecisionByIdExample(DecisionDefinitionId decisionDefinitionId)
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateDecisionAsync(new DecisionEvaluationById
    {
        DecisionDefinitionId = decisionDefinitionId,
    });

    Console.WriteLine($"Decision output: {result.Output}");
}

public static async Task EvaluateDecisionByKeyExample(DecisionDefinitionKey decisionDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateDecisionAsync(new DecisionEvaluationByKey
    {
        DecisionDefinitionKey = decisionDefinitionKey,
    });

    Console.WriteLine($"Decision output: {result.Output}");
}
```

### Audit Logs

#### GetAuditLogAsync(AuditLogKey, ConsistencyOptions\<AuditLogResult\>?, CancellationToken)

```csharp
public Task<AuditLogResult> GetAuditLogAsync(AuditLogKey auditLogKey, ConsistencyOptions<AuditLogResult>? consistency = null, CancellationToken ct = default)
```

Get audit log

Get an audit log entry by auditLogKey.

| Parameter     | Type                                 | Description |
| ------------- | ------------------------------------ | ----------- |
| `auditLogKey` | `AuditLogKey`                        |             |
| `consistency` | `ConsistencyOptions<AuditLogResult>` |             |
| `ct`          | `CancellationToken`                  |             |

**Returns:** `Task<AuditLogResult>`

**Example**

```csharp
public static async Task GetAuditLogExample(AuditLogKey auditLogKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetAuditLogAsync(auditLogKey);
    Console.WriteLine($"Audit log: {result.AuditLogKey}");
}
```

#### SearchAuditLogsAsync(AuditLogSearchQueryRequest, ConsistencyOptions\<AuditLogSearchQueryResult\>?, CancellationToken)

```csharp
public Task<AuditLogSearchQueryResult> SearchAuditLogsAsync(AuditLogSearchQueryRequest body, ConsistencyOptions<AuditLogSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search audit logs

Search for audit logs based on given criteria.

| Parameter     | Type                                            | Description |
| ------------- | ----------------------------------------------- | ----------- |
| `body`        | `AuditLogSearchQueryRequest`                    |             |
| `consistency` | `ConsistencyOptions<AuditLogSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                             |             |

**Returns:** `Task<AuditLogSearchQueryResult>`

**Example**

```csharp
public static async Task SearchAuditLogsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAuditLogsAsync(
        new AuditLogSearchQueryRequest());

    foreach (var log in result.Items)
    {
        Console.WriteLine($"Audit log: {log.AuditLogKey}");
    }
}
```

### Decision Definitions

#### GetDecisionDefinitionAsync(DecisionDefinitionKey, ConsistencyOptions\<DecisionDefinitionResult\>?, CancellationToken)

```csharp
public Task<DecisionDefinitionResult> GetDecisionDefinitionAsync(DecisionDefinitionKey decisionDefinitionKey, ConsistencyOptions<DecisionDefinitionResult>? consistency = null, CancellationToken ct = default)
```

Get decision definition

Returns a decision definition by key.

| Parameter               | Type                                           | Description |
| ----------------------- | ---------------------------------------------- | ----------- |
| `decisionDefinitionKey` | `DecisionDefinitionKey`                        |             |
| `consistency`           | `ConsistencyOptions<DecisionDefinitionResult>` |             |
| `ct`                    | `CancellationToken`                            |             |

**Returns:** `Task<DecisionDefinitionResult>`

**Example**

```csharp
public static async Task GetDecisionDefinitionExample(DecisionDefinitionKey decisionDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionDefinitionAsync(
        decisionDefinitionKey);

    Console.WriteLine($"Decision definition: {result.Name}");
}
```

#### GetDecisionDefinitionXmlAsync(DecisionDefinitionKey, ConsistencyOptions\<object\>?, CancellationToken)

```csharp
public Task<object> GetDecisionDefinitionXmlAsync(DecisionDefinitionKey decisionDefinitionKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)
```

Get decision definition XML

Returns decision definition as XML.

| Parameter               | Type                         | Description |
| ----------------------- | ---------------------------- | ----------- |
| `decisionDefinitionKey` | `DecisionDefinitionKey`      |             |
| `consistency`           | `ConsistencyOptions<Object>` |             |
| `ct`                    | `CancellationToken`          |             |

**Returns:** `Task<Object>`

**Example**

```csharp
public static async Task GetDecisionDefinitionXmlExample(DecisionDefinitionKey decisionDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionDefinitionXmlAsync(
        decisionDefinitionKey);

    Console.WriteLine($"XML: {result}");
}
```

#### SearchDecisionDefinitionsAsync(DecisionDefinitionSearchQuery, ConsistencyOptions\<DecisionDefinitionSearchQueryResult\>?, CancellationToken)

```csharp
public Task<DecisionDefinitionSearchQueryResult> SearchDecisionDefinitionsAsync(DecisionDefinitionSearchQuery body, ConsistencyOptions<DecisionDefinitionSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search decision definitions

Search for decision definitions based on given criteria.

| Parameter     | Type                                                      | Description |
| ------------- | --------------------------------------------------------- | ----------- |
| `body`        | `DecisionDefinitionSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<DecisionDefinitionSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                       |             |

**Returns:** `Task<DecisionDefinitionSearchQueryResult>`

**Example**

```csharp
public static async Task SearchDecisionDefinitionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchDecisionDefinitionsAsync(
        new DecisionDefinitionSearchQuery());

    foreach (var dd in result.Items)
    {
        Console.WriteLine($"Decision definition: {dd.Name}");
    }
}
```

### Decision Requirements

#### GetDecisionRequirementsAsync(DecisionRequirementsKey, ConsistencyOptions\<DecisionRequirementsResult\>?, CancellationToken)

```csharp
public Task<DecisionRequirementsResult> GetDecisionRequirementsAsync(DecisionRequirementsKey decisionRequirementsKey, ConsistencyOptions<DecisionRequirementsResult>? consistency = null, CancellationToken ct = default)
```

Get decision requirements

Returns Decision Requirements as JSON.

| Parameter                 | Type                                             | Description |
| ------------------------- | ------------------------------------------------ | ----------- |
| `decisionRequirementsKey` | `DecisionRequirementsKey`                        |             |
| `consistency`             | `ConsistencyOptions<DecisionRequirementsResult>` |             |
| `ct`                      | `CancellationToken`                              |             |

**Returns:** `Task<DecisionRequirementsResult>`

**Example**

```csharp
public static async Task GetDecisionRequirementsExample(DecisionRequirementsKey decisionRequirementsKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionRequirementsAsync(
        decisionRequirementsKey);

    Console.WriteLine($"DRD: {result.DecisionRequirementsName}");
}
```

#### GetDecisionRequirementsXmlAsync(DecisionRequirementsKey, ConsistencyOptions\<object\>?, CancellationToken)

```csharp
public Task<object> GetDecisionRequirementsXmlAsync(DecisionRequirementsKey decisionRequirementsKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)
```

Get decision requirements XML

Returns decision requirements as XML.

| Parameter                 | Type                         | Description |
| ------------------------- | ---------------------------- | ----------- |
| `decisionRequirementsKey` | `DecisionRequirementsKey`    |             |
| `consistency`             | `ConsistencyOptions<Object>` |             |
| `ct`                      | `CancellationToken`          |             |

**Returns:** `Task<Object>`

**Example**

```csharp
public static async Task GetDecisionRequirementsXmlExample(DecisionRequirementsKey decisionRequirementsKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionRequirementsXmlAsync(
        decisionRequirementsKey);

    Console.WriteLine($"XML: {result}");
}
```

#### SearchDecisionRequirementsAsync(DecisionRequirementsSearchQuery, ConsistencyOptions\<DecisionRequirementsSearchQueryResult\>?, CancellationToken)

```csharp
public Task<DecisionRequirementsSearchQueryResult> SearchDecisionRequirementsAsync(DecisionRequirementsSearchQuery body, ConsistencyOptions<DecisionRequirementsSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search decision requirements

Search for decision requirements based on given criteria.

| Parameter     | Type                                                        | Description |
| ------------- | ----------------------------------------------------------- | ----------- |
| `body`        | `DecisionRequirementsSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<DecisionRequirementsSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                         |             |

**Returns:** `Task<DecisionRequirementsSearchQueryResult>`

**Example**

```csharp
public static async Task SearchDecisionRequirementsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchDecisionRequirementsAsync(
        new DecisionRequirementsSearchQuery());

    foreach (var drd in result.Items)
    {
        Console.WriteLine($"DRD: {drd.DecisionRequirementsName}");
    }
}
```

### Incidents

#### GetIncidentAsync(IncidentKey, ConsistencyOptions\<IncidentResult\>?, CancellationToken)

```csharp
public Task<IncidentResult> GetIncidentAsync(IncidentKey incidentKey, ConsistencyOptions<IncidentResult>? consistency = null, CancellationToken ct = default)
```

Get incident

Returns incident as JSON.

| Parameter     | Type                                 | Description |
| ------------- | ------------------------------------ | ----------- |
| `incidentKey` | `IncidentKey`                        |             |
| `consistency` | `ConsistencyOptions<IncidentResult>` |             |
| `ct`          | `CancellationToken`                  |             |

**Returns:** `Task<IncidentResult>`

**Example**

```csharp
public static async Task GetIncidentExample(IncidentKey incidentKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetIncidentAsync(incidentKey);
    Console.WriteLine($"Incident: {result.IncidentKey}");
}
```

#### ResolveIncidentAsync(IncidentKey, IncidentResolutionRequest, CancellationToken)

```csharp
public Task ResolveIncidentAsync(IncidentKey incidentKey, IncidentResolutionRequest body, CancellationToken ct = default)
```

Resolve incident

Marks the incident as resolved; most likely a call to Update job will be necessary to reset the job's retries, followed by this call.

| Parameter     | Type                        | Description |
| ------------- | --------------------------- | ----------- |
| `incidentKey` | `IncidentKey`               |             |
| `body`        | `IncidentResolutionRequest` |             |
| `ct`          | `CancellationToken`         |             |

**Returns:** `Task`

**Example**

```csharp
public static async Task ResolveIncidentExample(IncidentKey incidentKey)
{
    using var client = CamundaClient.Create();

    await client.ResolveIncidentAsync(
        incidentKey,
        new IncidentResolutionRequest());
}
```

#### SearchElementInstanceIncidentsAsync(ElementInstanceKey, IncidentSearchQuery, ConsistencyOptions\<IncidentSearchQueryResult\>?, CancellationToken)

```csharp
public Task<IncidentSearchQueryResult> SearchElementInstanceIncidentsAsync(ElementInstanceKey elementInstanceKey, IncidentSearchQuery body, ConsistencyOptions<IncidentSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search for incidents of a specific element instance

Search for incidents caused by the specified element instance, including incidents of any child instances created from this element instance.

Although the `elementInstanceKey` is provided as a path parameter to indicate the root element instance, you may also include an `elementInstanceKey` within the filter object to narrow results to specific child element instances. This is useful, for example, if you want to isolate incidents associated with nested or subordinate elements within the given element instance while excluding incidents directly tied to the root element itself.

| Parameter            | Type                                            | Description |
| -------------------- | ----------------------------------------------- | ----------- |
| `elementInstanceKey` | `ElementInstanceKey`                            |             |
| `body`               | `IncidentSearchQuery`                           |             |
| `consistency`        | `ConsistencyOptions<IncidentSearchQueryResult>` |             |
| `ct`                 | `CancellationToken`                             |             |

**Returns:** `Task<IncidentSearchQueryResult>`

**Example**

```csharp
public static async Task SearchElementInstanceIncidentsExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchElementInstanceIncidentsAsync(
        elementInstanceKey,
        new IncidentSearchQuery());

    foreach (var incident in result.Items)
    {
        Console.WriteLine($"Incident: {incident.IncidentKey}");
    }
}
```

#### SearchIncidentsAsync(IncidentSearchQuery, ConsistencyOptions\<IncidentSearchQueryResult\>?, CancellationToken)

```csharp
public Task<IncidentSearchQueryResult> SearchIncidentsAsync(IncidentSearchQuery body, ConsistencyOptions<IncidentSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search incidents

Search for incidents based on given criteria.

| Parameter     | Type                                            | Description |
| ------------- | ----------------------------------------------- | ----------- |
| `body`        | `IncidentSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<IncidentSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                             |             |

**Returns:** `Task<IncidentSearchQueryResult>`

**Example**

```csharp
public static async Task SearchIncidentsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchIncidentsAsync(new IncidentSearchQuery());

    foreach (var incident in result.Items)
    {
        Console.WriteLine($"Incident: {incident.IncidentKey}");
    }
}
```

### Process Definitions

#### GetProcessDefinitionAsync(ProcessDefinitionKey, ConsistencyOptions\<ProcessDefinitionResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionResult> GetProcessDefinitionAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<ProcessDefinitionResult>? consistency = null, CancellationToken ct = default)
```

Get process definition

Returns process definition as JSON.

| Parameter              | Type                                          | Description |
| ---------------------- | --------------------------------------------- | ----------- |
| `processDefinitionKey` | `ProcessDefinitionKey`                        |             |
| `consistency`          | `ConsistencyOptions<ProcessDefinitionResult>` |             |
| `ct`                   | `CancellationToken`                           |             |

**Returns:** `Task<ProcessDefinitionResult>`

**Example**

```csharp
public static async Task GetProcessDefinitionExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionAsync(
        processDefinitionKey);

    Console.WriteLine($"Process definition: {result.Name}");
}
```

#### GetProcessDefinitionInstanceStatisticsAsync(ProcessDefinitionInstanceStatisticsQuery, ConsistencyOptions\<ProcessDefinitionInstanceStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionInstanceStatisticsQueryResult> GetProcessDefinitionInstanceStatisticsAsync(ProcessDefinitionInstanceStatisticsQuery body, ConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get process instance statistics

Get statistics about process instances, grouped by process definition and tenant.

| Parameter     | Type                                                                 | Description |
| ------------- | -------------------------------------------------------------------- | ----------- |
| `body`        | `ProcessDefinitionInstanceStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                                  |             |

**Returns:** `Task<ProcessDefinitionInstanceStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetProcessDefinitionInstanceStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionInstanceStatisticsAsync(
        new ProcessDefinitionInstanceStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Definition: {stat.ProcessDefinitionId}");
    }
}
```

#### GetProcessDefinitionInstanceVersionStatisticsAsync(ProcessDefinitionInstanceVersionStatisticsQuery, ConsistencyOptions\<ProcessDefinitionInstanceVersionStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionInstanceVersionStatisticsQueryResult> GetProcessDefinitionInstanceVersionStatisticsAsync(ProcessDefinitionInstanceVersionStatisticsQuery body, ConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get process instance statistics by version

Get statistics about process instances, grouped by version for a given process definition. The process definition ID must be provided as a required field in the request body filter.

| Parameter     | Type                                                                        | Description |
| ------------- | --------------------------------------------------------------------------- | ----------- |
| `body`        | `ProcessDefinitionInstanceVersionStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                                         |             |

**Returns:** `Task<ProcessDefinitionInstanceVersionStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetProcessDefinitionInstanceVersionStatisticsExample(ProcessDefinitionId processDefinitionId)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionInstanceVersionStatisticsAsync(
        new ProcessDefinitionInstanceVersionStatisticsQuery
        {
            Filter = new ProcessDefinitionInstanceVersionStatisticsFilter
            {
                ProcessDefinitionId = processDefinitionId,
            },
        });

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Version: {stat.ProcessDefinitionVersion}");
    }
}
```

#### GetProcessDefinitionMessageSubscriptionStatisticsAsync(ProcessDefinitionMessageSubscriptionStatisticsQuery, ConsistencyOptions\<ProcessDefinitionMessageSubscriptionStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionMessageSubscriptionStatisticsQueryResult> GetProcessDefinitionMessageSubscriptionStatisticsAsync(ProcessDefinitionMessageSubscriptionStatisticsQuery body, ConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get message subscription statistics

Get message subscription statistics, grouped by process definition.

| Parameter     | Type                                                                            | Description |
| ------------- | ------------------------------------------------------------------------------- | ----------- |
| `body`        | `ProcessDefinitionMessageSubscriptionStatisticsQuery`                           |             |
| `consistency` | `ConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>` |             |
| `ct`          | `CancellationToken`                                                             |             |

**Returns:** `Task<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetProcessDefinitionMessageSubscriptionStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionMessageSubscriptionStatisticsAsync(
        new ProcessDefinitionMessageSubscriptionStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Message subscriptions: {stat.ActiveSubscriptions}");
    }
}
```

#### GetProcessDefinitionStatisticsAsync(ProcessDefinitionKey, ProcessDefinitionElementStatisticsQuery, ConsistencyOptions\<ProcessDefinitionElementStatisticsQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionElementStatisticsQueryResult> GetProcessDefinitionStatisticsAsync(ProcessDefinitionKey processDefinitionKey, ProcessDefinitionElementStatisticsQuery body, ConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>? consistency = null, CancellationToken ct = default)
```

Get process definition statistics

Get statistics about elements in currently running process instances by process definition key and search filter.

| Parameter              | Type                                                                | Description |
| ---------------------- | ------------------------------------------------------------------- | ----------- |
| `processDefinitionKey` | `ProcessDefinitionKey`                                              |             |
| `body`                 | `ProcessDefinitionElementStatisticsQuery`                           |             |
| `consistency`          | `ConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>` |             |
| `ct`                   | `CancellationToken`                                                 |             |

**Returns:** `Task<ProcessDefinitionElementStatisticsQueryResult>`

**Example**

```csharp
public static async Task GetProcessDefinitionStatisticsExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionStatisticsAsync(
        processDefinitionKey,
        new ProcessDefinitionElementStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Element: {stat.ElementId}");
    }
}
```

#### GetProcessDefinitionXmlAsync(ProcessDefinitionKey, ConsistencyOptions\<object\>?, CancellationToken)

```csharp
public Task<object> GetProcessDefinitionXmlAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)
```

Get process definition XML

Returns process definition as XML.

| Parameter              | Type                         | Description |
| ---------------------- | ---------------------------- | ----------- |
| `processDefinitionKey` | `ProcessDefinitionKey`       |             |
| `consistency`          | `ConsistencyOptions<Object>` |             |
| `ct`                   | `CancellationToken`          |             |

**Returns:** `Task<Object>`

**Example**

```csharp
public static async Task GetProcessDefinitionXmlExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionXmlAsync(
        processDefinitionKey);

    Console.WriteLine($"XML: {result}");
}
```

#### GetStartProcessFormAsync(ProcessDefinitionKey, ConsistencyOptions\<FormResult\>?, CancellationToken)

```csharp
public Task<FormResult> GetStartProcessFormAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<FormResult>? consistency = null, CancellationToken ct = default)
```

Get process start form

Get the start form of a process. Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.

| Parameter              | Type                             | Description |
| ---------------------- | -------------------------------- | ----------- |
| `processDefinitionKey` | `ProcessDefinitionKey`           |             |
| `consistency`          | `ConsistencyOptions<FormResult>` |             |
| `ct`                   | `CancellationToken`              |             |

**Returns:** `Task<FormResult>`

**Example**

```csharp
public static async Task GetStartProcessFormExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetStartProcessFormAsync(
        processDefinitionKey);

    Console.WriteLine($"Form: {result.FormKey}");
}
```

#### SearchProcessDefinitionVariableNamesAsync(ProcessDefinitionKey, ProcessDefinitionVariableNameSearchQuery, ConsistencyOptions\<ProcessDefinitionVariableNameSearchQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionVariableNameSearchQueryResult> SearchProcessDefinitionVariableNamesAsync(ProcessDefinitionKey processDefinitionKey, ProcessDefinitionVariableNameSearchQuery body, ConsistencyOptions<ProcessDefinitionVariableNameSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search process definition variable names

Search for distinct variable names defined on a process definition, optionally narrowed by the name filter.

| Parameter              | Type                                                                 | Description |
| ---------------------- | -------------------------------------------------------------------- | ----------- |
| `processDefinitionKey` | `ProcessDefinitionKey`                                               |             |
| `body`                 | `ProcessDefinitionVariableNameSearchQuery`                           |             |
| `consistency`          | `ConsistencyOptions<ProcessDefinitionVariableNameSearchQueryResult>` |             |
| `ct`                   | `CancellationToken`                                                  |             |

**Returns:** `Task<ProcessDefinitionVariableNameSearchQueryResult>`

**Example**

```csharp
public static async Task SearchProcessDefinitionVariableNamesExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessDefinitionVariableNamesAsync(
        processDefinitionKey,
        new ProcessDefinitionVariableNameSearchQuery());

    foreach (var variable in result.Items)
    {
        Console.WriteLine($"Variable name: {variable.Name}");
    }
}
```

#### SearchProcessDefinitionsAsync(ProcessDefinitionSearchQuery, ConsistencyOptions\<ProcessDefinitionSearchQueryResult\>?, CancellationToken)

```csharp
public Task<ProcessDefinitionSearchQueryResult> SearchProcessDefinitionsAsync(ProcessDefinitionSearchQuery body, ConsistencyOptions<ProcessDefinitionSearchQueryResult>? consistency = null, CancellationToken ct = default)
```

Search process definitions

Search for process definitions based on given criteria.

| Parameter     | Type                                                     | Description |
| ------------- | -------------------------------------------------------- | ----------- |
| `body`        | `ProcessDefinitionSearchQuery`                           |             |
| `consistency` | `ConsistencyOptions<ProcessDefinitionSearchQueryResult>` |             |
| `ct`          | `CancellationToken`                                      |             |

**Returns:** `Task<ProcessDefinitionSearchQueryResult>`

**Example**

```csharp
public static async Task SearchProcessDefinitionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessDefinitionsAsync(
        new ProcessDefinitionSearchQuery());

    foreach (var pd in result.Items)
    {
        Console.WriteLine($"Process definition: {pd.Name}");
    }
}
```

---

## Configuration(Api-reference)


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Configuration and authentication types for the Camunda C# SDK.

## CamundaOptions

Options for constructing a `CamundaClient`.

Mirrors the JS SDK's CamundaOptions with idiomatic C# conventions.

```csharp
public sealed class CamundaOptions
```

### Properties

| Property             | Type                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| -------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Config`             | `Dictionary<String, String>` | Strongly typed env-style overrides (CAMUNDA_* keys).                                                                                                                                                                                                                                                                                                                                                                                             |
| `Configuration`      | `IConfiguration`             | An `Configuration.IConfiguration` section (typically `configuration.GetSection("Camunda")`) to bind settings from `appsettings.json` or any other configuration provider. Keys use PascalCase property names (e.g. `RestAddress`, `Auth:Strategy`) and are mapped to the canonical `CAMUNDA_*` env-var names internally. Precedence (highest wins): `CamundaOptions.Config` > `CamundaOptions.Configuration` > environment variables > defaults. |
| `HttpClient`         | `HttpClient`                 | Custom HttpClient factory. If not provided, a default HttpClient is created.                                                                                                                                                                                                                                                                                                                                                                     |
| `HttpMessageHandler` | `HttpMessageHandler`         | Custom HttpMessageHandler for the internal HttpClient (ignored if HttpClient is set). Useful for tests (e.g., MockHttpMessageHandler).                                                                                                                                                                                                                                                                                                           |
| `Env`                | `Dictionary<String, String>` | Provide a custom env map (mainly for tests). Defaults to Environment.GetEnvironmentVariable.                                                                                                                                                                                                                                                                                                                                                     |
| `LoggerFactory`      | `ILoggerFactory`             | Logger factory for SDK logging.                                                                                                                                                                                                                                                                                                                                                                                                                  |

## CamundaConfig

Hydrated Camunda configuration. Immutable after construction.

```csharp
public sealed class CamundaConfig
```

### Properties

| Property          | Type                   | Description |
| ----------------- | ---------------------- | ----------- |
| `RestAddress`     | `String`               |             |
| `TokenAudience`   | `String`               |             |
| `DefaultTenantId` | `String`               |             |
| `HttpRetry`       | `HttpRetryConfig`      |             |
| `Backpressure`    | `BackpressureConfig`   |             |
| `OAuth`           | `OAuthConfig`          |             |
| `Auth`            | `AuthConfig`           |             |
| `Validation`      | `ValidationConfig`     |             |
| `LogLevel`        | `String`               |             |
| `Eventual`        | `EventualConfig`       |             |
| `WorkerDefaults`  | `WorkerDefaultsConfig` |             |
| `Tls`             | `TlsConfig`            |             |

## ConfigurationHydrator

Hydrates a `CamundaConfig` from environment variables and overrides. Mirrors the JS SDK's hydrateConfig function.

```csharp
public static class ConfigurationHydrator
```

## AuthConfig

```csharp
public sealed class AuthConfig
```

### Properties

| Property   | Type              | Description |
| ---------- | ----------------- | ----------- |
| `Strategy` | `AuthStrategy`    |             |
| `Basic`    | `BasicAuthConfig` |             |

## AuthStrategy

Supported authentication strategies.

```csharp
public enum AuthStrategy
```

| Value   | Description |
| ------- | ----------- |
| `None`  |             |
| `OAuth` |             |
| `Basic` |             |

## BasicAuthConfig

```csharp
public sealed class BasicAuthConfig
```

### Properties

| Property   | Type     | Description |
| ---------- | -------- | ----------- |
| `Username` | `String` |             |
| `Password` | `String` |             |

## OAuthConfig

```csharp
public sealed class OAuthConfig
```

### Properties

| Property       | Type               | Description |
| -------------- | ------------------ | ----------- |
| `ClientId`     | `String`           |             |
| `ClientSecret` | `String`           |             |
| `OAuthUrl`     | `String`           |             |
| `GrantType`    | `String`           |             |
| `Scope`        | `String`           |             |
| `TimeoutMs`    | `Int32`            |             |
| `Retry`        | `OAuthRetryConfig` |             |

## OAuthRetryConfig

```csharp
public sealed class OAuthRetryConfig
```

### Properties

| Property      | Type    | Description |
| ------------- | ------- | ----------- |
| `Max`         | `Int32` |             |
| `BaseDelayMs` | `Int32` |             |

## HttpRetryConfig

```csharp
public sealed class HttpRetryConfig
```

### Properties

| Property      | Type    | Description |
| ------------- | ------- | ----------- |
| `MaxAttempts` | `Int32` |             |
| `BaseDelayMs` | `Int32` |             |
| `MaxDelayMs`  | `Int32` |             |

## BackpressureConfig

```csharp
public sealed class BackpressureConfig
```

### Properties

| Property             | Type      | Description |
| -------------------- | --------- | ----------- |
| `Enabled`            | `Boolean` |             |
| `Profile`            | `String`  |             |
| `ObserveOnly`        | `Boolean` |             |
| `InitialMax`         | `Int32`   |             |
| `SoftFactor`         | `Double`  |             |
| `SevereFactor`       | `Double`  |             |
| `RecoveryIntervalMs` | `Int32`   |             |
| `RecoveryStep`       | `Int32`   |             |
| `DecayQuietMs`       | `Int32`   |             |
| `Floor`              | `Int32`   |             |
| `SevereThreshold`    | `Int32`   |             |

## EventualConfig

```csharp
public sealed class EventualConfig
```

### Properties

| Property        | Type    | Description |
| --------------- | ------- | ----------- |
| `PollDefaultMs` | `Int32` |             |

## ValidationConfig

```csharp
public sealed class ValidationConfig
```

### Properties

| Property   | Type             | Description |
| ---------- | ---------------- | ----------- |
| `Request`  | `ValidationMode` |             |
| `Response` | `ValidationMode` |             |
| `Raw`      | `String`         |             |

## ValidationMode

Validation modes for request/response validation.

```csharp
public enum ValidationMode
```

| Value       | Description |
| ----------- | ----------- |
| `None`      |             |
| `Warn`      |             |
| `Strict`    |             |
| `Fanatical` |             |

## JobWorkerConfig

Configuration for a `JobWorker`.

```csharp
public sealed class JobWorkerConfig
```

### Properties

| Property                  | Type                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `JobType`                 | `String`                | The BPMN job type to subscribe to (e.g. `"payment-service"`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `JobTimeoutMs`            | `Nullable<Int64>`       | How long (in ms) the job is reserved for this worker before the broker makes it available to other workers. Falls back to `CAMUNDA_WORKER_TIMEOUT` environment variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `MaxConcurrentJobs`       | `Nullable<Int32>`       | Maximum number of jobs that may be in-flight (activated and being handled) concurrently by this worker. Controls how many jobs are requested per poll and how many handler tasks run in parallel. For I/O-bound handlers (HTTP calls, database queries), higher values (32–128) improve throughput because async handlers release threads during awaits. For CPU-bound handlers, set to `Environment.ProcessorCount` or lower to avoid over-subscribing the thread pool. Set to `1` for sequential (single-job-at-a-time) processing. Falls back to `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS` environment variable, then `10`. |
| `PollIntervalMs`          | `Int32`                 | Delay (in ms) between poll cycles when no jobs are available or when at capacity. Default: 500 ms.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `PollTimeoutMs`           | `Nullable<Int64>`       | Long-poll timeout (in ms) sent to the broker. The broker holds the activation request open until jobs are available or this timeout elapses. `null` or `0` = broker default; negative = long polling disabled.                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FetchVariables`          | `List<String>`          | Variable names to fetch from the process instance scope. `null` = fetch all.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `WorkerName`              | `String`                | Worker name sent to the broker for logging and diagnostics. Auto-generated if not set.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `AutoStart`               | `Boolean`               | Whether to start polling immediately on creation. Default: `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `StartupJitterMaxSeconds` | `Double`                | Maximum random delay (in seconds) before the worker starts polling. When multiple application instances restart simultaneously, this spreads out initial activation requests to avoid saturating the server. `0` (the default) means no delay.                                                                                                                                                                                                                                                                                                                                                                            |
| `TenantIds`               | `IReadOnlyList<String>` | Restrict job activation to the given tenant IDs (multi-tenant setups). Cannot be combined with `JobWorkerConfig.TenantId` — setting both is rejected with `ArgumentException`. If neither `JobWorkerConfig.TenantIds` nor `JobWorkerConfig.TenantId` is set (or `JobWorkerConfig.TenantIds` is empty), the activation request falls back to `[CamundaConfig.DefaultTenantId]` (which itself defaults to `""` and can be overridden via the `CAMUNDA_DEFAULT_TENANT_ID` environment variable).                                                                                                                             |
| `TenantId`                | `String`                | Convenience for the common single-tenant case. Equivalent to setting `JobWorkerConfig.TenantIds` to `[TenantId]`. Cannot be combined with `JobWorkerConfig.TenantIds`.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |

## ConfigErrorCode

Configuration hydration errors.

```csharp
public enum ConfigErrorCode
```

| Value                     | Description |
| ------------------------- | ----------- |
| `MissingRequired`         |             |
| `InvalidEnum`             |             |
| `InvalidBoolean`          |             |
| `InvalidInteger`          |             |
| `InvalidValidationSyntax` |             |

## ConfigErrorDetail

```csharp
public sealed class ConfigErrorDetail
```

### Properties

| Property  | Type              | Description |
| --------- | ----------------- | ----------- |
| `Key`     | `String`          |             |
| `Code`    | `ConfigErrorCode` |             |
| `Message` | `String`          |             |

---

## Enums


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Enumeration types (89 enums).

## AgentInstanceHistoryCommitStatusEnum

The commit status of a history item.

COMMITTED: the producing job completed successfully. PENDING: the producing job is still active (in-flight). DISCARDED: the producing job failed; this item was superseded by a later activation.

| Value       | Description |
| ----------- | ----------- |
| `COMMITTED` |             |
| `PENDING`   |             |
| `DISCARDED` |             |

## AgentInstanceHistoryRoleEnum

The role of a history item in the agent conversation.

| Value        | Description |
| ------------ | ----------- |
| `USER`       |             |
| `ASSISTANT`  |             |
| `TOOLRESULT` |             |

## AgentInstanceHistorySearchQuerySortRequestField

The field to sort by.

| Value            | Description |
| ---------------- | ----------- |
| `ProducedAt`     |             |
| `HistoryItemKey` |             |
| `LoopIteration`  |             |

## AgentInstanceMessageContentTypeEnum

The content type discriminator for a history item content block.

| Value      | Description |
| ---------- | ----------- |
| `TEXT`     |             |
| `DOCUMENT` |             |
| `OBJECT`   |             |

## AgentInstanceSearchQuerySortRequestField

The field to sort by.

| Value                    | Description |
| ------------------------ | ----------- |
| `AgentInstanceKey`       |             |
| `Status`                 |             |
| `ElementId`              |             |
| `ProcessInstanceKey`     |             |
| `RootProcessInstanceKey` |             |
| `ProcessDefinitionKey`   |             |
| `TenantId`               |             |
| `CreationDate`           |             |
| `LastUpdatedDate`        |             |
| `CompletionDate`         |             |

## AgentInstanceStatusEnum

The current status of an agent instance.

| Value           | Description |
| --------------- | ----------- |
| `UNKNOWN`       |             |
| `COMPLETED`     |             |
| `IDLE`          |             |
| `INITIALIZING`  |             |
| `THINKING`      |             |
| `TOOLCALLING`   |             |
| `TOOLDISCOVERY` |             |

## AgentInstanceUpdateStatusEnum

The status values that can be set on an agent instance via an update request.

| Value           | Description |
| --------------- | ----------- |
| `IDLE`          |             |
| `THINKING`      |             |
| `TOOLCALLING`   |             |
| `TOOLDISCOVERY` |             |

## AuditLogActorTypeEnum

The type of actor who performed the operation.

| Value       | Description |
| ----------- | ----------- |
| `ANONYMOUS` |             |
| `CLIENT`    |             |
| `UNKNOWN`   |             |
| `USER`      |             |

## AuditLogCategoryEnum

The category of the audit log operation.

| Value               | Description |
| ------------------- | ----------- |
| `ADMIN`             |             |
| `DEPLOYEDRESOURCES` |             |
| `USERTASKS`         |             |

## AuditLogEntityTypeEnum

The type of entity affected by the operation.

| Value             | Description |
| ----------------- | ----------- |
| `AUTHORIZATION`   |             |
| `BATCH`           |             |
| `DECISION`        |             |
| `GROUP`           |             |
| `INCIDENT`        |             |
| `JOB`             |             |
| `MAPPINGRULE`     |             |
| `PROCESSINSTANCE` |             |
| `RESOURCE`        |             |
| `ROLE`            |             |
| `TENANT`          |             |
| `USER`            |             |
| `USERTASK`        |             |
| `VARIABLE`        |             |
| `CLIENT`          |             |

## AuditLogOperationTypeEnum

The type of operation performed.

| Value      | Description |
| ---------- | ----------- |
| `ASSIGN`   |             |
| `CANCEL`   |             |
| `COMPLETE` |             |
| `CREATE`   |             |
| `DELETE`   |             |
| `EVALUATE` |             |
| `MIGRATE`  |             |
| `MODIFY`   |             |
| `RESOLVE`  |             |
| `RESUME`   |             |
| `SUSPEND`  |             |
| `UNASSIGN` |             |
| `UNKNOWN`  |             |
| `UPDATE`   |             |

## AuditLogResultEnum

The result status of the operation.

| Value     | Description |
| --------- | ----------- |
| `FAIL`    |             |
| `SUCCESS` |             |

## AuditLogSearchQuerySortRequestField

The field to sort by.

| Value                     | Description |
| ------------------------- | ----------- |
| `ActorId`                 |             |
| `ActorType`               |             |
| `AuditLogKey`             |             |
| `BatchOperationKey`       |             |
| `BatchOperationType`      |             |
| `Category`                |             |
| `DecisionDefinitionId`    |             |
| `DecisionDefinitionKey`   |             |
| `DecisionEvaluationKey`   |             |
| `DecisionRequirementsId`  |             |
| `DecisionRequirementsKey` |             |
| `ElementInstanceKey`      |             |
| `EntityKey`               |             |
| `EntityType`              |             |
| `JobKey`                  |             |
| `OperationType`           |             |
| `ProcessDefinitionId`     |             |
| `ProcessDefinitionKey`    |             |
| `ProcessInstanceKey`      |             |
| `InboundChannelType`      |             |
| `InboundChannelToolName`  |             |
| `Result`                  |             |
| `TenantId`                |             |
| `Timestamp`               |             |
| `UserTaskKey`             |             |

## AuthorizationSearchQuerySortRequestField

The field to sort by.

| Value                  | Description |
| ---------------------- | ----------- |
| `OwnerId`              |             |
| `OwnerType`            |             |
| `ResourceId`           |             |
| `ResourcePropertyName` |             |
| `ResourceType`         |             |

## BatchOperationErrorType

The type of the error that occurred during the batch operation.

| Value                      | Description |
| -------------------------- | ----------- |
| `QUERYFAILED`              |             |
| `RESULTBUFFERSIZEEXCEEDED` |             |

## BatchOperationItemResponseState

State of the item.

| Value       | Description |
| ----------- | ----------- |
| `ACTIVE`    |             |
| `COMPLETED` |             |
| `SKIPPED`   |             |
| `CANCELED`  |             |
| `FAILED`    |             |

## BatchOperationItemSearchQuerySortRequestField

The field to sort by.

| Value                | Description |
| -------------------- | ----------- |
| `BatchOperationKey`  |             |
| `ItemKey`            |             |
| `ProcessInstanceKey` |             |
| `ProcessedDate`      |             |
| `State`              |             |

## BatchOperationItemStateEnum

The batch operation item state.

| Value       | Description |
| ----------- | ----------- |
| `ACTIVE`    |             |
| `COMPLETED` |             |
| `CANCELED`  |             |
| `FAILED`    |             |

## BatchOperationSearchQuerySortRequestField

The field to sort by.

| Value               | Description |
| ------------------- | ----------- |
| `BatchOperationKey` |             |
| `OperationType`     |             |
| `State`             |             |
| `StartDate`         |             |
| `EndDate`           |             |
| `ActorType`         |             |
| `ActorId`           |             |

## BatchOperationStateEnum

The batch operation state.

| Value                | Description |
| -------------------- | ----------- |
| `ACTIVE`             |             |
| `CANCELED`           |             |
| `COMPLETED`          |             |
| `CREATED`            |             |
| `FAILED`             |             |
| `PARTIALLYCOMPLETED` |             |
| `SUSPENDED`          |             |

## BatchOperationTypeEnum

The type of the batch operation.

| Value                      | Description |
| -------------------------- | ----------- |
| `ADDVARIABLE`              |             |
| `CANCELPROCESSINSTANCE`    |             |
| `DELETEDECISIONDEFINITION` |             |
| `DELETEDECISIONINSTANCE`   |             |
| `DELETEPROCESSDEFINITION`  |             |
| `DELETEPROCESSINSTANCE`    |             |
| `MIGRATEPROCESSINSTANCE`   |             |
| `MODIFYPROCESSINSTANCE`    |             |
| `RESOLVEINCIDENT`          |             |
| `RESUMEPROCESSINSTANCE`    |             |
| `SUSPENDPROCESSINSTANCE`   |             |
| `UPDATEJOB`                |             |
| `UPDATEVARIABLE`           |             |

## CamundaAuthErrorCode

Auth error codes matching the JS SDK.

| Value                     | Description |
| ------------------------- | ----------- |
| `TokenFetchFailed`        |             |
| `TokenParseFailed`        |             |
| `TokenExpired`            |             |
| `OAuthConfigMissing`      |             |
| `BasicCredentialsMissing` |             |

## CloudStage

The cloud deployment stage.

| Value  | Description |
| ------ | ----------- |
| `Dev`  |             |
| `Int`  |             |
| `Prod` |             |

## ClusterVariableKindEnum

The kind of a cluster variable. JSON is the default. SECRET_REFERENCE allows the value to contain camunda.secrets.X references that are resolved at job activation time.

| Value             | Description |
| ----------------- | ----------- |
| `JSON`            |             |
| `SECRETREFERENCE` |             |

## ClusterVariableScopeEnum

The scope of a cluster variable.

| Value    | Description |
| -------- | ----------- |
| `GLOBAL` |             |
| `TENANT` |             |

## ClusterVariableSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `Name`     |             |
| `Value`    |             |
| `TenantId` |             |
| `Scope`    |             |

## CorrelatedMessageSubscriptionSearchQuerySortRequestField

The field to sort by.

| Value                  | Description |
| ---------------------- | ----------- |
| `BusinessId`           |             |
| `CorrelationKey`       |             |
| `CorrelationTime`      |             |
| `ElementId`            |             |
| `ElementInstanceKey`   |             |
| `MessageKey`           |             |
| `MessageName`          |             |
| `PartitionId`          |             |
| `ProcessDefinitionId`  |             |
| `ProcessDefinitionKey` |             |
| `ProcessInstanceKey`   |             |
| `SubscriptionKey`      |             |
| `TenantId`             |             |

## DecisionDefinitionSearchQuerySortRequestField

The field to sort by.

| Value                         | Description |
| ----------------------------- | ----------- |
| `DecisionDefinitionKey`       |             |
| `DecisionDefinitionId`        |             |
| `Name`                        |             |
| `Version`                     |             |
| `DecisionRequirementsId`      |             |
| `DecisionRequirementsKey`     |             |
| `DecisionRequirementsName`    |             |
| `DecisionRequirementsVersion` |             |
| `TenantId`                    |             |

## DecisionDefinitionTypeEnum

The type of the decision. UNSPECIFIED is deprecated and should not be used anymore, for removal in 8.10

| Value               | Description |
| ------------------- | ----------- |
| `DECISIONTABLE`     |             |
| `LITERALEXPRESSION` |             |
| `UNSPECIFIED`       |             |
| `UNKNOWN`           |             |

## DecisionInstanceSearchQuerySortRequestField

The field to sort by.

| Value                           | Description |
| ------------------------------- | ----------- |
| `BusinessId`                    |             |
| `DecisionDefinitionId`          |             |
| `DecisionDefinitionKey`         |             |
| `DecisionDefinitionName`        |             |
| `DecisionDefinitionType`        |             |
| `DecisionDefinitionVersion`     |             |
| `DecisionEvaluationInstanceKey` |             |
| `DecisionEvaluationKey`         |             |
| `ElementInstanceKey`            |             |
| `EvaluationDate`                |             |
| `EvaluationFailure`             |             |
| `ProcessDefinitionKey`          |             |
| `ProcessInstanceKey`            |             |
| `RootDecisionDefinitionKey`     |             |
| `State`                         |             |
| `TenantId`                      |             |

## DecisionInstanceStateEnum

The state of the decision instance. UNSPECIFIED and UNKNOWN are deprecated and should not be used anymore, for removal in 8.10

| Value         | Description |
| ------------- | ----------- |
| `EVALUATED`   |             |
| `FAILED`      |             |
| `UNSPECIFIED` |             |
| `UNKNOWN`     |             |

## DecisionRequirementsSearchQuerySortRequestField

The field to sort by.

| Value                      | Description |
| -------------------------- | ----------- |
| `DecisionRequirementsKey`  |             |
| `DecisionRequirementsName` |             |
| `Version`                  |             |
| `DecisionRequirementsId`   |             |
| `TenantId`                 |             |

## DocumentReferenceCamundaDocumentType

Document discriminator. Always set to "camunda".

| Value     | Description |
| --------- | ----------- |
| `Camunda` |             |

## ElementInstanceFilterFieldsType

Type of element as defined set of values.

| Value                          | Description |
| ------------------------------ | ----------- |
| `UNSPECIFIED`                  |             |
| `PROCESS`                      |             |
| `SUBPROCESS`                   |             |
| `EVENTSUBPROCESS`              |             |
| `ADHOCSUBPROCESS`              |             |
| `ADHOCSUBPROCESSINNERINSTANCE` |             |
| `STARTEVENT`                   |             |
| `INTERMEDIATECATCHEVENT`       |             |
| `INTERMEDIATETHROWEVENT`       |             |
| `BOUNDARYEVENT`                |             |
| `ENDEVENT`                     |             |
| `SERVICETASK`                  |             |
| `RECEIVETASK`                  |             |
| `USERTASK`                     |             |
| `MANUALTASK`                   |             |
| `TASK`                         |             |
| `EXCLUSIVEGATEWAY`             |             |
| `INCLUSIVEGATEWAY`             |             |
| `PARALLELGATEWAY`              |             |
| `EVENTBASEDGATEWAY`            |             |
| `SEQUENCEFLOW`                 |             |
| `MULTIINSTANCEBODY`            |             |
| `CALLACTIVITY`                 |             |
| `BUSINESSRULETASK`             |             |
| `SCRIPTTASK`                   |             |
| `SENDTASK`                     |             |
| `UNKNOWN`                      |             |

## ElementInstanceFilterType

Type of element as defined set of values.

| Value                          | Description |
| ------------------------------ | ----------- |
| `UNSPECIFIED`                  |             |
| `PROCESS`                      |             |
| `SUBPROCESS`                   |             |
| `EVENTSUBPROCESS`              |             |
| `ADHOCSUBPROCESS`              |             |
| `ADHOCSUBPROCESSINNERINSTANCE` |             |
| `STARTEVENT`                   |             |
| `INTERMEDIATECATCHEVENT`       |             |
| `INTERMEDIATETHROWEVENT`       |             |
| `BOUNDARYEVENT`                |             |
| `ENDEVENT`                     |             |
| `SERVICETASK`                  |             |
| `RECEIVETASK`                  |             |
| `USERTASK`                     |             |
| `MANUALTASK`                   |             |
| `TASK`                         |             |
| `EXCLUSIVEGATEWAY`             |             |
| `INCLUSIVEGATEWAY`             |             |
| `PARALLELGATEWAY`              |             |
| `EVENTBASEDGATEWAY`            |             |
| `SEQUENCEFLOW`                 |             |
| `MULTIINSTANCEBODY`            |             |
| `CALLACTIVITY`                 |             |
| `BUSINESSRULETASK`             |             |
| `SCRIPTTASK`                   |             |
| `SENDTASK`                     |             |
| `UNKNOWN`                      |             |

## ElementInstanceResultType

Type of element as defined set of values.

| Value                          | Description |
| ------------------------------ | ----------- |
| `UNSPECIFIED`                  |             |
| `PROCESS`                      |             |
| `SUBPROCESS`                   |             |
| `EVENTSUBPROCESS`              |             |
| `ADHOCSUBPROCESS`              |             |
| `ADHOCSUBPROCESSINNERINSTANCE` |             |
| `STARTEVENT`                   |             |
| `INTERMEDIATECATCHEVENT`       |             |
| `INTERMEDIATETHROWEVENT`       |             |
| `BOUNDARYEVENT`                |             |
| `ENDEVENT`                     |             |
| `SERVICETASK`                  |             |
| `RECEIVETASK`                  |             |
| `USERTASK`                     |             |
| `MANUALTASK`                   |             |
| `TASK`                         |             |
| `EXCLUSIVEGATEWAY`             |             |
| `INCLUSIVEGATEWAY`             |             |
| `PARALLELGATEWAY`              |             |
| `EVENTBASEDGATEWAY`            |             |
| `SEQUENCEFLOW`                 |             |
| `MULTIINSTANCEBODY`            |             |
| `CALLACTIVITY`                 |             |
| `BUSINESSRULETASK`             |             |
| `SCRIPTTASK`                   |             |
| `SENDTASK`                     |             |
| `UNKNOWN`                      |             |

## ElementInstanceSearchQuerySortRequestField

The field to sort by.

| Value                  | Description |
| ---------------------- | ----------- |
| `ElementInstanceKey`   |             |
| `ProcessInstanceKey`   |             |
| `ProcessDefinitionKey` |             |
| `ProcessDefinitionId`  |             |
| `StartDate`            |             |
| `EndDate`              |             |
| `ElementId`            |             |
| `ElementName`          |             |
| `Type`                 |             |
| `State`                |             |
| `IncidentKey`          |             |
| `TenantId`             |             |

## ElementInstanceStateEnum

Element states

| Value        | Description |
| ------------ | ----------- |
| `ACTIVE`     |             |
| `COMPLETED`  |             |
| `TERMINATED` |             |

## ElementInstanceWaitStateQuerySortRequestField

The field to sort by.

| Value                    | Description |
| ------------------------ | ----------- |
| `ElementInstanceKey`     |             |
| `ProcessInstanceKey`     |             |
| `RootProcessInstanceKey` |             |
| `ElementId`              |             |

## GlobalListenerSourceEnum

How the global listener was defined.

| Value           | Description |
| --------------- | ----------- |
| `CONFIGURATION` |             |
| `API`           |             |

## GlobalTaskListenerEventTypeEnum

The event type that triggers the user task listener.

| Value        | Description |
| ------------ | ----------- |
| `All`        |             |
| `Creating`   |             |
| `Assigning`  |             |
| `Updating`   |             |
| `Completing` |             |
| `Canceling`  |             |

## GlobalTaskListenerSearchQuerySortRequestField

The field to sort by.

| Value            | Description |
| ---------------- | ----------- |
| `Id`             |             |
| `Type`           |             |
| `AfterNonGlobal` |             |
| `Priority`       |             |
| `Source`         |             |

## GroupClientSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `ClientId` |             |

## GroupSearchQuerySortRequestField

The field to sort by.

| Value     | Description |
| --------- | ----------- |
| `Name`    |             |
| `GroupId` |             |

## GroupUserSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `Username` |             |

## IncidentErrorTypeEnum

Incident error type with a defined set of values.

| Value                        | Description |
| ---------------------------- | ----------- |
| `ADHOCSUBPROCESSNORETRIES`   |             |
| `CALLEDDECISIONERROR`        |             |
| `CALLEDELEMENTERROR`         |             |
| `CONDITIONERROR`             |             |
| `DECISIONEVALUATIONERROR`    |             |
| `EXECUTIONLISTENERNORETRIES` |             |
| `EXTRACTVALUEERROR`          |             |
| `FORMNOTFOUND`               |             |
| `IOMAPPINGERROR`             |             |
| `JOBNORETRIES`               |             |
| `MESSAGESIZEEXCEEDED`        |             |
| `RESOURCENOTFOUND`           |             |
| `TASKLISTENERNORETRIES`      |             |
| `UNHANDLEDERROREVENT`        |             |
| `UNKNOWN`                    |             |
| `UNSPECIFIED`                |             |

## IncidentProcessInstanceStatisticsByDefinitionQuerySortRequestField

The aggregated field by which the process instance statistics are sorted.

| Value                           | Description |
| ------------------------------- | ----------- |
| `ActiveInstancesWithErrorCount` |             |
| `ProcessDefinitionKey`          |             |
| `TenantId`                      |             |

## IncidentProcessInstanceStatisticsByErrorQuerySortRequestField

The field to sort the incident error statistics by.

| Value                           | Description |
| ------------------------------- | ----------- |
| `ErrorMessage`                  |             |
| `ActiveInstancesWithErrorCount` |             |

## IncidentSearchQuerySortRequestField

The field to sort by.

| Value                  | Description |
| ---------------------- | ----------- |
| `IncidentKey`          |             |
| `ProcessDefinitionKey` |             |
| `ProcessDefinitionId`  |             |
| `ProcessInstanceKey`   |             |
| `ErrorType`            |             |
| `ElementId`            |             |
| `ElementInstanceKey`   |             |
| `CreationTime`         |             |
| `State`                |             |
| `JobKey`               |             |
| `TenantId`             |             |

## IncidentStateEnum

Incident states with a defined set of values.

| Value      | Description |
| ---------- | ----------- |
| `ACTIVE`   |             |
| `MIGRATED` |             |
| `PENDING`  |             |
| `RESOLVED` |             |
| `UNKNOWN`  |             |

## JobKindEnum

The job kind.

| Value               | Description |
| ------------------- | ----------- |
| `BPMNELEMENT`       |             |
| `EXECUTIONLISTENER` |             |
| `TASKLISTENER`      |             |
| `ADHOCSUBPROCESS`   |             |

## JobListenerEventTypeEnum

The listener event type of the job.

| Value         | Description |
| ------------- | ----------- |
| `ASSIGNING`   |             |
| `BEFOREALL`   |             |
| `CANCEL`      |             |
| `CANCELING`   |             |
| `COMPLETING`  |             |
| `CREATING`    |             |
| `END`         |             |
| `START`       |             |
| `UNSPECIFIED` |             |
| `UPDATING`    |             |

## JobSearchQuerySortRequestField

The field to sort by.

| Value                      | Description |
| -------------------------- | ----------- |
| `Deadline`                 |             |
| `DeniedReason`             |             |
| `ElementId`                |             |
| `ElementInstanceKey`       |             |
| `EndTime`                  |             |
| `ErrorCode`                |             |
| `ErrorMessage`             |             |
| `HasFailedWithRetriesLeft` |             |
| `IsDenied`                 |             |
| `JobKey`                   |             |
| `Kind`                     |             |
| `ListenerEventType`        |             |
| `Priority`                 |             |
| `ProcessDefinitionId`      |             |
| `ProcessDefinitionKey`     |             |
| `ProcessInstanceKey`       |             |
| `Retries`                  |             |
| `State`                    |             |
| `TenantId`                 |             |
| `Type`                     |             |
| `Worker`                   |             |

## JobStateEnum

The state of the job.

| Value             | Description |
| ----------------- | ----------- |
| `CANCELED`        |             |
| `COMPLETED`       |             |
| `CREATED`         |             |
| `ERRORTHROWN`     |             |
| `FAILED`          |             |
| `MIGRATED`        |             |
| `PRIORITYUPDATED` |             |
| `RETRIESUPDATED`  |             |
| `TIMEOUTUPDATED`  |             |
| `TIMEDOUT`        |             |

## MappingRuleSearchQuerySortRequestField

The field to sort by.

| Value           | Description |
| --------------- | ----------- |
| `MappingRuleId` |             |
| `ClaimName`     |             |
| `ClaimValue`    |             |
| `Name`          |             |

## MessageSubscriptionSearchQuerySortRequestField

The field to sort by.

| Value                      | Description |
| -------------------------- | ----------- |
| `MessageSubscriptionKey`   |             |
| `ProcessDefinitionId`      |             |
| `ProcessDefinitionName`    |             |
| `ProcessDefinitionVersion` |             |
| `ProcessInstanceKey`       |             |
| `ElementId`                |             |
| `ElementInstanceKey`       |             |
| `MessageSubscriptionState` |             |
| `MessageSubscriptionType`  |             |
| `LastUpdatedDate`          |             |
| `MessageName`              |             |
| `CorrelationKey`           |             |
| `TenantId`                 |             |
| `ToolName`                 |             |
| `InboundConnectorType`     |             |

## MessageSubscriptionStateEnum

The state of message subscription.

**Note for `START_EVENT` subscriptions:** The `CORRELATED` and `MIGRATED` states are not tracked for these subscriptions. To query correlation history for process start events, use the `/correlated-message-subscriptions/search` endpoint.

| Value        | Description |
| ------------ | ----------- |
| `CORRELATED` |             |
| `CREATED`    |             |
| `DELETED`    |             |
| `MIGRATED`   |             |

## MessageSubscriptionTypeEnum

The type of message subscription.

`START_EVENT` is definition-scoped (process start events). Always has a value; only captured from Camunda 8.10 onwards. `PROCESS_EVENT` is instance-scoped (intermediate catch events). Pre-8.10 entries have no value stored; the API returns `PROCESS_EVENT` as a default for those entries.

| Value          | Description |
| -------------- | ----------- |
| `STARTEVENT`   |             |
| `PROCESSEVENT` |             |

## OwnerTypeEnum

The type of the owner of permissions.

| Value         | Description |
| ------------- | ----------- |
| `USER`        |             |
| `CLIENT`      |             |
| `ROLE`        |             |
| `GROUP`       |             |
| `MAPPINGRULE` |             |
| `UNSPECIFIED` |             |

## PartitionHealth

Describes the current health of the partition.

| Value       | Description |
| ----------- | ----------- |
| `Healthy`   |             |
| `Unhealthy` |             |
| `Dead`      |             |

## PartitionRole

Describes the Raft role of the broker for a given partition.

| Value      | Description |
| ---------- | ----------- |
| `Leader`   |             |
| `Follower` |             |
| `Inactive` |             |

## PartitionState

Describes the current operational state of the partition within the cluster configuration.

| Value        | Description |
| ------------ | ----------- |
| `Unknown`    |             |
| `Joining`    |             |
| `Active`     |             |
| `Leaving`    |             |
| `Recovering` |             |

## PermissionTypeEnum

Specifies the type of permissions.

| Value                                          | Description |
| ---------------------------------------------- | ----------- |
| `ACCESS`                                       |             |
| `CANCELPROCESSINSTANCE`                        |             |
| `CLAIM`                                        |             |
| `CLAIMUSERTASK`                                |             |
| `COMPLETE`                                     |             |
| `COMPLETEUSERTASK`                             |             |
| `CREATE`                                       |             |
| `CREATEBATCHOPERATIONCANCELPROCESSINSTANCE`    |             |
| `CREATEBATCHOPERATIONDELETEDECISIONDEFINITION` |             |
| `CREATEBATCHOPERATIONDELETEDECISIONINSTANCE`   |             |
| `CREATEBATCHOPERATIONDELETEPROCESSDEFINITION`  |             |
| `CREATEBATCHOPERATIONDELETEPROCESSINSTANCE`    |             |
| `CREATEBATCHOPERATIONMIGRATEPROCESSINSTANCE`   |             |
| `CREATEBATCHOPERATIONMODIFYPROCESSINSTANCE`    |             |
| `CREATEBATCHOPERATIONRESOLVEINCIDENT`          |             |
| `CREATEBATCHOPERATIONSUSPENDPROCESSINSTANCE`   |             |
| `CREATEBATCHOPERATIONUPDATEJOB`                |             |
| `CREATEDECISIONINSTANCE`                       |             |
| `CREATEPROCESSINSTANCE`                        |             |
| `CREATETASKLISTENER`                           |             |
| `DELETE`                                       |             |
| `DELETEDECISIONINSTANCE`                       |             |
| `DELETEDRD`                                    |             |
| `DELETEFORM`                                   |             |
| `DELETEPROCESS`                                |             |
| `DELETEPROCESSINSTANCE`                        |             |
| `DELETERESOURCE`                               |             |
| `DELETETASKLISTENER`                           |             |
| `EVALUATE`                                     |             |
| `MODIFYPROCESSINSTANCE`                        |             |
| `PAUSE`                                        |             |
| `READ`                                         |             |
| `READDECISIONDEFINITION`                       |             |
| `READDECISIONINSTANCE`                         |             |
| `READJOBMETRIC`                                |             |
| `READPROCESSDEFINITION`                        |             |
| `READPROCESSINSTANCE`                          |             |
| `READUSAGEMETRIC`                              |             |
| `READUSERTASK`                                 |             |
| `READTASKLISTENER`                             |             |
| `RESTORE`                                      |             |
| `REVEAL`                                       |             |
| `SUSPENDPROCESSINSTANCE`                       |             |
| `UPDATE`                                       |             |
| `UPDATEPROCESSINSTANCE`                        |             |
| `UPDATEUSERTASK`                               |             |
| `UPDATETASKLISTENER`                           |             |

## ProcessDefinitionInstanceStatisticsQuerySortRequestField

The field to sort by.

| Value                                 | Description |
| ------------------------------------- | ----------- |
| `ProcessDefinitionId`                 |             |
| `ActiveInstancesWithIncidentCount`    |             |
| `ActiveInstancesWithoutIncidentCount` |             |

## ProcessDefinitionInstanceVersionStatisticsQuerySortRequestField

The field to sort by.

| Value                                 | Description |
| ------------------------------------- | ----------- |
| `ProcessDefinitionId`                 |             |
| `ProcessDefinitionKey`                |             |
| `ProcessDefinitionName`               |             |
| `ProcessDefinitionVersion`            |             |
| `ActiveInstancesWithIncidentCount`    |             |
| `ActiveInstancesWithoutIncidentCount` |             |

## ProcessDefinitionSearchQuerySortRequestField

The field to sort by.

| Value                  | Description |
| ---------------------- | ----------- |
| `ProcessDefinitionKey` |             |
| `Name`                 |             |
| `ResourceName`         |             |
| `Version`              |             |
| `VersionTag`           |             |
| `ProcessDefinitionId`  |             |
| `TenantId`             |             |

## ProcessInstanceSearchQuerySortRequestField

The field to sort by.

| Value                         | Description |
| ----------------------------- | ----------- |
| `ProcessInstanceKey`          |             |
| `ProcessDefinitionId`         |             |
| `ProcessDefinitionName`       |             |
| `ProcessDefinitionVersion`    |             |
| `ProcessDefinitionVersionTag` |             |
| `ProcessDefinitionKey`        |             |
| `ParentProcessInstanceKey`    |             |
| `ParentElementInstanceKey`    |             |
| `StartDate`                   |             |
| `EndDate`                     |             |
| `State`                       |             |
| `HasIncident`                 |             |
| `TenantId`                    |             |
| `BusinessId`                  |             |

## ProcessInstanceStateEnum

Process instance states

| Value        | Description |
| ------------ | ----------- |
| `ACTIVE`     |             |
| `COMPLETED`  |             |
| `TERMINATED` |             |

## ResourceSearchQuerySortRequestField

The field to sort by.

| Value           | Description |
| --------------- | ----------- |
| `ResourceKey`   |             |
| `ResourceName`  |             |
| `ResourceId`    |             |
| `Version`       |             |
| `VersionTag`    |             |
| `DeploymentKey` |             |
| `TenantId`      |             |

## ResourceTypeEnum

The type of resource to add/remove permissions to/from.

| Value                            | Description |
| -------------------------------- | ----------- |
| `AUDITLOG`                       |             |
| `AUTHORIZATION`                  |             |
| `BACKUP`                         |             |
| `BATCH`                          |             |
| `CLUSTERVARIABLE`                |             |
| `COMPONENT`                      |             |
| `DECISIONDEFINITION`             |             |
| `DECISIONREQUIREMENTSDEFINITION` |             |
| `DOCUMENT`                       |             |
| `EXPORTER`                       |             |
| `EXPRESSION`                     |             |
| `GLOBALLISTENER`                 |             |
| `GROUP`                          |             |
| `MAPPINGRULE`                    |             |
| `MESSAGE`                        |             |
| `PROCESSDEFINITION`              |             |
| `RESOURCE`                       |             |
| `ROLE`                           |             |
| `SECRET`                         |             |
| `SYSTEM`                         |             |
| `TENANT`                         |             |
| `USER`                           |             |
| `USERTASK`                       |             |

## RoleClientSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `ClientId` |             |

## RoleGroupSearchQuerySortRequestField

The field to sort by.

| Value     | Description |
| --------- | ----------- |
| `GroupId` |             |

## RoleSearchQuerySortRequestField

The field to sort by.

| Value    | Description |
| -------- | ----------- |
| `Name`   |             |
| `RoleId` |             |

## RoleUserSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `Username` |             |

## SecretErrorCode

The typed reason a reference could not be resolved.

- `NOT_FOUND`: no secret exists for the reference.
- `ACCESS_DENIED`: the caller lacks `SECRET:REVEAL` on the reference.
- `INVALID_REFERENCE`: the reference is malformed.

| Value              | Description |
| ------------------ | ----------- |
| `NOTFOUND`         |             |
| `ACCESSDENIED`     |             |
| `INVALIDREFERENCE` |             |

## SortOrderEnum

The order in which to sort the related field.

| Value  | Description |
| ------ | ----------- |
| `ASC`  |             |
| `DESC` |             |

## TenantClientSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `ClientId` |             |

## TenantFilterEnum

The tenant filtering strategy for job activation. Determines whether to use tenant IDs provided in the request or tenant IDs assigned to the authenticated principal.

| Value      | Description |
| ---------- | ----------- |
| `PROVIDED` |             |
| `ASSIGNED` |             |

## TenantGroupSearchQuerySortRequestField

The field to sort by.

| Value     | Description |
| --------- | ----------- |
| `GroupId` |             |

## TenantSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `Key`      |             |
| `Name`     |             |
| `TenantId` |             |

## TenantUserSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `Username` |             |

## UserSearchQuerySortRequestField

The field to sort by.

| Value      | Description |
| ---------- | ----------- |
| `Username` |             |
| `Name`     |             |
| `Email`    |             |

## UserTaskSearchQuerySortRequestField

The field to sort by.

| Value            | Description |
| ---------------- | ----------- |
| `CreationDate`   |             |
| `CompletionDate` |             |
| `FollowUpDate`   |             |
| `DueDate`        |             |
| `Priority`       |             |
| `Name`           |             |
| `BusinessId`     |             |

## UserTaskStateEnum

The state of the user task.

Note: FAILED state is only for legacy job-worker-based tasks.

| Value        | Description |
| ------------ | ----------- |
| `CREATING`   |             |
| `CREATED`    |             |
| `ASSIGNING`  |             |
| `UPDATING`   |             |
| `COMPLETING` |             |
| `COMPLETED`  |             |
| `CANCELING`  |             |
| `CANCELED`   |             |
| `FAILED`     |             |

## UserTaskVariableSearchQuerySortRequestField

The field to sort by.

| Value                | Description |
| -------------------- | ----------- |
| `Value`              |             |
| `Name`               |             |
| `TenantId`           |             |
| `VariableKey`        |             |
| `ScopeKey`           |             |
| `ProcessInstanceKey` |             |

## VariableSearchQuerySortRequestField

The field to sort by.

| Value                | Description |
| -------------------- | ----------- |
| `Value`              |             |
| `Name`               |             |
| `TenantId`           |             |
| `VariableKey`        |             |
| `ScopeKey`           |             |
| `ProcessInstanceKey` |             |

## WaitStateElementTypeEnum

The BPMN element type of a waiting element instance.

| Value                          | Description |
| ------------------------------ | ----------- |
| `ADHOCSUBPROCESS`              |             |
| `ADHOCSUBPROCESSINNERINSTANCE` |             |
| `BOUNDARYEVENT`                |             |
| `BUSINESSRULETASK`             |             |
| `CALLACTIVITY`                 |             |
| `ENDEVENT`                     |             |
| `EVENTBASEDGATEWAY`            |             |
| `EVENTSUBPROCESS`              |             |
| `EXCLUSIVEGATEWAY`             |             |
| `INCLUSIVEGATEWAY`             |             |
| `INTERMEDIATECATCHEVENT`       |             |
| `INTERMEDIATETHROWEVENT`       |             |
| `MANUALTASK`                   |             |
| `MULTIINSTANCEBODY`            |             |
| `PARALLELGATEWAY`              |             |
| `PROCESS`                      |             |
| `RECEIVETASK`                  |             |
| `SCRIPTTASK`                   |             |
| `SENDTASK`                     |             |
| `SEQUENCEFLOW`                 |             |
| `SERVICETASK`                  |             |
| `STARTEVENT`                   |             |
| `SUBPROCESS`                   |             |
| `TASK`                         |             |
| `UNKNOWN`                      |             |
| `UNSPECIFIED`                  |             |
| `USERTASK`                     |             |

## WaitStateTypeEnum

The type of waiting state an element instance is in.

| Value       | Description |
| ----------- | ----------- |
| `JOB`       |             |
| `MESSAGE`   |             |
| `USERTASK`  |             |
| `TIMER`     |             |
| `SIGNAL`    |             |
| `CONDITION` |             |

## WebappComponent

A Camunda webapp component name.

| Value      | Description |
| ---------- | ----------- |
| `Operate`  |             |
| `Tasklist` |             |
| `Admin`    |             |

---

## C# SDK API Reference


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Auto-generated from the Camunda C# SDK source code.

## Sections

- [CamundaClient](camunda-client.md) — Main client class with all API methods (3 types)
- [Configuration](configuration.md) — SDK configuration, authentication, and options (16 types)
- [Runtime](runtime.md) — Runtime infrastructure: job workers, backpressure, polling, errors (0 types)
- [Models](models.md) — Request and response model classes (630 types)
- [Enums](enums.md) — Enumeration types (89 types)
- [Keys](keys.md) — Strongly-typed domain key types (27 types)

---

## Keys

# Key Types

:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Strongly-typed domain key types provide compile-time safety for entity identifiers. Each key wraps a string value and ensures type-safe API calls.

## Overview

| Key Type                        | Description                                                                                                                                                                                                                    |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `AgentHistoryItemKey`           | System-generated key for an agent history item.                                                                                                                                                                                |
| `AgentInstanceKey`              | System-generated key for an agent instance.                                                                                                                                                                                    |
| `AuditLogEntityKey`             | System-generated entity key for an audit log entry.                                                                                                                                                                            |
| `AuditLogKey`                   | System-generated key for an audit log entry.                                                                                                                                                                                   |
| `AuthorizationKey`              | System-generated key for an authorization.                                                                                                                                                                                     |
| `BatchOperationKey`             | System-generated key for an batch operation.                                                                                                                                                                                   |
| `ConditionalEvaluationKey`      | System-generated key for a conditional evaluation.                                                                                                                                                                             |
| `DecisionDefinitionKey`         | System-generated key for a decision definition.                                                                                                                                                                                |
| `DecisionEvaluationInstanceKey` | System-generated identifier for a decision evaluation instance. It is composed of the parent decision evaluation key and the 1-based index of the evaluated decision within that evaluation, joined by a hyphen (format: `-`). |
| `DecisionEvaluationKey`         | System-generated key for a decision evaluation.                                                                                                                                                                                |
| `DecisionInstanceKey`           | System-generated key for a deployed decision instance.                                                                                                                                                                         |
| `DecisionRequirementsKey`       | System-generated key for a deployed decision requirements definition.                                                                                                                                                          |
| `DeploymentKey`                 | Key for a deployment.                                                                                                                                                                                                          |
| `ElementInstanceKey`            | System-generated key for a element instance.                                                                                                                                                                                   |
| `FormKey`                       | System-generated key for a deployed form.                                                                                                                                                                                      |
| `IncidentKey`                   | System-generated key for a incident.                                                                                                                                                                                           |
| `JobKey`                        | System-generated key for a job.                                                                                                                                                                                                |
| `LongKey`                       | Zeebe Engine resource key (Java long serialized as string)                                                                                                                                                                     |
| `MessageKey`                    | System-generated key for an message.                                                                                                                                                                                           |
| `MessageSubscriptionKey`        | System-generated key for a message subscription.                                                                                                                                                                               |
| `ProcessDefinitionKey`          | System-generated key for a deployed process definition.                                                                                                                                                                        |
| `ProcessInstanceKey`            | System-generated key for a process instance.                                                                                                                                                                                   |
| `ResourceKey`                   | The system-assigned key for this resource.                                                                                                                                                                                     |
| `ScopeKey`                      | System-generated key for a scope. A scope can hold variables and represents either an element instance in a BPMN process or the process instance itself.                                                                       |
| `SignalKey`                     | System-generated key for an signal.                                                                                                                                                                                            |
| `UserTaskKey`                   | System-generated key for a user task.                                                                                                                                                                                          |
| `VariableKey`                   | System-generated key for a variable.                                                                                                                                                                                           |

## Common Methods

All key types share these methods:

| Method                 | Description                                      |
| ---------------------- | ------------------------------------------------ |
| `AssumeExists(string)` | Creates a key from a known-valid string value.   |
| `IsValid(string)`      | Validates whether a string is a valid key value. |
| `Value`                | Gets the underlying string value.                |
| `ToString()`           | Returns the string representation.               |

## Details

### AgentHistoryItemKey

System-generated key for an agent history item.

```csharp
public readonly record struct AgentHistoryItemKey : ICamundaKey, IEquatable<AgentHistoryItemKey>
```

### AgentInstanceKey

System-generated key for an agent instance.

```csharp
public readonly record struct AgentInstanceKey : ICamundaKey, IEquatable<AgentInstanceKey>
```

### AuditLogEntityKey

System-generated entity key for an audit log entry.

```csharp
public readonly record struct AuditLogEntityKey : ICamundaKey, IEquatable<AuditLogEntityKey>
```

### AuditLogKey

System-generated key for an audit log entry.

```csharp
public readonly record struct AuditLogKey : ICamundaKey, IEquatable<AuditLogKey>
```

### AuthorizationKey

System-generated key for an authorization.

```csharp
public readonly record struct AuthorizationKey : ICamundaKey, IEquatable<AuthorizationKey>
```

### BatchOperationKey

System-generated key for an batch operation.

```csharp
public readonly record struct BatchOperationKey : ICamundaKey, IEquatable<BatchOperationKey>
```

### ConditionalEvaluationKey

System-generated key for a conditional evaluation.

```csharp
public readonly record struct ConditionalEvaluationKey : ICamundaKey, IEquatable<ConditionalEvaluationKey>
```

### DecisionDefinitionKey

System-generated key for a decision definition.

```csharp
public readonly record struct DecisionDefinitionKey : ICamundaKey, IEquatable<DecisionDefinitionKey>
```

### DecisionEvaluationInstanceKey

System-generated identifier for a decision evaluation instance. It is composed of the parent decision evaluation key and the 1-based index of the evaluated decision within that evaluation, joined by a hyphen (format: `-`).

```csharp
public readonly record struct DecisionEvaluationInstanceKey : ICamundaKey, IEquatable<DecisionEvaluationInstanceKey>
```

### DecisionEvaluationKey

System-generated key for a decision evaluation.

```csharp
public readonly record struct DecisionEvaluationKey : ICamundaKey, IEquatable<DecisionEvaluationKey>
```

### DecisionInstanceKey

System-generated key for a deployed decision instance.

```csharp
public readonly record struct DecisionInstanceKey : ICamundaKey, IEquatable<DecisionInstanceKey>
```

### DecisionRequirementsKey

System-generated key for a deployed decision requirements definition.

```csharp
public readonly record struct DecisionRequirementsKey : ICamundaKey, IEquatable<DecisionRequirementsKey>
```

### DeploymentKey

Key for a deployment.

```csharp
public readonly record struct DeploymentKey : ICamundaKey, IEquatable<DeploymentKey>
```

### ElementInstanceKey

System-generated key for a element instance.

```csharp
public readonly record struct ElementInstanceKey : ICamundaKey, IEquatable<ElementInstanceKey>
```

### FormKey

System-generated key for a deployed form.

```csharp
public readonly record struct FormKey : ICamundaKey, IEquatable<FormKey>
```

### IncidentKey

System-generated key for a incident.

```csharp
public readonly record struct IncidentKey : ICamundaKey, IEquatable<IncidentKey>
```

### JobKey

System-generated key for a job.

```csharp
public readonly record struct JobKey : ICamundaKey, IEquatable<JobKey>
```

### LongKey

Zeebe Engine resource key (Java long serialized as string)

```csharp
public readonly record struct LongKey : ICamundaKey, IEquatable<LongKey>
```

### MessageKey

System-generated key for an message.

```csharp
public readonly record struct MessageKey : ICamundaKey, IEquatable<MessageKey>
```

### MessageSubscriptionKey

System-generated key for a message subscription.

```csharp
public readonly record struct MessageSubscriptionKey : ICamundaKey, IEquatable<MessageSubscriptionKey>
```

### ProcessDefinitionKey

System-generated key for a deployed process definition.

```csharp
public readonly record struct ProcessDefinitionKey : ICamundaKey, IEquatable<ProcessDefinitionKey>
```

### ProcessInstanceKey

System-generated key for a process instance.

```csharp
public readonly record struct ProcessInstanceKey : ICamundaKey, IEquatable<ProcessInstanceKey>
```

### ResourceKey

The system-assigned key for this resource.

```csharp
public readonly record struct ResourceKey : ICamundaKey, IEquatable<ResourceKey>
```

### ScopeKey

System-generated key for a scope. A scope can hold variables and represents either an element instance in a BPMN process or the process instance itself.

```csharp
public readonly record struct ScopeKey : ICamundaKey, IEquatable<ScopeKey>
```

### SignalKey

System-generated key for an signal.

```csharp
public readonly record struct SignalKey : ICamundaKey, IEquatable<SignalKey>
```

### UserTaskKey

System-generated key for a user task.

```csharp
public readonly record struct UserTaskKey : ICamundaKey, IEquatable<UserTaskKey>
```

### VariableKey

System-generated key for a variable.

```csharp
public readonly record struct VariableKey : ICamundaKey, IEquatable<VariableKey>
```

---

## Models


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Request and response model classes (630 types).

## Quick Reference

- [ActivatedJob](#activatedjob) — An activated job received from the Camunda broker, with typed variable access
- [ActivatedJobResult](#activatedjobresult) — ActivatedJobResult
- [AdHocSubProcessActivateActivitiesInstruction](#adhocsubprocessactivateactivitiesinstruction) — AdHocSubProcessActivateActivitiesInstruction
- [AdHocSubProcessActivateActivityReference](#adhocsubprocessactivateactivityreference) — AdHocSubProcessActivateActivityReference
- [AdvancedActorTypeFilter](#advancedactortypefilter) — Advanced AuditLogActorTypeEnum filter
- [AdvancedAgentHistoryItemKeyFilter](#advancedagenthistoryitemkeyfilter) — Advanced AgentHistoryItemKey filter
- [AdvancedAgentInstanceHistoryCommitStatusFilter](#advancedagentinstancehistorycommitstatusfilter) — Advanced AgentInstanceHistoryCommitStatusEnum filter
- [AdvancedAgentInstanceHistoryRoleFilter](#advancedagentinstancehistoryrolefilter) — Advanced AgentInstanceHistoryRoleEnum filter
- [AdvancedAgentInstanceKeyFilter](#advancedagentinstancekeyfilter) — Advanced AgentInstanceKey filter
- [AdvancedAgentInstanceStatusFilter](#advancedagentinstancestatusfilter) — Advanced AgentInstanceStatusEnum filter
- [AdvancedAuditLogEntityKeyFilter](#advancedauditlogentitykeyfilter) — Advanced entityKey filter
- [AdvancedAuditLogKeyFilter](#advancedauditlogkeyfilter) — Advanced AuditLogKey filter
- [AdvancedBatchOperationItemStateFilter](#advancedbatchoperationitemstatefilter) — Advanced BatchOperationItemStateEnum filter
- [AdvancedBatchOperationStateFilter](#advancedbatchoperationstatefilter) — Advanced BatchOperationStateEnum filter
- [AdvancedBatchOperationTypeFilter](#advancedbatchoperationtypefilter) — Advanced BatchOperationTypeEnum filter
- [AdvancedCategoryFilter](#advancedcategoryfilter) — Advanced AuditLogCategoryEnum filter
- [AdvancedClusterVariableKindFilter](#advancedclustervariablekindfilter) — Advanced ClusterVariableKindEnum filter
- [AdvancedClusterVariableScopeFilter](#advancedclustervariablescopefilter) — Advanced ClusterVariableScopeEnum filter
- [AdvancedDateTimeFilter](#advanceddatetimefilter) — Advanced date-time filter
- [AdvancedDecisionDefinitionKeyFilter](#advanceddecisiondefinitionkeyfilter) — Advanced DecisionDefinitionKey filter
- [AdvancedDecisionEvaluationInstanceKeyFilter](#advanceddecisionevaluationinstancekeyfilter) — Advanced DecisionEvaluationInstanceKey filter
- [AdvancedDecisionEvaluationKeyFilter](#advanceddecisionevaluationkeyfilter) — Advanced DecisionEvaluationKey filter
- [AdvancedDecisionInstanceStateFilter](#advanceddecisioninstancestatefilter) — Advanced DecisionInstanceStateEnum filter
- [AdvancedDecisionRequirementsKeyFilter](#advanceddecisionrequirementskeyfilter) — Advanced DecisionRequirementsKey filter
- [AdvancedDeploymentKeyFilter](#advanceddeploymentkeyfilter) — Advanced DeploymentKey filter
- [AdvancedElementIdFilter](#advancedelementidfilter) — Advanced ElementId filter
- [AdvancedElementInstanceKeyFilter](#advancedelementinstancekeyfilter) — Advanced ElementInstanceKey filter
- [AdvancedElementInstanceStateFilter](#advancedelementinstancestatefilter) — Advanced ElementInstanceStateEnum filter
- [AdvancedEntityTypeFilter](#advancedentitytypefilter) — Advanced AuditLogEntityTypeEnum filter
- [AdvancedFormKeyFilter](#advancedformkeyfilter) — Advanced FormKey filter
- [AdvancedGlobalListenerSourceFilter](#advancedgloballistenersourcefilter) — Advanced global listener source filter
- [AdvancedGlobalTaskListenerEventTypeFilter](#advancedglobaltasklistenereventtypefilter) — Advanced global listener event type filter
- [AdvancedIncidentErrorTypeFilter](#advancedincidenterrortypefilter) — Advanced IncidentErrorTypeEnum filter
- [AdvancedIncidentStateFilter](#advancedincidentstatefilter) — Advanced IncidentStateEnum filter
- [AdvancedIntegerFilter](#advancedintegerfilter) — Advanced integer (int32) filter
- [AdvancedJobKeyFilter](#advancedjobkeyfilter) — Advanced JobKey filter
- [AdvancedJobKindFilter](#advancedjobkindfilter) — Advanced JobKindEnum filter
- [AdvancedJobListenerEventTypeFilter](#advancedjoblistenereventtypefilter) — Advanced JobListenerEventTypeEnum filter
- [AdvancedJobStateFilter](#advancedjobstatefilter) — Advanced JobStateEnum filter
- [AdvancedMessageSubscriptionKeyFilter](#advancedmessagesubscriptionkeyfilter) — Advanced MessageSubscriptionKey filter
- [AdvancedMessageSubscriptionStateFilter](#advancedmessagesubscriptionstatefilter) — Advanced MessageSubscriptionStateEnum filter
- [AdvancedMessageSubscriptionTypeFilter](#advancedmessagesubscriptiontypefilter) — Advanced MessageSubscriptionTypeEnum filter
- [AdvancedMetadataValueFilter](#advancedmetadatavaluefilter) — Advanced filter on a metadata value (string or number)
- [AdvancedOperationTypeFilter](#advancedoperationtypefilter) — Advanced AuditLogOperationTypeEnum filter
- [AdvancedProcessDefinitionIdFilter](#advancedprocessdefinitionidfilter) — Advanced ProcessDefinitionId filter
- [AdvancedProcessDefinitionKeyFilter](#advancedprocessdefinitionkeyfilter) — Advanced ProcessDefinitionKey filter
- [AdvancedProcessInstanceKeyFilter](#advancedprocessinstancekeyfilter) — Advanced ProcessInstanceKey filter
- [AdvancedProcessInstanceStateFilter](#advancedprocessinstancestatefilter) — Advanced ProcessInstanceStateEnum filter
- [AdvancedResourceKeyFilter](#advancedresourcekeyfilter) — Advanced ResourceKey filter
- [AdvancedResultFilter](#advancedresultfilter) — Advanced AuditLogResultEnum filter
- [AdvancedScopeKeyFilter](#advancedscopekeyfilter) — Advanced ScopeKey filter
- [AdvancedStringFilter](#advancedstringfilter) — Advanced string filter
- [AdvancedUserTaskStateFilter](#advancedusertaskstatefilter) — Advanced UserTaskStateEnum filter
- [AdvancedVariableKeyFilter](#advancedvariablekeyfilter) — Advanced VariableKey filter
- [AdvancedWaitStateElementTypeFilter](#advancedwaitstateelementtypefilter) — Advanced element type filter
- [AdvancedWaitStateTypeFilter](#advancedwaitstatetypefilter) — Advanced wait state type filter
- [AgentHistoryItemKeyExactMatch](#agenthistoryitemkeyexactmatch) — Matches the value exactly
- [AgentHistoryItemKeyFilterProperty](#agenthistoryitemkeyfilterproperty) — AgentHistoryItemKey property with full advanced search capabilities
- [AgentInstanceCreationRequest](#agentinstancecreationrequest) — Request to create a new agent instance
- [AgentInstanceCreationResult](#agentinstancecreationresult) — Response returned after successfully creating an agent instance
- [AgentInstanceDefinition](#agentinstancedefinition) — The static definition of an agent instance, set once at creation
- [AgentInstanceDocumentContent](#agentinstancedocumentcontent) — A Camunda Document Store reference content block
- [AgentInstanceFilter](#agentinstancefilter) — Agent instance search filter
- [AgentInstanceHistoryCommitStatusExactMatch](#agentinstancehistorycommitstatusexactmatch) — Matches the value exactly
- [AgentInstanceHistoryCommitStatusFilterProperty](#agentinstancehistorycommitstatusfilterproperty) — AgentInstanceHistoryCommitStatusEnum property with full advanced search capabilities
- [AgentInstanceHistoryFilter](#agentinstancehistoryfilter) — Agent instance history item search filter
- [AgentInstanceHistoryItemCreationResult](#agentinstancehistoryitemcreationresult) — Response returned after successfully appending a history item
- [AgentInstanceHistoryItemMetrics](#agentinstancehistoryitemmetrics) — Per-call token and latency metrics for an ASSISTANT history item
- [AgentInstanceHistoryItemRequest](#agentinstancehistoryitemrequest) — Request to append a single history item to an agent instance's conversation history
- [AgentInstanceHistoryItemResult](#agentinstancehistoryitemresult) — A single conversation history item belonging to an agent instance
- [AgentInstanceHistoryRoleExactMatch](#agentinstancehistoryroleexactmatch) — Matches the value exactly
- [AgentInstanceHistoryRoleFilterProperty](#agentinstancehistoryrolefilterproperty) — AgentInstanceHistoryRoleEnum property with full advanced search capabilities
- [AgentInstanceHistorySearchQuery](#agentinstancehistorysearchquery) — Agent instance history search request
- [AgentInstanceHistorySearchQueryResult](#agentinstancehistorysearchqueryresult) — Agent instance history search response
- [AgentInstanceHistorySearchQuerySortRequest](#agentinstancehistorysearchquerysortrequest) — AgentInstanceHistorySearchQuerySortRequest
- [AgentInstanceKeyExactMatch](#agentinstancekeyexactmatch) — Matches the value exactly
- [AgentInstanceKeyFilterProperty](#agentinstancekeyfilterproperty) — AgentInstanceKey property with full advanced search capabilities
- [AgentInstanceLimits](#agentinstancelimits) — The configured limits for an agent instance, set once at creation
- [AgentInstanceMessageContent](#agentinstancemessagecontent) — A single content block within a history item
- [AgentInstanceMetrics](#agentinstancemetrics) — Aggregated metrics for an agent instance across all model calls
- [AgentInstanceMetricsDelta](#agentinstancemetricsdelta) — Metric increments to apply to the agent instance aggregate counters
- [AgentInstanceObjectContent](#agentinstanceobjectcontent) — An arbitrary structured content block
- [AgentInstanceResult](#agentinstanceresult) — AgentInstanceResult
- [AgentInstanceSearchQuery](#agentinstancesearchquery) — Agent instance search request
- [AgentInstanceSearchQueryResult](#agentinstancesearchqueryresult) — Agent instance search response
- [AgentInstanceSearchQuerySortRequest](#agentinstancesearchquerysortrequest) — AgentInstanceSearchQuerySortRequest
- [AgentInstanceStatusExactMatch](#agentinstancestatusexactmatch) — Matches the value exactly
- [AgentInstanceStatusFilterProperty](#agentinstancestatusfilterproperty) — AgentInstanceStatusEnum property with full advanced search capabilities
- [AgentInstanceTextContent](#agentinstancetextcontent) — A plain-text content block
- [AgentInstanceToolCall](#agentinstancetoolcall) — A tool call associated with a history item
- [AgentInstanceUpdateRequest](#agentinstanceupdaterequest) — Request to update the mutable state of an agent instance
- [AgentTool](#agenttool) — A tool available to the agent
- [AncestorScopeInstruction](#ancestorscopeinstruction) — Defines the ancestor scope for the created element instances
- [AuditLogActorTypeExactMatch](#auditlogactortypeexactmatch) — Matches the value exactly
- [AuditLogActorTypeFilterProperty](#auditlogactortypefilterproperty) — AuditLogActorTypeEnum property with full advanced search capabilities
- [AuditLogEntityKeyExactMatch](#auditlogentitykeyexactmatch) — Matches the value exactly
- [AuditLogEntityKeyFilterProperty](#auditlogentitykeyfilterproperty) — EntityKey property with full advanced search capabilities
- [AuditLogFilter](#auditlogfilter) — Audit log filter request
- [AuditLogKeyExactMatch](#auditlogkeyexactmatch) — Matches the value exactly
- [AuditLogKeyFilterProperty](#auditlogkeyfilterproperty) — AuditLogKey property with full advanced search capabilities
- [AuditLogResult](#auditlogresult) — Audit log item
- [AuditLogResultExactMatch](#auditlogresultexactmatch) — Matches the value exactly
- [AuditLogResultFilterProperty](#auditlogresultfilterproperty) — AuditLogResultEnum property with full advanced search capabilities
- [AuditLogSearchQueryRequest](#auditlogsearchqueryrequest) — Audit log search request
- [AuditLogSearchQueryResult](#auditlogsearchqueryresult) — Audit log search response
- [AuditLogSearchQuerySortRequest](#auditlogsearchquerysortrequest) — AuditLogSearchQuerySortRequest
- [AuthenticationConfigurationResponse](#authenticationconfigurationresponse) — Configuration for authentication and session management
- [AuthorizationCreateResult](#authorizationcreateresult) — AuthorizationCreateResult
- [AuthorizationFilter](#authorizationfilter) — Authorization search filter
- [AuthorizationIdBasedRequest](#authorizationidbasedrequest) — AuthorizationIdBasedRequest
- [AuthorizationPropertyBasedRequest](#authorizationpropertybasedrequest) — AuthorizationPropertyBasedRequest
- [AuthorizationRequest](#authorizationrequest) — Defines an authorization request
- [AuthorizationResult](#authorizationresult) — AuthorizationResult
- [AuthorizationSearchQuery](#authorizationsearchquery) — AuthorizationSearchQuery
- [AuthorizationSearchQuerySortRequest](#authorizationsearchquerysortrequest) — AuthorizationSearchQuerySortRequest
- [AuthorizationSearchResult](#authorizationsearchresult) — AuthorizationSearchResult
- [BackpressureState](#backpressurestate)
- [BaseProcessInstanceFilterFields](#baseprocessinstancefilterfields) — Base process instance search filter
- [BasicStringFilter](#basicstringfilter) — Basic advanced string filter
- [BasicStringFilterProperty](#basicstringfilterproperty) — String property with basic advanced search capabilities
- [BatchOperationCreatedResult](#batchoperationcreatedresult) — The created batch operation
- [BatchOperationError](#batchoperationerror) — BatchOperationError
- [BatchOperationFilter](#batchoperationfilter) — Batch operation filter request
- [BatchOperationItemFilter](#batchoperationitemfilter) — Batch operation item filter request
- [BatchOperationItemResponse](#batchoperationitemresponse) — BatchOperationItemResponse
- [BatchOperationItemSearchQuery](#batchoperationitemsearchquery) — Batch operation item search request
- [BatchOperationItemSearchQueryResult](#batchoperationitemsearchqueryresult) — BatchOperationItemSearchQueryResult
- [BatchOperationItemSearchQuerySortRequest](#batchoperationitemsearchquerysortrequest) — BatchOperationItemSearchQuerySortRequest
- [BatchOperationItemStateExactMatch](#batchoperationitemstateexactmatch) — Matches the value exactly
- [BatchOperationItemStateFilterProperty](#batchoperationitemstatefilterproperty) — BatchOperationItemStateEnum property with full advanced search capabilities
- [BatchOperationResponse](#batchoperationresponse) — BatchOperationResponse
- [BatchOperationSearchQuery](#batchoperationsearchquery) — Batch operation search request
- [BatchOperationSearchQueryResult](#batchoperationsearchqueryresult) — The batch operation search query result
- [BatchOperationSearchQuerySortRequest](#batchoperationsearchquerysortrequest) — BatchOperationSearchQuerySortRequest
- [BatchOperationStateExactMatch](#batchoperationstateexactmatch) — Matches the value exactly
- [BatchOperationStateFilterProperty](#batchoperationstatefilterproperty) — BatchOperationStateEnum property with full advanced search capabilities
- [BatchOperationTypeExactMatch](#batchoperationtypeexactmatch) — Matches the value exactly
- [BatchOperationTypeFilterProperty](#batchoperationtypefilterproperty) — BatchOperationTypeEnum property with full advanced search capabilities
- [BpmnErrorException](#bpmnerrorexception) — Throw from a job handler to trigger a BPMN error boundary event on the job's task
- [BrokerInfo](#brokerinfo) — Provides information on a broker node
- [BusinessId](#businessid) — An optional, user-defined string identifier that identifies the process instance within the scope of a process definition (scoped by tenant)
- [CamundaAuthException](#camundaauthexception) — Authentication-specific exception
- [CamundaConfigurationException](#camundaconfigurationexception) — Thrown when configuration hydration encounters validation errors
- [CamundaKeyJsonConverterFactory](#camundakeyjsonconverterfactory) — JSON converter factory that handles any `ICamundaKey` struct
- [CamundaKeyValidation](#camundakeyvalidation) — Validation helpers for domain key constraints
- [CamundaLongKeyJsonConverterFactory](#camundalongkeyjsonconverterfactory) — JSON converter factory that handles any `ICamundaLongKey` struct
- [CamundaSdkException](#camundasdkexception) — SDK error types mirroring the JS SDK's error structure
- [CamundaUserResult](#camundauserresult) — CamundaUserResult
- [CancelProcessInstanceRequest](#cancelprocessinstancerequest) — CancelProcessInstanceRequest
- [CancelSdkException](#cancelsdkexception) — Thrown when a cancellable operation is cancelled
- [CategoryExactMatch](#categoryexactmatch) — Matches the value exactly
- [CategoryFilterProperty](#categoryfilterproperty) — AuditLogCategoryEnum property with full advanced search capabilities
- [Changeset](#changeset) — JSON object with changed task attribute values
- [ClientId](#clientid) — The unique identifier of an OAuth client
- [ClockPinRequest](#clockpinrequest) — ClockPinRequest
- [CloudConfigurationResponse](#cloudconfigurationresponse) — Configuration for SaaS/cloud-specific settings
- [ClusterModeChangeOperation](#clustermodechangeoperation) — A single operation that is part of a cluster mode change
- [ClusterModeChangeResponse](#clustermodechangeresponse) — The planned changes resulting from a cluster mode transition request
- [ClusterVariableKindExactMatch](#clustervariablekindexactmatch) — Matches the value exactly
- [ClusterVariableKindFilterProperty](#clustervariablekindfilterproperty) — ClusterVariableKindEnum property with full advanced search capabilities
- [ClusterVariableName](#clustervariablename) — The name of a cluster variable
- [ClusterVariableResult](#clustervariableresult) — ClusterVariableResult
- [ClusterVariableResultBase](#clustervariableresultbase) — Cluster variable response item
- [ClusterVariableScopeExactMatch](#clustervariablescopeexactmatch) — Matches the value exactly
- [ClusterVariableScopeFilterProperty](#clustervariablescopefilterproperty) — ClusterVariableScopeEnum property with full advanced search capabilities
- [ClusterVariableSearchQueryFilterRequest](#clustervariablesearchqueryfilterrequest) — Cluster variable filter request
- [ClusterVariableSearchQueryRequest](#clustervariablesearchqueryrequest) — Cluster variable search query request
- [ClusterVariableSearchQueryResult](#clustervariablesearchqueryresult) — Cluster variable search query response
- [ClusterVariableSearchQuerySortRequest](#clustervariablesearchquerysortrequest) — ClusterVariableSearchQuerySortRequest
- [ClusterVariableSearchResult](#clustervariablesearchresult) — Cluster variable search response item
- [ComponentsConfigurationResponse](#componentsconfigurationresponse) — Configuration for active Camunda components in the deployment
- [ConditionWaitStateDetails](#conditionwaitstatedetails) — ConditionWaitStateDetails
- [ConditionalEvaluationInstruction](#conditionalevaluationinstruction) — ConditionalEvaluationInstruction
- [ConsistencyOptions<T>](#consistencyoptions<t>) — Options for eventual consistency polling behavior
- [CorrelatedMessageSubscriptionFilter](#correlatedmessagesubscriptionfilter) — Correlated message subscriptions search filter
- [CorrelatedMessageSubscriptionResult](#correlatedmessagesubscriptionresult) — CorrelatedMessageSubscriptionResult
- [CorrelatedMessageSubscriptionSearchQuery](#correlatedmessagesubscriptionsearchquery) — CorrelatedMessageSubscriptionSearchQuery
- [CorrelatedMessageSubscriptionSearchQueryResult](#correlatedmessagesubscriptionsearchqueryresult) — CorrelatedMessageSubscriptionSearchQueryResult
- [CorrelatedMessageSubscriptionSearchQuerySortRequest](#correlatedmessagesubscriptionsearchquerysortrequest) — CorrelatedMessageSubscriptionSearchQuerySortRequest
- [CreateClusterVariableRequest](#createclustervariablerequest) — CreateClusterVariableRequest
- [CreateGlobalTaskListenerRequest](#createglobaltasklistenerrequest) — CreateGlobalTaskListenerRequest
- [CreateProcessInstanceResult](#createprocessinstanceresult) — CreateProcessInstanceResult
- [CursorBackwardPagination](#cursorbackwardpagination) — CursorBackwardPagination
- [CursorForwardPagination](#cursorforwardpagination) — CursorForwardPagination
- [DateTimeFilterProperty](#datetimefilterproperty) — Date-time property with full advanced search capabilities
- [DecisionDefinitionFilter](#decisiondefinitionfilter) — Decision definition search filter
- [DecisionDefinitionId](#decisiondefinitionid) — Id of a decision definition, from the model
- [DecisionDefinitionKeyExactMatch](#decisiondefinitionkeyexactmatch) — Matches the value exactly
- [DecisionDefinitionKeyFilterProperty](#decisiondefinitionkeyfilterproperty) — DecisionDefinitionKey property with full advanced search capabilities
- [DecisionDefinitionResult](#decisiondefinitionresult) — DecisionDefinitionResult
- [DecisionDefinitionSearchQuery](#decisiondefinitionsearchquery) — DecisionDefinitionSearchQuery
- [DecisionDefinitionSearchQueryResult](#decisiondefinitionsearchqueryresult) — DecisionDefinitionSearchQueryResult
- [DecisionDefinitionSearchQuerySortRequest](#decisiondefinitionsearchquerysortrequest) — DecisionDefinitionSearchQuerySortRequest
- [DecisionEvaluationById](#decisionevaluationbyid) — DecisionEvaluationById
- [DecisionEvaluationByKey](#decisionevaluationbykey) — DecisionEvaluationByKey
- [DecisionEvaluationInstanceKeyExactMatch](#decisionevaluationinstancekeyexactmatch) — Matches the value exactly
- [DecisionEvaluationInstanceKeyFilterProperty](#decisionevaluationinstancekeyfilterproperty) — DecisionEvaluationInstanceKey property with full advanced search capabilities
- [DecisionEvaluationInstruction](#decisionevaluationinstruction) — DecisionEvaluationInstruction
- [DecisionEvaluationKeyExactMatch](#decisionevaluationkeyexactmatch) — Matches the value exactly
- [DecisionEvaluationKeyFilterProperty](#decisionevaluationkeyfilterproperty) — DecisionEvaluationKey property with full advanced search capabilities
- [DecisionInstanceDeletionBatchOperationRequest](#decisioninstancedeletionbatchoperationrequest) — The decision instance filter that defines which decision instances should be deleted
- [DecisionInstanceFilter](#decisioninstancefilter) — Decision instance search filter
- [DecisionInstanceGetQueryResult](#decisioninstancegetqueryresult) — DecisionInstanceGetQueryResult
- [DecisionInstanceResult](#decisioninstanceresult) — DecisionInstanceResult
- [DecisionInstanceSearchQuery](#decisioninstancesearchquery) — DecisionInstanceSearchQuery
- [DecisionInstanceSearchQueryResult](#decisioninstancesearchqueryresult) — DecisionInstanceSearchQueryResult
- [DecisionInstanceSearchQuerySortRequest](#decisioninstancesearchquerysortrequest) — DecisionInstanceSearchQuerySortRequest
- [DecisionInstanceStateExactMatch](#decisioninstancestateexactmatch) — Matches the value exactly
- [DecisionInstanceStateFilterProperty](#decisioninstancestatefilterproperty) — DecisionInstanceStateEnum property with full advanced search capabilities
- [DecisionRequirementsFilter](#decisionrequirementsfilter) — Decision requirements search filter
- [DecisionRequirementsKeyExactMatch](#decisionrequirementskeyexactmatch) — Matches the value exactly
- [DecisionRequirementsKeyFilterProperty](#decisionrequirementskeyfilterproperty) — DecisionRequirementsKey property with full advanced search capabilities
- [DecisionRequirementsResult](#decisionrequirementsresult) — DecisionRequirementsResult
- [DecisionRequirementsSearchQuery](#decisionrequirementssearchquery) — DecisionRequirementsSearchQuery
- [DecisionRequirementsSearchQueryResult](#decisionrequirementssearchqueryresult) — DecisionRequirementsSearchQueryResult
- [DecisionRequirementsSearchQuerySortRequest](#decisionrequirementssearchquerysortrequest) — DecisionRequirementsSearchQuerySortRequest
- [DeleteDecisionInstanceRequest](#deletedecisioninstancerequest) — DeleteDecisionInstanceRequest
- [DeleteProcessInstanceRequest](#deleteprocessinstancerequest) — DeleteProcessInstanceRequest
- [DeleteResourceRequest](#deleteresourcerequest) — DeleteResourceRequest
- [DeleteResourceResponse](#deleteresourceresponse) — DeleteResourceResponse
- [DeploymentConfigurationResponse](#deploymentconfigurationresponse) — Configuration for deployment characteristics
- [DeploymentDecisionRequirementsResult](#deploymentdecisionrequirementsresult) — Deployed decision requirements
- [DeploymentDecisionResult](#deploymentdecisionresult) — A deployed decision
- [DeploymentFormResult](#deploymentformresult) — A deployed form
- [DeploymentKeyExactMatch](#deploymentkeyexactmatch) — Matches the value exactly
- [DeploymentKeyFilterProperty](#deploymentkeyfilterproperty) — DeploymentKey property with full advanced search capabilities
- [DeploymentMetadataResult](#deploymentmetadataresult) — DeploymentMetadataResult
- [DeploymentProcessResult](#deploymentprocessresult) — A deployed process
- [DeploymentResourceResult](#deploymentresourceresult) — A deployed Resource
- [DeploymentResult](#deploymentresult) — DeploymentResult
- [DirectAncestorKeyInstruction](#directancestorkeyinstruction) — Provides a concrete key to use as ancestor scope for the created element instance
- [DocumentCreationBatchResponse](#documentcreationbatchresponse) — DocumentCreationBatchResponse
- [DocumentCreationFailureDetail](#documentcreationfailuredetail) — DocumentCreationFailureDetail
- [DocumentId](#documentid) — Document Id that uniquely identifies a document
- [DocumentLink](#documentlink) — DocumentLink
- [DocumentLinkRequest](#documentlinkrequest) — DocumentLinkRequest
- [DocumentMetadata](#documentmetadata) — Information about the document
- [DocumentMetadataResponse](#documentmetadataresponse) — Information about the document that is returned in responses
- [DocumentReference](#documentreference) — DocumentReference
- [ElementId](#elementid) — The model-defined id of an element
- [ElementIdExactMatch](#elementidexactmatch) — Matches the value exactly
- [ElementIdFilterProperty](#elementidfilterproperty) — ElementId property with full advanced search capabilities
- [ElementInstanceFilter](#elementinstancefilter) — Element instance search filter
- [ElementInstanceFilterFields](#elementinstancefilterfields) — Element instance filter fields
- [ElementInstanceKeyExactMatch](#elementinstancekeyexactmatch) — Matches the value exactly
- [ElementInstanceKeyFilterProperty](#elementinstancekeyfilterproperty) — ElementInstanceKey property with full advanced search capabilities
- [ElementInstanceResult](#elementinstanceresult) — ElementInstanceResult
- [ElementInstanceSearchQuery](#elementinstancesearchquery) — Element instance search request
- [ElementInstanceSearchQueryResult](#elementinstancesearchqueryresult) — ElementInstanceSearchQueryResult
- [ElementInstanceSearchQuerySortRequest](#elementinstancesearchquerysortrequest) — ElementInstanceSearchQuerySortRequest
- [ElementInstanceStateExactMatch](#elementinstancestateexactmatch) — Matches the value exactly
- [ElementInstanceStateFilterProperty](#elementinstancestatefilterproperty) — ElementInstanceStateEnum property with full advanced search capabilities
- [ElementInstanceWaitStateFilter](#elementinstancewaitstatefilter) — Filters for the element instance inspection
- [ElementInstanceWaitStateQuery](#elementinstancewaitstatequery) — Element instance inspection request
- [ElementInstanceWaitStateQueryResult](#elementinstancewaitstatequeryresult) — ElementInstanceWaitStateQueryResult
- [ElementInstanceWaitStateQuerySortRequest](#elementinstancewaitstatequerysortrequest) — ElementInstanceWaitStateQuerySortRequest
- [ElementInstanceWaitStateResult](#elementinstancewaitstateresult) — An element instance waiting state
- [EndCursor](#endcursor) — The end cursor in a search query result set
- [EntityTypeExactMatch](#entitytypeexactmatch) — Matches the value exactly
- [EntityTypeFilterProperty](#entitytypefilterproperty) — AuditLogEntityTypeEnum property with full advanced search capabilities
- [EvaluateConditionalResult](#evaluateconditionalresult) — EvaluateConditionalResult
- [EvaluateDecisionResult](#evaluatedecisionresult) — EvaluateDecisionResult
- [EvaluatedDecisionInputItem](#evaluateddecisioninputitem) — A decision input that was evaluated within this decision evaluation
- [EvaluatedDecisionOutputItem](#evaluateddecisionoutputitem) — The evaluated decision outputs
- [EvaluatedDecisionResult](#evaluateddecisionresult) — A decision that was evaluated
- [EventualConsistencyTimeoutException](#eventualconsistencytimeoutexception) — Thrown when an eventually consistent endpoint times out waiting for data
- [ExpressionEvaluationRequest](#expressionevaluationrequest) — ExpressionEvaluationRequest
- [ExpressionEvaluationResult](#expressionevaluationresult) — ExpressionEvaluationResult
- [ExpressionEvaluationWarningItem](#expressionevaluationwarningitem) — ExpressionEvaluationWarningItem
- [ExtendedDeploymentResponse](#extendeddeploymentresponse) — Extended deployment result with typed convenience properties for direct access to deployed artifacts by category (processes, decisions, forms, etc
- [FormId](#formid) — The user-defined id for the form
- [FormKeyExactMatch](#formkeyexactmatch) — Matches the value exactly
- [FormKeyFilterProperty](#formkeyfilterproperty) — FormKey property with full advanced search capabilities
- [FormResult](#formresult) — FormResult
- [GlobalJobStatisticsQueryResult](#globaljobstatisticsqueryresult) — Global job statistics query result
- [GlobalListenerBase](#globallistenerbase) — GlobalListenerBase
- [GlobalListenerId](#globallistenerid) — The user-defined id for the global listener
- [GlobalListenerSourceExactMatch](#globallistenersourceexactmatch) — Matches the value exactly
- [GlobalListenerSourceFilterProperty](#globallistenersourcefilterproperty) — Global listener source property with full advanced search capabilities
- [GlobalTaskListenerBase](#globaltasklistenerbase) — GlobalTaskListenerBase
- [GlobalTaskListenerEventTypeExactMatch](#globaltasklistenereventtypeexactmatch) — Matches the value exactly
- [GlobalTaskListenerEventTypeFilterProperty](#globaltasklistenereventtypefilterproperty) — Global listener event type property with full advanced search capabilities
- [GlobalTaskListenerResult](#globaltasklistenerresult) — GlobalTaskListenerResult
- [GlobalTaskListenerSearchQueryFilterRequest](#globaltasklistenersearchqueryfilterrequest) — Global listener filter request
- [GlobalTaskListenerSearchQueryRequest](#globaltasklistenersearchqueryrequest) — Global listener search query request
- [GlobalTaskListenerSearchQueryResult](#globaltasklistenersearchqueryresult) — Global listener search query response
- [GlobalTaskListenerSearchQuerySortRequest](#globaltasklistenersearchquerysortrequest) — GlobalTaskListenerSearchQuerySortRequest
- [GroupClientResult](#groupclientresult) — GroupClientResult
- [GroupClientSearchQueryRequest](#groupclientsearchqueryrequest) — GroupClientSearchQueryRequest
- [GroupClientSearchQuerySortRequest](#groupclientsearchquerysortrequest) — GroupClientSearchQuerySortRequest
- [GroupClientSearchResult](#groupclientsearchresult) — GroupClientSearchResult
- [GroupCreateRequest](#groupcreaterequest) — GroupCreateRequest
- [GroupCreateResult](#groupcreateresult) — GroupCreateResult
- [GroupFilter](#groupfilter) — Group filter request
- [GroupId](#groupid) — The unique identifier of a group
- [GroupMappingRuleSearchResult](#groupmappingrulesearchresult) — GroupMappingRuleSearchResult
- [GroupResult](#groupresult) — Group search response item
- [GroupRoleSearchResult](#grouprolesearchresult) — GroupRoleSearchResult
- [GroupSearchQueryRequest](#groupsearchqueryrequest) — Group search request
- [GroupSearchQueryResult](#groupsearchqueryresult) — Group search response
- [GroupSearchQuerySortRequest](#groupsearchquerysortrequest) — GroupSearchQuerySortRequest
- [GroupUpdateRequest](#groupupdaterequest) — GroupUpdateRequest
- [GroupUpdateResult](#groupupdateresult) — GroupUpdateResult
- [GroupUserResult](#groupuserresult) — GroupUserResult
- [GroupUserSearchQueryRequest](#groupusersearchqueryrequest) — GroupUserSearchQueryRequest
- [GroupUserSearchQuerySortRequest](#groupusersearchquerysortrequest) — GroupUserSearchQuerySortRequest
- [GroupUserSearchResult](#groupusersearchresult) — GroupUserSearchResult
- [HttpSdkException](#httpsdkexception) — HTTP-specific SDK error with RFC 7807 Problem Details
- [ICamundaKey](#icamundakey) — Marker interface for all Camunda domain key types
- [ICamundaLongKey](#icamundalongkey) — Marker interface for Camunda domain types backed by a long (int64) value
- [ITenantIdSettable](#itenantidsettable) — Implemented by request body types that have an optional tenantId property
- [ITenantIdsSettable](#itenantidssettable) — Implemented by request body types that have an optional `tenantIds` array property (e
- [IncidentErrorTypeExactMatch](#incidenterrortypeexactmatch) — Matches the value exactly
- [IncidentErrorTypeFilterProperty](#incidenterrortypefilterproperty) — IncidentErrorTypeEnum with full advanced search capabilities
- [IncidentFilter](#incidentfilter) — Incident search filter
- [IncidentProcessInstanceStatisticsByDefinitionFilter](#incidentprocessinstancestatisticsbydefinitionfilter) — Filter for the incident process instance statistics by definition query
- [IncidentProcessInstanceStatisticsByDefinitionQuery](#incidentprocessinstancestatisticsbydefinitionquery) — IncidentProcessInstanceStatisticsByDefinitionQuery
- [IncidentProcessInstanceStatisticsByDefinitionQueryResult](#incidentprocessinstancestatisticsbydefinitionqueryresult) — IncidentProcessInstanceStatisticsByDefinitionQueryResult
- [IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest](#incidentprocessinstancestatisticsbydefinitionquerysortrequest) — IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest
- [IncidentProcessInstanceStatisticsByDefinitionResult](#incidentprocessinstancestatisticsbydefinitionresult) — IncidentProcessInstanceStatisticsByDefinitionResult
- [IncidentProcessInstanceStatisticsByErrorQuery](#incidentprocessinstancestatisticsbyerrorquery) — IncidentProcessInstanceStatisticsByErrorQuery
- [IncidentProcessInstanceStatisticsByErrorQueryResult](#incidentprocessinstancestatisticsbyerrorqueryresult) — IncidentProcessInstanceStatisticsByErrorQueryResult
- [IncidentProcessInstanceStatisticsByErrorQuerySortRequest](#incidentprocessinstancestatisticsbyerrorquerysortrequest) — IncidentProcessInstanceStatisticsByErrorQuerySortRequest
- [IncidentProcessInstanceStatisticsByErrorResult](#incidentprocessinstancestatisticsbyerrorresult) — IncidentProcessInstanceStatisticsByErrorResult
- [IncidentResolutionRequest](#incidentresolutionrequest) — IncidentResolutionRequest
- [IncidentResult](#incidentresult) — IncidentResult
- [IncidentSearchQuery](#incidentsearchquery) — IncidentSearchQuery
- [IncidentSearchQueryResult](#incidentsearchqueryresult) — IncidentSearchQueryResult
- [IncidentSearchQuerySortRequest](#incidentsearchquerysortrequest) — IncidentSearchQuerySortRequest
- [IncidentStateExactMatch](#incidentstateexactmatch) — Matches the value exactly
- [IncidentStateFilterProperty](#incidentstatefilterproperty) — IncidentStateEnum with full advanced search capabilities
- [InferredAncestorKeyInstruction](#inferredancestorkeyinstruction) — Instructs the engine to derive the ancestor scope key from the source element's hierarchy
- [IntegerFilterProperty](#integerfilterproperty) — Integer property with advanced search capabilities
- [JobActivationRequest](#jobactivationrequest) — JobActivationRequest
- [JobActivationResult](#jobactivationresult) — The list of activated jobs
- [JobBatchUpdateRequest](#jobbatchupdaterequest) — The filter and changeset for a batch job update operation
- [JobChangeset](#jobchangeset) — JSON object with changed job attribute values
- [JobCompletionRequest](#jobcompletionrequest) — JobCompletionRequest
- [JobErrorRequest](#joberrorrequest) — JobErrorRequest
- [JobErrorStatisticsFilter](#joberrorstatisticsfilter) — Job error statistics search filter
- [JobErrorStatisticsItem](#joberrorstatisticsitem) — Aggregated error metrics for a single error type and message combination
- [JobErrorStatisticsQuery](#joberrorstatisticsquery) — Job error statistics query
- [JobErrorStatisticsQueryResult](#joberrorstatisticsqueryresult) — Job error statistics query result
- [JobFailRequest](#jobfailrequest) — JobFailRequest
- [JobFailureException](#jobfailureexception) — Throw from a job handler to explicitly fail a job with custom retry settings
- [JobFilter](#jobfilter) — Job search filter
- [JobHandler](#jobhandler) — Delegate for job handler functions
- [JobKeyExactMatch](#jobkeyexactmatch) — Matches the value exactly
- [JobKeyFilterProperty](#jobkeyfilterproperty) — JobKey property with full advanced search capabilities
- [JobKindExactMatch](#jobkindexactmatch) — Matches the value exactly
- [JobKindFilterProperty](#jobkindfilterproperty) — JobKindEnum property with full advanced search capabilities
- [JobListenerEventTypeExactMatch](#joblistenereventtypeexactmatch) — Matches the value exactly
- [JobListenerEventTypeFilterProperty](#joblistenereventtypefilterproperty) — JobListenerEventTypeEnum property with full advanced search capabilities
- [JobMetricsConfigurationResponse](#jobmetricsconfigurationresponse) — Configuration for job metrics collection and export
- [JobResult](#jobresult) — The result of the completed job as determined by the worker
- [JobResultActivateElement](#jobresultactivateelement) — Instruction to activate a single BPMN element within an ad‑hoc sub‑process, optionally providing variables scoped to that element
- [JobResultAdHocSubProcess](#jobresultadhocsubprocess) — Job result details for an ad‑hoc sub‑process, including elements to activate and flags indicating completion or cancellation behavior
- [JobResultCorrections](#jobresultcorrections) — JSON object with attributes that were corrected by the worker
- [JobResultUserTask](#jobresultusertask) — Job result details for a user task completion, optionally including a denial reason and corrected task properties
- [JobSearchQuery](#jobsearchquery) — Job search request
- [JobSearchQueryResult](#jobsearchqueryresult) — Job search response
- [JobSearchQuerySortRequest](#jobsearchquerysortrequest) — JobSearchQuerySortRequest
- [JobSearchResult](#jobsearchresult) — JobSearchResult
- [JobStateExactMatch](#jobstateexactmatch) — Matches the value exactly
- [JobStateFilterProperty](#jobstatefilterproperty) — JobStateEnum property with full advanced search capabilities
- [JobTimeSeriesStatisticsFilter](#jobtimeseriesstatisticsfilter) — Job time-series statistics search filter
- [JobTimeSeriesStatisticsItem](#jobtimeseriesstatisticsitem) — Aggregated job metrics for a single time bucket
- [JobTimeSeriesStatisticsQuery](#jobtimeseriesstatisticsquery) — Job time-series statistics query
- [JobTimeSeriesStatisticsQueryResult](#jobtimeseriesstatisticsqueryresult) — Job time-series statistics query result
- [JobTypeStatisticsFilter](#jobtypestatisticsfilter) — Job type statistics search filter
- [JobTypeStatisticsItem](#jobtypestatisticsitem) — Statistics for a single job type
- [JobTypeStatisticsQuery](#jobtypestatisticsquery) — Job type statistics query
- [JobTypeStatisticsQueryResult](#jobtypestatisticsqueryresult) — Job type statistics query result
- [JobUpdateRequest](#jobupdaterequest) — JobUpdateRequest
- [JobWaitStateDetails](#jobwaitstatedetails) — JobWaitStateDetails
- [JobWorker](#jobworker) — A long-running worker that polls the Camunda broker for jobs of a specific type, dispatches them to a handler, and auto-completes or auto-fails based on the outcome
- [JobWorkerStatisticsFilter](#jobworkerstatisticsfilter) — Job worker statistics search filter
- [JobWorkerStatisticsItem](#jobworkerstatisticsitem) — Statistics for a single worker within a job type
- [JobWorkerStatisticsQuery](#jobworkerstatisticsquery) — Job worker statistics query
- [JobWorkerStatisticsQueryResult](#jobworkerstatisticsqueryresult) — Job worker statistics query result
- [LicenseResponse](#licenseresponse) — The response of a license request
- [LikeFilter](#likefilter) — Checks if the property matches the provided like value
- [LimitPagination](#limitpagination) — LimitPagination
- [LoopIterationId](#loopiterationid) — A client-provided sequential integer identifying one pass through the agent feedback loop: one LLM call, its tool dispatches, and their results
- [MappingRuleCreateRequest](#mappingrulecreaterequest) — MappingRuleCreateRequest
- [MappingRuleCreateResult](#mappingrulecreateresult) — MappingRuleCreateResult
- [MappingRuleCreateUpdateRequest](#mappingrulecreateupdaterequest) — MappingRuleCreateUpdateRequest
- [MappingRuleCreateUpdateResult](#mappingrulecreateupdateresult) — MappingRuleCreateUpdateResult
- [MappingRuleFilter](#mappingrulefilter) — Mapping rule search filter
- [MappingRuleId](#mappingruleid) — The unique identifier of a mapping rule
- [MappingRuleResult](#mappingruleresult) — MappingRuleResult
- [MappingRuleSearchQueryRequest](#mappingrulesearchqueryrequest) — MappingRuleSearchQueryRequest
- [MappingRuleSearchQueryResult](#mappingrulesearchqueryresult) — MappingRuleSearchQueryResult
- [MappingRuleSearchQuerySortRequest](#mappingrulesearchquerysortrequest) — MappingRuleSearchQuerySortRequest
- [MappingRuleUpdateRequest](#mappingruleupdaterequest) — MappingRuleUpdateRequest
- [MappingRuleUpdateResult](#mappingruleupdateresult) — MappingRuleUpdateResult
- [MatchedDecisionRuleItem](#matcheddecisionruleitem) — A decision rule that matched within this decision evaluation
- [MessageCorrelationRequest](#messagecorrelationrequest) — MessageCorrelationRequest
- [MessageCorrelationResult](#messagecorrelationresult) — The message key of the correlated message, as well as the first process instance key it correlated with
- [MessagePublicationRequest](#messagepublicationrequest) — MessagePublicationRequest
- [MessagePublicationResult](#messagepublicationresult) — The message key of the published message
- [MessageSubscriptionFilter](#messagesubscriptionfilter) — Message subscription search filter
- [MessageSubscriptionKeyExactMatch](#messagesubscriptionkeyexactmatch) — Matches the value exactly
- [MessageSubscriptionKeyFilterProperty](#messagesubscriptionkeyfilterproperty) — MessageSubscriptionKey property with full advanced search capabilities
- [MessageSubscriptionResult](#messagesubscriptionresult) — MessageSubscriptionResult
- [MessageSubscriptionSearchQuery](#messagesubscriptionsearchquery) — MessageSubscriptionSearchQuery
- [MessageSubscriptionSearchQueryResult](#messagesubscriptionsearchqueryresult) — MessageSubscriptionSearchQueryResult
- [MessageSubscriptionSearchQuerySortRequest](#messagesubscriptionsearchquerysortrequest) — MessageSubscriptionSearchQuerySortRequest
- [MessageSubscriptionStateExactMatch](#messagesubscriptionstateexactmatch) — Matches the value exactly
- [MessageSubscriptionStateFilterProperty](#messagesubscriptionstatefilterproperty) — MessageSubscriptionStateEnum with full advanced search capabilities
- [MessageSubscriptionTypeExactMatch](#messagesubscriptiontypeexactmatch) — Matches the value exactly
- [MessageSubscriptionTypeFilterProperty](#messagesubscriptiontypefilterproperty) — MessageSubscriptionTypeEnum with full advanced search capabilities
- [MessageWaitStateDetails](#messagewaitstatedetails) — MessageWaitStateDetails
- [MigrateProcessInstanceMappingInstruction](#migrateprocessinstancemappinginstruction) — The mapping instructions describe how to map elements from the source process definition to the target process definition
- [ModifyProcessInstanceVariableInstruction](#modifyprocessinstancevariableinstruction) — Instruction describing which variables to create or update
- [OffsetPagination](#offsetpagination) — OffsetPagination
- [OperationReference](#operationreference) — A reference key chosen by the user that will be part of all records resulting from this operation
- [OperationTypeExactMatch](#operationtypeexactmatch) — Matches the value exactly
- [OperationTypeFilterProperty](#operationtypefilterproperty) — AuditLogOperationTypeEnum property with full advanced search capabilities
- [Partition](#partition) — Provides information on a partition within a broker node
- [ProblemDetail](#problemdetail) — A Problem detail object as described in [RFC 9457](https://www
- [ProcessDefinitionElementStatisticsQuery](#processdefinitionelementstatisticsquery) — Process definition element statistics request
- [ProcessDefinitionElementStatisticsQueryResult](#processdefinitionelementstatisticsqueryresult) — Process definition element statistics query response
- [ProcessDefinitionFilter](#processdefinitionfilter) — Process definition search filter
- [ProcessDefinitionId](#processdefinitionid) — Id of a process definition, from the model
- [ProcessDefinitionIdExactMatch](#processdefinitionidexactmatch) — Matches the value exactly
- [ProcessDefinitionIdFilterProperty](#processdefinitionidfilterproperty) — ProcessDefinitionId property with full advanced search capabilities
- [ProcessDefinitionInstanceStatisticsQuery](#processdefinitioninstancestatisticsquery) — ProcessDefinitionInstanceStatisticsQuery
- [ProcessDefinitionInstanceStatisticsQueryResult](#processdefinitioninstancestatisticsqueryresult) — ProcessDefinitionInstanceStatisticsQueryResult
- [ProcessDefinitionInstanceStatisticsQuerySortRequest](#processdefinitioninstancestatisticsquerysortrequest) — ProcessDefinitionInstanceStatisticsQuerySortRequest
- [ProcessDefinitionInstanceStatisticsResult](#processdefinitioninstancestatisticsresult) — Process definition instance statistics response
- [ProcessDefinitionInstanceVersionStatisticsFilter](#processdefinitioninstanceversionstatisticsfilter) — Process definition instance version statistics search filter
- [ProcessDefinitionInstanceVersionStatisticsQuery](#processdefinitioninstanceversionstatisticsquery) — ProcessDefinitionInstanceVersionStatisticsQuery
- [ProcessDefinitionInstanceVersionStatisticsQueryResult](#processdefinitioninstanceversionstatisticsqueryresult) — ProcessDefinitionInstanceVersionStatisticsQueryResult
- [ProcessDefinitionInstanceVersionStatisticsQuerySortRequest](#processdefinitioninstanceversionstatisticsquerysortrequest) — ProcessDefinitionInstanceVersionStatisticsQuerySortRequest
- [ProcessDefinitionInstanceVersionStatisticsResult](#processdefinitioninstanceversionstatisticsresult) — Process definition instance version statistics response
- [ProcessDefinitionKeyExactMatch](#processdefinitionkeyexactmatch) — Matches the value exactly
- [ProcessDefinitionKeyFilterProperty](#processdefinitionkeyfilterproperty) — ProcessDefinitionKey property with full advanced search capabilities
- [ProcessDefinitionMessageSubscriptionStatisticsQuery](#processdefinitionmessagesubscriptionstatisticsquery) — ProcessDefinitionMessageSubscriptionStatisticsQuery
- [ProcessDefinitionMessageSubscriptionStatisticsQueryResult](#processdefinitionmessagesubscriptionstatisticsqueryresult) — ProcessDefinitionMessageSubscriptionStatisticsQueryResult
- [ProcessDefinitionMessageSubscriptionStatisticsResult](#processdefinitionmessagesubscriptionstatisticsresult) — ProcessDefinitionMessageSubscriptionStatisticsResult
- [ProcessDefinitionResult](#processdefinitionresult) — ProcessDefinitionResult
- [ProcessDefinitionSearchQuery](#processdefinitionsearchquery) — ProcessDefinitionSearchQuery
- [ProcessDefinitionSearchQueryResult](#processdefinitionsearchqueryresult) — ProcessDefinitionSearchQueryResult
- [ProcessDefinitionSearchQuerySortRequest](#processdefinitionsearchquerysortrequest) — ProcessDefinitionSearchQuerySortRequest
- [ProcessDefinitionStatisticsFilter](#processdefinitionstatisticsfilter) — Process definition statistics search filter
- [ProcessDefinitionVariableNameFilter](#processdefinitionvariablenamefilter) — Process definition variable name filter request
- [ProcessDefinitionVariableNameSearchQuery](#processdefinitionvariablenamesearchquery) — Process definition variable name search query request
- [ProcessDefinitionVariableNameSearchQueryResult](#processdefinitionvariablenamesearchqueryresult) — Process definition variable name search query response
- [ProcessDefinitionVariableNameSearchResult](#processdefinitionvariablenamesearchresult) — Process definition variable name search response item
- [ProcessElementStatisticsResult](#processelementstatisticsresult) — Process element statistics response
- [ProcessInstanceBusinessIdAssignmentInstruction](#processinstancebusinessidassignmentinstruction) — The instruction describing the business id to assign to a running process instance
- [ProcessInstanceCallHierarchyEntry](#processinstancecallhierarchyentry) — ProcessInstanceCallHierarchyEntry
- [ProcessInstanceCancellationBatchOperationRequest](#processinstancecancellationbatchoperationrequest) — The process instance filter that defines which process instances should be canceled
- [ProcessInstanceCreationInstruction](#processinstancecreationinstruction) — Instructions for creating a process instance
- [ProcessInstanceCreationInstructionById](#processinstancecreationinstructionbyid) — ProcessInstanceCreationInstructionById
- [ProcessInstanceCreationInstructionByKey](#processinstancecreationinstructionbykey) — ProcessInstanceCreationInstructionByKey
- [ProcessInstanceCreationRuntimeInstruction](#processinstancecreationruntimeinstruction) — ProcessInstanceCreationRuntimeInstruction
- [ProcessInstanceCreationStartInstruction](#processinstancecreationstartinstruction) — ProcessInstanceCreationStartInstruction
- [ProcessInstanceCreationTerminateInstruction](#processinstancecreationterminateinstruction) — Terminates the process instance after a specific BPMN element is completed or terminated
- [ProcessInstanceDeletionBatchOperationRequest](#processinstancedeletionbatchoperationrequest) — The process instance filter that defines which process instances should be deleted
- [ProcessInstanceElementStatisticsQueryResult](#processinstanceelementstatisticsqueryresult) — Process instance element statistics query response
- [ProcessInstanceFilter](#processinstancefilter) — Process instance search filter
- [ProcessInstanceFilterFields](#processinstancefilterfields) — Process instance search filter
- [ProcessInstanceIncidentResolutionBatchOperationRequest](#processinstanceincidentresolutionbatchoperationrequest) — The process instance filter that defines which process instances should have their incidents resolved
- [ProcessInstanceKeyExactMatch](#processinstancekeyexactmatch) — Matches the value exactly
- [ProcessInstanceKeyFilterProperty](#processinstancekeyfilterproperty) — ProcessInstanceKey property with full advanced search capabilities
- [ProcessInstanceMigrationBatchOperationPlan](#processinstancemigrationbatchoperationplan) — The migration instructions describe how to migrate a process instance from one process definition to another
- [ProcessInstanceMigrationBatchOperationRequest](#processinstancemigrationbatchoperationrequest) — ProcessInstanceMigrationBatchOperationRequest
- [ProcessInstanceMigrationInstruction](#processinstancemigrationinstruction) — The migration instructions describe how to migrate a process instance from one process definition to another
- [ProcessInstanceModificationActivateInstruction](#processinstancemodificationactivateinstruction) — Instruction describing an element to activate
- [ProcessInstanceModificationBatchOperationRequest](#processinstancemodificationbatchoperationrequest) — The process instance filter to define on which process instances tokens should be moved, and new element instances should be activated or terminated
- [ProcessInstanceModificationInstruction](#processinstancemodificationinstruction) — ProcessInstanceModificationInstruction
- [ProcessInstanceModificationMoveBatchOperationInstruction](#processinstancemodificationmovebatchoperationinstruction) — Instructions describing a move operation
- [ProcessInstanceModificationMoveInstruction](#processinstancemodificationmoveinstruction) — Instruction describing a move operation
- [ProcessInstanceModificationTerminateByIdInstruction](#processinstancemodificationterminatebyidinstruction) — Instruction describing which elements to terminate
- [ProcessInstanceModificationTerminateByKeyInstruction](#processinstancemodificationterminatebykeyinstruction) — Instruction providing the key of the element instance to terminate
- [ProcessInstanceModificationTerminateInstruction](#processinstancemodificationterminateinstruction) — Instruction describing which elements to terminate
- [ProcessInstanceReference](#processinstancereference) — ProcessInstanceReference
- [ProcessInstanceResult](#processinstanceresult) — Process instance search response item
- [ProcessInstanceResumptionBatchOperationRequest](#processinstanceresumptionbatchoperationrequest) — The process instance filter that defines which process instances should be resumed
- [ProcessInstanceSearchQuery](#processinstancesearchquery) — Process instance search request
- [ProcessInstanceSearchQueryResult](#processinstancesearchqueryresult) — Process instance search response
- [ProcessInstanceSearchQuerySortRequest](#processinstancesearchquerysortrequest) — ProcessInstanceSearchQuerySortRequest
- [ProcessInstanceSequenceFlowResult](#processinstancesequenceflowresult) — Process instance sequence flow result
- [ProcessInstanceSequenceFlowsQueryResult](#processinstancesequenceflowsqueryresult) — Process instance sequence flows query response
- [ProcessInstanceStateExactMatch](#processinstancestateexactmatch) — Matches the value exactly
- [ProcessInstanceStateFilterProperty](#processinstancestatefilterproperty) — ProcessInstanceStateEnum property with full advanced search capabilities
- [ProcessInstanceSuspensionBatchOperationRequest](#processinstancesuspensionbatchoperationrequest) — The process instance filter that defines which process instances should be suspended
- [ProcessInstanceWaitStateStatisticsQueryResult](#processinstancewaitstatestatisticsqueryresult) — Process instance wait state statistics query response
- [ProcessInstanceWaitStateStatisticsResult](#processinstancewaitstatestatisticsresult) — Process instance wait state statistics response item
- [ResolvedSecret](#resolvedsecret) — ResolvedSecret
- [ResourceFilter](#resourcefilter) — Resource search filter
- [ResourceKeyExactMatch](#resourcekeyexactmatch) — Matches the value exactly
- [ResourceKeyFilterProperty](#resourcekeyfilterproperty) — ResourceKey property with full advanced search capabilities
- [ResourceResult](#resourceresult) — ResourceResult
- [ResourceSearchQuery](#resourcesearchquery) — ResourceSearchQuery
- [ResourceSearchQueryResult](#resourcesearchqueryresult) — ResourceSearchQueryResult
- [ResourceSearchQuerySortRequest](#resourcesearchquerysortrequest) — ResourceSearchQuerySortRequest
- [RestoreRequest](#restorerequest) — Describes a restore request
- [ResumeProcessInstanceRequest](#resumeprocessinstancerequest) — ResumeProcessInstanceRequest
- [RetryDecision](#retrydecision)
- [RoleClientResult](#roleclientresult) — RoleClientResult
- [RoleClientSearchQueryRequest](#roleclientsearchqueryrequest) — RoleClientSearchQueryRequest
- [RoleClientSearchQuerySortRequest](#roleclientsearchquerysortrequest) — RoleClientSearchQuerySortRequest
- [RoleClientSearchResult](#roleclientsearchresult) — RoleClientSearchResult
- [RoleCreateRequest](#rolecreaterequest) — RoleCreateRequest
- [RoleCreateResult](#rolecreateresult) — RoleCreateResult
- [RoleFilter](#rolefilter) — Role filter request
- [RoleGroupResult](#rolegroupresult) — RoleGroupResult
- [RoleGroupSearchQueryRequest](#rolegroupsearchqueryrequest) — RoleGroupSearchQueryRequest
- [RoleGroupSearchQuerySortRequest](#rolegroupsearchquerysortrequest) — RoleGroupSearchQuerySortRequest
- [RoleGroupSearchResult](#rolegroupsearchresult) — RoleGroupSearchResult
- [RoleId](#roleid) — The unique identifier of a role
- [RoleMappingRuleSearchResult](#rolemappingrulesearchresult) — RoleMappingRuleSearchResult
- [RoleResult](#roleresult) — Role search response item
- [RoleSearchQueryRequest](#rolesearchqueryrequest) — Role search request
- [RoleSearchQueryResult](#rolesearchqueryresult) — Role search response
- [RoleSearchQuerySortRequest](#rolesearchquerysortrequest) — RoleSearchQuerySortRequest
- [RoleUpdateRequest](#roleupdaterequest) — RoleUpdateRequest
- [RoleUpdateResult](#roleupdateresult) — RoleUpdateResult
- [RoleUserResult](#roleuserresult) — RoleUserResult
- [RoleUserSearchQueryRequest](#roleusersearchqueryrequest) — RoleUserSearchQueryRequest
- [RoleUserSearchQuerySortRequest](#roleusersearchquerysortrequest) — RoleUserSearchQuerySortRequest
- [RoleUserSearchResult](#roleusersearchresult) — RoleUserSearchResult
- [ScopeKeyExactMatch](#scopekeyexactmatch) — Matches the value exactly
- [ScopeKeyFilterProperty](#scopekeyfilterproperty) — ScopeKey property with full advanced search capabilities
- [SearchQueryPageRequest](#searchquerypagerequest) — Pagination criteria
- [SearchQueryPageResponse](#searchquerypageresponse) — Pagination information about the search results
- [SearchQueryRequest](#searchqueryrequest) — SearchQueryRequest
- [SearchQueryResponse](#searchqueryresponse) — SearchQueryResponse
- [SecretResolutionError](#secretresolutionerror) — SecretResolutionError
- [SecretResolveRequest](#secretresolverequest) — SecretResolveRequest
- [SecretResolveResult](#secretresolveresult) — The per-reference outcome of a resolve request
- [SetVariableRequest](#setvariablerequest) — SetVariableRequest
- [SignalBroadcastRequest](#signalbroadcastrequest) — SignalBroadcastRequest
- [SignalBroadcastResult](#signalbroadcastresult) — SignalBroadcastResult
- [SignalWaitStateDetails](#signalwaitstatedetails) — SignalWaitStateDetails
- [SourceElementIdInstruction](#sourceelementidinstruction) — Defines an instruction with a sourceElementId
- [SourceElementInstanceKeyInstruction](#sourceelementinstancekeyinstruction) — Defines an instruction with a sourceElementInstanceKey
- [SourceElementInstruction](#sourceelementinstruction) — Defines the source element identifier for the move instruction
- [StartCursor](#startcursor) — The start cursor in a search query result set
- [StatusMetric](#statusmetric) — Metric for a single job status
- [StopResult](#stopresult) — Result of a `JobWorker
- [StringFilterProperty](#stringfilterproperty) — String property with full advanced search capabilities
- [SuspendProcessInstanceRequest](#suspendprocessinstancerequest) — SuspendProcessInstanceRequest
- [SystemConfigurationResponse](#systemconfigurationresponse) — Envelope for all system configuration sections
- [Tag](#tag) — A tag
- [TenantClientResult](#tenantclientresult) — TenantClientResult
- [TenantClientSearchQueryRequest](#tenantclientsearchqueryrequest) — TenantClientSearchQueryRequest
- [TenantClientSearchQuerySortRequest](#tenantclientsearchquerysortrequest) — TenantClientSearchQuerySortRequest
- [TenantClientSearchResult](#tenantclientsearchresult) — TenantClientSearchResult
- [TenantCreateRequest](#tenantcreaterequest) — TenantCreateRequest
- [TenantCreateResult](#tenantcreateresult) — TenantCreateResult
- [TenantFilter](#tenantfilter) — Tenant filter request
- [TenantGroupResult](#tenantgroupresult) — TenantGroupResult
- [TenantGroupSearchQueryRequest](#tenantgroupsearchqueryrequest) — TenantGroupSearchQueryRequest
- [TenantGroupSearchQuerySortRequest](#tenantgroupsearchquerysortrequest) — TenantGroupSearchQuerySortRequest
- [TenantGroupSearchResult](#tenantgroupsearchresult) — TenantGroupSearchResult
- [TenantId](#tenantid) — The unique identifier of the tenant
- [TenantMappingRuleSearchResult](#tenantmappingrulesearchresult) — TenantMappingRuleSearchResult
- [TenantResult](#tenantresult) — Tenant search response item
- [TenantRoleSearchResult](#tenantrolesearchresult) — TenantRoleSearchResult
- [TenantSearchQueryRequest](#tenantsearchqueryrequest) — Tenant search request
- [TenantSearchQueryResult](#tenantsearchqueryresult) — Tenant search response
- [TenantSearchQuerySortRequest](#tenantsearchquerysortrequest) — TenantSearchQuerySortRequest
- [TenantUpdateRequest](#tenantupdaterequest) — TenantUpdateRequest
- [TenantUpdateResult](#tenantupdateresult) — TenantUpdateResult
- [TenantUserResult](#tenantuserresult) — TenantUserResult
- [TenantUserSearchQueryRequest](#tenantusersearchqueryrequest) — TenantUserSearchQueryRequest
- [TenantUserSearchQuerySortRequest](#tenantusersearchquerysortrequest) — TenantUserSearchQuerySortRequest
- [TenantUserSearchResult](#tenantusersearchresult) — TenantUserSearchResult
- [TimerWaitStateDetails](#timerwaitstatedetails) — TimerWaitStateDetails
- [TlsConfig](#tlsconfig) — TLS / mTLS configuration for custom certificates
- [TopologyResponse](#topologyresponse) — The response of a topology request
- [TypedVariables](#typedvariables) — Extension methods for deserializing Camunda variable and custom header payloads from untyped `object` properties into strongly-typed DTOs
- [TypedVariablesException](#typedvariablesexception) — Base class for all errors raised by the DTO-driven typed variable map feature (`CamundaClient
- [UpdateClusterVariableRequest](#updateclustervariablerequest) — UpdateClusterVariableRequest
- [UpdateGlobalTaskListenerRequest](#updateglobaltasklistenerrequest) — UpdateGlobalTaskListenerRequest
- [UsageMetricsResponse](#usagemetricsresponse) — UsageMetricsResponse
- [UsageMetricsResponseItem](#usagemetricsresponseitem) — UsageMetricsResponseItem
- [UseSourceParentKeyInstruction](#usesourceparentkeyinstruction) — Instructs the engine to use the source's direct parent key as the ancestor scope key for the target element
- [UserCreateResult](#usercreateresult) — UserCreateResult
- [UserFilter](#userfilter) — User search filter
- [UserRequest](#userrequest) — UserRequest
- [UserResult](#userresult) — UserResult
- [UserSearchQueryRequest](#usersearchqueryrequest) — UserSearchQueryRequest
- [UserSearchQuerySortRequest](#usersearchquerysortrequest) — UserSearchQuerySortRequest
- [UserSearchResult](#usersearchresult) — UserSearchResult
- [UserTaskAssignmentRequest](#usertaskassignmentrequest) — UserTaskAssignmentRequest
- [UserTaskAuditLogFilter](#usertaskauditlogfilter) — The user task audit log search filters
- [UserTaskAuditLogSearchQueryRequest](#usertaskauditlogsearchqueryrequest) — User task search query request
- [UserTaskCompletionRequest](#usertaskcompletionrequest) — UserTaskCompletionRequest
- [UserTaskEffectiveVariableSearchQueryRequest](#usertaskeffectivevariablesearchqueryrequest) — User task effective variable search query request
- [UserTaskFilter](#usertaskfilter) — User task filter request
- [UserTaskProperties](#usertaskproperties) — Contains properties of a user task
- [UserTaskResult](#usertaskresult) — UserTaskResult
- [UserTaskSearchQuery](#usertasksearchquery) — User task search query request
- [UserTaskSearchQueryResult](#usertasksearchqueryresult) — User task search query response
- [UserTaskSearchQuerySortRequest](#usertasksearchquerysortrequest) — UserTaskSearchQuerySortRequest
- [UserTaskStateExactMatch](#usertaskstateexactmatch) — Matches the value exactly
- [UserTaskStateFilterProperty](#usertaskstatefilterproperty) — UserTaskStateEnum property with full advanced search capabilities
- [UserTaskUpdateRequest](#usertaskupdaterequest) — UserTaskUpdateRequest
- [UserTaskVariableFilter](#usertaskvariablefilter) — The user task variable search filters
- [UserTaskVariableSearchQueryRequest](#usertaskvariablesearchqueryrequest) — User task search query request
- [UserTaskVariableSearchQuerySortRequest](#usertaskvariablesearchquerysortrequest) — UserTaskVariableSearchQuerySortRequest
- [UserTaskWaitStateDetails](#usertaskwaitstatedetails) — UserTaskWaitStateDetails
- [UserUpdateRequest](#userupdaterequest) — UserUpdateRequest
- [UserUpdateResult](#userupdateresult) — UserUpdateResult
- [Username](#username) — The unique name of a user
- [VariableDeserializationException](#variabledeserializationexception) — Raised when a present variable value cannot be deserialized
- [VariableFilter](#variablefilter) — Variable filter request
- [VariableKeyExactMatch](#variablekeyexactmatch) — Matches the value exactly
- [VariableKeyFilterProperty](#variablekeyfilterproperty) — VariableKey property with full advanced search capabilities
- [VariableMap<T>](#variablemap<t>) — Result of a DTO-driven variable search (`CamundaClient
- [VariableResult](#variableresult) — Variable search response item
- [VariableResultBase](#variableresultbase) — Variable response item
- [VariableScopeCollisionException](#variablescopecollisionexception) — Raised when a declared variable name is returned at more than one scope
- [VariableSearchQuery](#variablesearchquery) — Variable search query request
- [VariableSearchQueryResult](#variablesearchqueryresult) — Variable search query response
- [VariableSearchQuerySortRequest](#variablesearchquerysortrequest) — VariableSearchQuerySortRequest
- [VariableSearchResult](#variablesearchresult) — Variable search response item
- [VariableValidationException](#variablevalidationexception) — Raised by `VariableMap
- [VariableValueFilterProperty](#variablevaluefilterproperty) — VariableValueFilterProperty
- [WaitStateDetails](#waitstatedetails) — Wait-state-specific details of an element instance
- [WaitStateElementTypeExactMatch](#waitstateelementtypeexactmatch) — Matches the value exactly
- [WaitStateElementTypeFilterProperty](#waitstateelementtypefilterproperty) — Element type property with full advanced search capabilities
- [WaitStateTypeExactMatch](#waitstatetypeexactmatch) — Matches the value exactly
- [WaitStateTypeFilterProperty](#waitstatetypefilterproperty) — Wait state type property with full advanced search capabilities
- [WorkerDefaultsConfig](#workerdefaultsconfig)

---

## ActivatedJob

An activated job received from the Camunda broker, with typed variable access. This is what job handler functions receive.

```csharp
public sealed class ActivatedJob
```

| Property                   | Type                       | Description                                                     |
| -------------------------- | -------------------------- | --------------------------------------------------------------- |
| `Type`                     | `String`                   | The job type (matches the BPMN task definition type).           |
| `ProcessDefinitionId`      | `ProcessDefinitionId`      | The BPMN process ID of the job's process definition.            |
| `ProcessDefinitionVersion` | `Int32`                    | The version of the job's process definition.                    |
| `ElementId`                | `ElementId`                | The associated task element ID.                                 |
| `CustomHeaders`            | `Object`                   | Raw custom headers (typically a `Json.JsonElement` at runtime). |
| `Worker`                   | `String`                   | The name of the worker that activated this job.                 |
| `Retries`                  | `Int32`                    | Retries remaining for this job.                                 |
| `Deadline`                 | `Int64`                    | UNIX epoch timestamp (ms) when the job lock expires.            |
| `Variables`                | `Object`                   | Raw variables (typically a `Json.JsonElement` at runtime).      |
| `TenantId`                 | `TenantId`                 | The tenant that owns this job.                                  |
| `JobKey`                   | `JobKey`                   | Unique identifier for this job.                                 |
| `ProcessInstanceKey`       | `ProcessInstanceKey`       | The process instance this job belongs to.                       |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey`     | The process definition key.                                     |
| `ElementInstanceKey`       | `ElementInstanceKey`       | The element instance key.                                       |
| `Kind`                     | `JobKindEnum`              | The job kind.                                                   |
| `ListenerEventType`        | `JobListenerEventTypeEnum` | The listener event type.                                        |
| `UserTask`                 | `UserTaskProperties`       | User task properties (if this is a user task job).              |
| `Tags`                     | `List<Tag>`                | Tags associated with this job.                                  |

## ActivatedJobResult

```csharp
public sealed class ActivatedJobResult
```

| Property                   | Type                           | Description                                                                                                                                                                                                                                 |
| -------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Type`                     | `String`                       | The type of the job (should match what was requested).                                                                                                                                                                                      |
| `ProcessDefinitionId`      | `ProcessDefinitionId`          | The bpmn process ID of the job's process definition.                                                                                                                                                                                        |
| `ProcessDefinitionVersion` | `Int32`                        | The version of the job's process definition.                                                                                                                                                                                                |
| `ElementId`                | `ElementId`                    | The associated task element ID.                                                                                                                                                                                                             |
| `CustomHeaders`            | `Object`                       | A set of custom headers defined during modelling; returned as a serialized JSON document.                                                                                                                                                   |
| `Worker`                   | `String`                       | The name of the worker which activated this job.                                                                                                                                                                                            |
| `Retries`                  | `Int32`                        | The amount of retries left to this job (should always be positive).                                                                                                                                                                         |
| `Deadline`                 | `Int64`                        | When the job can be activated again, sent as a UNIX epoch timestamp.                                                                                                                                                                        |
| `Variables`                | `Object`                       | All variables visible to the task scope, computed at activation time.                                                                                                                                                                       |
| `TenantId`                 | `TenantId`                     | The ID of the tenant that owns the job.                                                                                                                                                                                                     |
| `PhysicalTenantId`         | `String`                       | The ID of the physical tenant that the job-activation request was routed to; the default physical tenant when the request did not specify one.                                                                                              |
| `JobKey`                   | `JobKey`                       | The key, a unique identifier for the job.                                                                                                                                                                                                   |
| `ProcessInstanceKey`       | `ProcessInstanceKey`           | The job's process instance key.                                                                                                                                                                                                             |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey`         | The key of the job's process definition.                                                                                                                                                                                                    |
| `ElementInstanceKey`       | `ElementInstanceKey`           | The element instance key of the task.                                                                                                                                                                                                       |
| `Kind`                     | `JobKindEnum`                  | The job kind.                                                                                                                                                                                                                               |
| `ListenerEventType`        | `JobListenerEventTypeEnum`     | The listener event type of the job.                                                                                                                                                                                                         |
| `UserTask`                 | `UserTaskProperties`           | User task properties, if the job is a user task. This is `null` if the job is not a user task.                                                                                                                                              |
| `Tags`                     | `List<Tag>`                    | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                    |
| `RootProcessInstanceKey`   | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `BusinessId`               | `Nullable<BusinessId>`         | The business ID of the owning process instance, inherited when the job was created. This is `null` for jobs created before version 8.10 and for jobs whose owning process instance has no business ID.                                      |
| `Priority`                 | `Int32`                        | The priority of the job. Higher values indicate higher priority. Jobs created before 8.10 have no stored priority; the API returns 0 for such jobs.                                                                                         |
| `LeaseToken`               | `String`                       | The lease token identifying this activation. This is `null` when the job was activated without a lease.                                                                                                                                     |

## AdHocSubProcessActivateActivitiesInstruction

```csharp
public sealed class AdHocSubProcessActivateActivitiesInstruction
```

| Property                   | Type                                             | Description                                                      |
| -------------------------- | ------------------------------------------------ | ---------------------------------------------------------------- |
| `Elements`                 | `List<AdHocSubProcessActivateActivityReference>` | Activities to activate.                                          |
| `CancelRemainingInstances` | `Nullable<Boolean>`                              | Whether to cancel remaining instances of the ad-hoc sub-process. |

## AdHocSubProcessActivateActivityReference

```csharp
public sealed class AdHocSubProcessActivateActivityReference
```

| Property    | Type        | Description                                      |
| ----------- | ----------- | ------------------------------------------------ |
| `ElementId` | `ElementId` | The ID of the element that should be activated.  |
| `Variables` | `Object`    | Variables to be set when activating the element. |

## AdvancedActorTypeFilter

Advanced AuditLogActorTypeEnum filter.

```csharp
public sealed class AdvancedActorTypeFilter
```

| Property | Type                              | Description                                                                                                                                                                                                                                               |
| -------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogActorTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<AuditLogActorTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`               | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<AuditLogActorTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`            | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedAgentHistoryItemKeyFilter

Advanced AgentHistoryItemKey filter.

```csharp
public sealed class AdvancedAgentHistoryItemKeyFilter
```

| Property | Type                            | Description                                                 |
| -------- | ------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<AgentHistoryItemKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<AgentHistoryItemKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`             | Checks if the current property exists.                      |
| `In`     | `List<AgentHistoryItemKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<AgentHistoryItemKey>`     | Checks if the property matches none of the provided values. |

## AdvancedAgentInstanceHistoryCommitStatusFilter

Advanced AgentInstanceHistoryCommitStatusEnum filter.

```csharp
public sealed class AdvancedAgentInstanceHistoryCommitStatusFilter
```

| Property | Type                                             | Description                                                |
| -------- | ------------------------------------------------ | ---------------------------------------------------------- |
| `Eq`     | `Nullable<AgentInstanceHistoryCommitStatusEnum>` | Checks for equality with the provided value.               |
| `Neq`    | `Nullable<AgentInstanceHistoryCommitStatusEnum>` | Checks for inequality with the provided value.             |
| `Exists` | `Nullable<Boolean>`                              | Checks if the current property exists.                     |
| `In`     | `List<AgentInstanceHistoryCommitStatusEnum>`     | Checks if the property matches any of the provided values. |

## AdvancedAgentInstanceHistoryRoleFilter

Advanced AgentInstanceHistoryRoleEnum filter.

```csharp
public sealed class AdvancedAgentInstanceHistoryRoleFilter
```

| Property | Type                                     | Description                                                |
| -------- | ---------------------------------------- | ---------------------------------------------------------- |
| `Eq`     | `Nullable<AgentInstanceHistoryRoleEnum>` | Checks for equality with the provided value.               |
| `Neq`    | `Nullable<AgentInstanceHistoryRoleEnum>` | Checks for inequality with the provided value.             |
| `Exists` | `Nullable<Boolean>`                      | Checks if the current property exists.                     |
| `In`     | `List<AgentInstanceHistoryRoleEnum>`     | Checks if the property matches any of the provided values. |

## AdvancedAgentInstanceKeyFilter

Advanced AgentInstanceKey filter.

```csharp
public sealed class AdvancedAgentInstanceKeyFilter
```

| Property | Type                         | Description                                                 |
| -------- | ---------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<AgentInstanceKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<AgentInstanceKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`          | Checks if the current property exists.                      |
| `In`     | `List<AgentInstanceKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<AgentInstanceKey>`     | Checks if the property matches none of the provided values. |

## AdvancedAgentInstanceStatusFilter

Advanced AgentInstanceStatusEnum filter.

```csharp
public sealed class AdvancedAgentInstanceStatusFilter
```

| Property | Type                                | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<AgentInstanceStatusEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<AgentInstanceStatusEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<AgentInstanceStatusEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`              | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedAuditLogEntityKeyFilter

Advanced entityKey filter.

```csharp
public sealed class AdvancedAuditLogEntityKeyFilter
```

| Property | Type                          | Description                                                 |
| -------- | ----------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogEntityKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<AuditLogEntityKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`           | Checks if the current property exists.                      |
| `In`     | `List<AuditLogEntityKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<AuditLogEntityKey>`     | Checks if the property matches none of the provided values. |

## AdvancedAuditLogKeyFilter

Advanced AuditLogKey filter.

```csharp
public sealed class AdvancedAuditLogKeyFilter
```

| Property | Type                    | Description                                                 |
| -------- | ----------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<AuditLogKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`     | Checks if the current property exists.                      |
| `In`     | `List<AuditLogKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<AuditLogKey>`     | Checks if the property matches none of the provided values. |

## AdvancedBatchOperationItemStateFilter

Advanced BatchOperationItemStateEnum filter.

```csharp
public sealed class AdvancedBatchOperationItemStateFilter
```

| Property | Type                                    | Description                                                                                                                                                                                                                                               |
| -------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<BatchOperationItemStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<BatchOperationItemStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                     | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<BatchOperationItemStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`                  | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedBatchOperationStateFilter

Advanced BatchOperationStateEnum filter.

```csharp
public sealed class AdvancedBatchOperationStateFilter
```

| Property | Type                                | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<BatchOperationStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<BatchOperationStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<BatchOperationStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`              | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedBatchOperationTypeFilter

Advanced BatchOperationTypeEnum filter.

```csharp
public sealed class AdvancedBatchOperationTypeFilter
```

| Property | Type                               | Description                                                                                                                                                                                                                                               |
| -------- | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<BatchOperationTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<BatchOperationTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<BatchOperationTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`             | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedCategoryFilter

Advanced AuditLogCategoryEnum filter.

```csharp
public sealed class AdvancedCategoryFilter
```

| Property | Type                             | Description                                                                                                                                                                                                                                               |
| -------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogCategoryEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<AuditLogCategoryEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`              | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<AuditLogCategoryEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`           | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedClusterVariableKindFilter

Advanced ClusterVariableKindEnum filter.

```csharp
public sealed class AdvancedClusterVariableKindFilter
```

| Property | Type                                | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<ClusterVariableKindEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<ClusterVariableKindEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<ClusterVariableKindEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`              | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedClusterVariableScopeFilter

Advanced ClusterVariableScopeEnum filter.

```csharp
public sealed class AdvancedClusterVariableScopeFilter
```

| Property | Type                                 | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<ClusterVariableScopeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<ClusterVariableScopeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<ClusterVariableScopeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedDateTimeFilter

Advanced date-time filter.

```csharp
public sealed class AdvancedDateTimeFilter
```

| Property | Type                       | Description                                                |
| -------- | -------------------------- | ---------------------------------------------------------- |
| `Eq`     | `Nullable<DateTimeOffset>` | Checks for equality with the provided value.               |
| `Neq`    | `Nullable<DateTimeOffset>` | Checks for inequality with the provided value.             |
| `Exists` | `Nullable<Boolean>`        | Checks if the current property exists.                     |
| `Gt`     | `Nullable<DateTimeOffset>` | Greater than comparison with the provided value.           |
| `Gte`    | `Nullable<DateTimeOffset>` | Greater than or equal comparison with the provided value.  |
| `Lt`     | `Nullable<DateTimeOffset>` | Lower than comparison with the provided value.             |
| `Lte`    | `Nullable<DateTimeOffset>` | Lower than or equal comparison with the provided value.    |
| `In`     | `List<DateTimeOffset>`     | Checks if the property matches any of the provided values. |

## AdvancedDecisionDefinitionKeyFilter

Advanced DecisionDefinitionKey filter.

```csharp
public sealed class AdvancedDecisionDefinitionKeyFilter
```

| Property | Type                              | Description                                                 |
| -------- | --------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<DecisionDefinitionKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<DecisionDefinitionKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`               | Checks if the current property exists.                      |
| `In`     | `List<DecisionDefinitionKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<DecisionDefinitionKey>`     | Checks if the property matches none of the provided values. |

## AdvancedDecisionEvaluationInstanceKeyFilter

Advanced DecisionEvaluationInstanceKey filter.

```csharp
public sealed class AdvancedDecisionEvaluationInstanceKeyFilter
```

| Property | Type                                      | Description                                                 |
| -------- | ----------------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<DecisionEvaluationInstanceKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<DecisionEvaluationInstanceKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`                       | Checks if the current property exists.                      |
| `In`     | `List<DecisionEvaluationInstanceKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<DecisionEvaluationInstanceKey>`     | Checks if the property matches none of the provided values. |

## AdvancedDecisionEvaluationKeyFilter

Advanced DecisionEvaluationKey filter.

```csharp
public sealed class AdvancedDecisionEvaluationKeyFilter
```

| Property | Type                              | Description                                                 |
| -------- | --------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<DecisionEvaluationKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<DecisionEvaluationKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`               | Checks if the current property exists.                      |
| `In`     | `List<DecisionEvaluationKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<DecisionEvaluationKey>`     | Checks if the property matches none of the provided values. |

## AdvancedDecisionInstanceStateFilter

Advanced DecisionInstanceStateEnum filter.

```csharp
public sealed class AdvancedDecisionInstanceStateFilter
```

| Property | Type                                  | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<DecisionInstanceStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<DecisionInstanceStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                   | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<DecisionInstanceStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`  | `List<DecisionInstanceStateEnum>`     | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`   | `Nullable<LikeFilter>`                | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedDecisionRequirementsKeyFilter

Advanced DecisionRequirementsKey filter.

```csharp
public sealed class AdvancedDecisionRequirementsKeyFilter
```

| Property | Type                                | Description                                                 |
| -------- | ----------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<DecisionRequirementsKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<DecisionRequirementsKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`                 | Checks if the current property exists.                      |
| `In`     | `List<DecisionRequirementsKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<DecisionRequirementsKey>`     | Checks if the property matches none of the provided values. |

## AdvancedDeploymentKeyFilter

Advanced DeploymentKey filter.

```csharp
public sealed class AdvancedDeploymentKeyFilter
```

| Property | Type                      | Description                                                 |
| -------- | ------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<DeploymentKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<DeploymentKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`       | Checks if the current property exists.                      |
| `In`     | `List<DeploymentKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<DeploymentKey>`     | Checks if the property matches none of the provided values. |

## AdvancedElementIdFilter

Advanced ElementId filter.

```csharp
public sealed class AdvancedElementIdFilter
```

| Property | Type                   | Description                                                                                                                                                                                                                                               |
| -------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<ElementId>`  | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<ElementId>`  | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`    | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<ElementId>`      | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`  | `List<ElementId>`      | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`   | `Nullable<LikeFilter>` | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedElementInstanceKeyFilter

Advanced ElementInstanceKey filter.

```csharp
public sealed class AdvancedElementInstanceKeyFilter
```

| Property | Type                           | Description                                                 |
| -------- | ------------------------------ | ----------------------------------------------------------- |
| `Eq`     | `Nullable<ElementInstanceKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<ElementInstanceKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`            | Checks if the current property exists.                      |
| `In`     | `List<ElementInstanceKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<ElementInstanceKey>`     | Checks if the property matches none of the provided values. |

## AdvancedElementInstanceStateFilter

Advanced ElementInstanceStateEnum filter.

```csharp
public sealed class AdvancedElementInstanceStateFilter
```

| Property | Type                                 | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<ElementInstanceStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<ElementInstanceStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<ElementInstanceStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedEntityTypeFilter

Advanced AuditLogEntityTypeEnum filter.

```csharp
public sealed class AdvancedEntityTypeFilter
```

| Property | Type                               | Description                                                                                                                                                                                                                                               |
| -------- | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogEntityTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<AuditLogEntityTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<AuditLogEntityTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`             | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedFormKeyFilter

Advanced FormKey filter.

```csharp
public sealed class AdvancedFormKeyFilter
```

| Property | Type                | Description                                                 |
| -------- | ------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<FormKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<FormKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>` | Checks if the current property exists.                      |
| `In`     | `List<FormKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<FormKey>`     | Checks if the property matches none of the provided values. |

## AdvancedGlobalListenerSourceFilter

Advanced global listener source filter.

```csharp
public sealed class AdvancedGlobalListenerSourceFilter
```

| Property | Type                                 | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<GlobalListenerSourceEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<GlobalListenerSourceEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<GlobalListenerSourceEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedGlobalTaskListenerEventTypeFilter

Advanced global listener event type filter.

```csharp
public sealed class AdvancedGlobalTaskListenerEventTypeFilter
```

| Property | Type                                        | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<GlobalTaskListenerEventTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<GlobalTaskListenerEventTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                         | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<GlobalTaskListenerEventTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`                      | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedIncidentErrorTypeFilter

Advanced IncidentErrorTypeEnum filter

```csharp
public sealed class AdvancedIncidentErrorTypeFilter
```

| Property | Type                              | Description                                                                                                                                                                                                                                               |
| -------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<IncidentErrorTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<IncidentErrorTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`               | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<IncidentErrorTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`  | `List<IncidentErrorTypeEnum>`     | Checks if the property does not match any of the provided values.                                                                                                                                                                                         |
| `Like`   | `Nullable<LikeFilter>`            | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedIncidentStateFilter

Advanced IncidentStateEnum filter

```csharp
public sealed class AdvancedIncidentStateFilter
```

| Property | Type                          | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<IncidentStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<IncidentStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<IncidentStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`  | `List<IncidentStateEnum>`     | Checks if the property does not match any of the provided values.                                                                                                                                                                                         |
| `Like`   | `Nullable<LikeFilter>`        | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedIntegerFilter

Advanced integer (int32) filter.

```csharp
public sealed class AdvancedIntegerFilter
```

| Property | Type                | Description                                                |
| -------- | ------------------- | ---------------------------------------------------------- |
| `Eq`     | `Nullable<Int32>`   | Checks for equality with the provided value.               |
| `Neq`    | `Nullable<Int32>`   | Checks for inequality with the provided value.             |
| `Exists` | `Nullable<Boolean>` | Checks if the current property exists.                     |
| `Gt`     | `Nullable<Int32>`   | Greater than comparison with the provided value.           |
| `Gte`    | `Nullable<Int32>`   | Greater than or equal comparison with the provided value.  |
| `Lt`     | `Nullable<Int32>`   | Lower than comparison with the provided value.             |
| `Lte`    | `Nullable<Int32>`   | Lower than or equal comparison with the provided value.    |
| `In`     | `List<Int32>`       | Checks if the property matches any of the provided values. |

## AdvancedJobKeyFilter

Advanced JobKey filter.

```csharp
public sealed class AdvancedJobKeyFilter
```

| Property | Type                | Description                                                 |
| -------- | ------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<JobKey>`  | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<JobKey>`  | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>` | Checks if the current property exists.                      |
| `In`     | `List<JobKey>`      | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<JobKey>`      | Checks if the property matches none of the provided values. |

## AdvancedJobKindFilter

Advanced JobKindEnum filter.

```csharp
public sealed class AdvancedJobKindFilter
```

| Property | Type                    | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<JobKindEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<JobKindEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`     | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<JobKindEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`  | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedJobListenerEventTypeFilter

Advanced JobListenerEventTypeEnum filter.

```csharp
public sealed class AdvancedJobListenerEventTypeFilter
```

| Property | Type                                 | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<JobListenerEventTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<JobListenerEventTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<JobListenerEventTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedJobStateFilter

Advanced JobStateEnum filter.

```csharp
public sealed class AdvancedJobStateFilter
```

| Property | Type                     | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<JobStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<JobStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`      | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<JobStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`   | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedMessageSubscriptionKeyFilter

Advanced MessageSubscriptionKey filter.

```csharp
public sealed class AdvancedMessageSubscriptionKeyFilter
```

| Property | Type                               | Description                                                 |
| -------- | ---------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<MessageSubscriptionKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<MessageSubscriptionKey>` | Checks for equality with the provided value.                |
| `Exists` | `Nullable<Boolean>`                | Checks if the current property exists.                      |
| `In`     | `List<MessageSubscriptionKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<MessageSubscriptionKey>`     | Checks if the property matches none of the provided values. |

## AdvancedMessageSubscriptionStateFilter

Advanced MessageSubscriptionStateEnum filter

```csharp
public sealed class AdvancedMessageSubscriptionStateFilter
```

| Property | Type                                     | Description                                                                                                                                                                                                                                               |
| -------- | ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<MessageSubscriptionStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<MessageSubscriptionStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                      | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<MessageSubscriptionStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`                   | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedMessageSubscriptionTypeFilter

Advanced MessageSubscriptionTypeEnum filter

```csharp
public sealed class AdvancedMessageSubscriptionTypeFilter
```

| Property | Type                                    | Description                                                                                                                                                                                                                                               |
| -------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<MessageSubscriptionTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<MessageSubscriptionTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                     | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<MessageSubscriptionTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`                  | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedMetadataValueFilter

Advanced filter on a metadata value (string or number).

```csharp
public sealed class AdvancedMetadataValueFilter
```

| Property | Type                   | Description                                                                                                                                                                                                                                               |
| -------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Object`               | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Object`               | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`    | Checks if the metadata key exists.                                                                                                                                                                                                                        |
| `Gt`     | `Nullable<Double>`     | Greater than comparison with the provided value.                                                                                                                                                                                                          |
| `Gte`    | `Nullable<Double>`     | Greater than or equal comparison with the provided value.                                                                                                                                                                                                 |
| `Lt`     | `Nullable<Double>`     | Lower than comparison with the provided value.                                                                                                                                                                                                            |
| `Lte`    | `Nullable<Double>`     | Lower than or equal comparison with the provided value.                                                                                                                                                                                                   |
| `In`     | `List<Object>`         | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>` | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedOperationTypeFilter

Advanced AuditLogOperationTypeEnum filter.

```csharp
public sealed class AdvancedOperationTypeFilter
```

| Property | Type                                  | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogOperationTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<AuditLogOperationTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                   | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<AuditLogOperationTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`                | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedProcessDefinitionIdFilter

Advanced ProcessDefinitionId filter.

```csharp
public sealed class AdvancedProcessDefinitionIdFilter
```

| Property | Type                            | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<ProcessDefinitionId>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<ProcessDefinitionId>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`             | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<ProcessDefinitionId>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`  | `List<ProcessDefinitionId>`     | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`   | `Nullable<LikeFilter>`          | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedProcessDefinitionKeyFilter

Advanced ProcessDefinitionKey filter.

```csharp
public sealed class AdvancedProcessDefinitionKeyFilter
```

| Property | Type                             | Description                                                 |
| -------- | -------------------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<ProcessDefinitionKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<ProcessDefinitionKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`              | Checks if the current property exists.                      |
| `In`     | `List<ProcessDefinitionKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<ProcessDefinitionKey>`     | Checks if the property matches none of the provided values. |

## AdvancedProcessInstanceKeyFilter

Advanced ProcessInstanceKey filter.

```csharp
public sealed class AdvancedProcessInstanceKeyFilter
```

| Property | Type                           | Description                                                 |
| -------- | ------------------------------ | ----------------------------------------------------------- |
| `Eq`     | `Nullable<ProcessInstanceKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<ProcessInstanceKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`            | Checks if the current property exists.                      |
| `In`     | `List<ProcessInstanceKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<ProcessInstanceKey>`     | Checks if the property matches none of the provided values. |

## AdvancedProcessInstanceStateFilter

Advanced ProcessInstanceStateEnum filter.

```csharp
public sealed class AdvancedProcessInstanceStateFilter
```

| Property | Type                                 | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<ProcessInstanceStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<ProcessInstanceStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<ProcessInstanceStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedResourceKeyFilter

Advanced ResourceKey filter.

```csharp
public sealed class AdvancedResourceKeyFilter
```

| Property | Type                    | Description                                                 |
| -------- | ----------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<ResourceKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<ResourceKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`     | Checks if the current property exists.                      |
| `In`     | `List<ResourceKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<ResourceKey>`     | Checks if the property matches none of the provided values. |

## AdvancedResultFilter

Advanced AuditLogResultEnum filter.

```csharp
public sealed class AdvancedResultFilter
```

| Property | Type                           | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<AuditLogResultEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<AuditLogResultEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`            | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<AuditLogResultEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`         | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedScopeKeyFilter

Advanced ScopeKey filter.

```csharp
public sealed class AdvancedScopeKeyFilter
```

| Property | Type                 | Description                                                 |
| -------- | -------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<ScopeKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<ScopeKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`  | Checks if the current property exists.                      |
| `In`     | `List<ScopeKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<ScopeKey>`     | Checks if the property matches none of the provided values. |

## AdvancedStringFilter

Advanced string filter.

```csharp
public sealed class AdvancedStringFilter
```

| Property | Type                   | Description                                                                                                                                                                                                                                               |
| -------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `String`               | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `String`               | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`    | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<String>`         | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`  | `List<String>`         | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`   | `Nullable<LikeFilter>` | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedUserTaskStateFilter

Advanced UserTaskStateEnum filter.

```csharp
public sealed class AdvancedUserTaskStateFilter
```

| Property | Type                          | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<UserTaskStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<UserTaskStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<UserTaskStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`        | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedVariableKeyFilter

Advanced VariableKey filter.

```csharp
public sealed class AdvancedVariableKeyFilter
```

| Property | Type                    | Description                                                 |
| -------- | ----------------------- | ----------------------------------------------------------- |
| `Eq`     | `Nullable<VariableKey>` | Checks for equality with the provided value.                |
| `Neq`    | `Nullable<VariableKey>` | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>`     | Checks if the current property exists.                      |
| `In`     | `List<VariableKey>`     | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<VariableKey>`     | Checks if the property matches none of the provided values. |

## AdvancedWaitStateElementTypeFilter

Advanced element type filter.

```csharp
public sealed class AdvancedWaitStateElementTypeFilter
```

| Property | Type                                 | Description                                                                                                                                                                                                                                               |
| -------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<WaitStateElementTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<WaitStateElementTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<WaitStateElementTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AdvancedWaitStateTypeFilter

Advanced wait state type filter.

```csharp
public sealed class AdvancedWaitStateTypeFilter
```

| Property | Type                          | Description                                                                                                                                                                                                                                               |
| -------- | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Eq`     | `Nullable<WaitStateTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`    | `Nullable<WaitStateTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists` | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`     | `List<WaitStateTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`   | `Nullable<LikeFilter>`        | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AgentHistoryItemKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct AgentHistoryItemKeyExactMatch : ICamundaKey, IEquatable<AgentHistoryItemKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AgentHistoryItemKeyFilterProperty

AgentHistoryItemKey property with full advanced search capabilities.

```csharp
public sealed class AgentHistoryItemKeyFilterProperty
```

| Property     | Type                            | Description                                                                                                                      |
| ------------ | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AgentHistoryItemKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<AgentHistoryItemKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<AgentHistoryItemKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`             | Checks if the current property exists.                                                                                           |
| `In`         | `List<AgentHistoryItemKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<AgentHistoryItemKey>`     | Checks if the property matches none of the provided values.                                                                      |

## AgentInstanceCreationRequest

Request to create a new agent instance.

```csharp
public sealed class AgentInstanceCreationRequest
```

| Property             | Type                      | Description                                                                                                                                                                 |
| -------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ElementInstanceKey` | `ElementInstanceKey`      | The key of the AI Agent Sub-process or AI Agent Task element instance. The engine uses this key to infer processInstanceKey, elementId, processDefinitionKey, and tenantId. |
| `Definition`         | `AgentInstanceDefinition` | Static definition set once at creation.                                                                                                                                     |
| `Limits`             | `AgentInstanceLimits`     | Limits for the agent execution. When omitted, all limits default to -1 (no limit).                                                                                          |

## AgentInstanceCreationResult

Response returned after successfully creating an agent instance.

```csharp
public sealed class AgentInstanceCreationResult
```

| Property           | Type               | Description                                              |
| ------------------ | ------------------ | -------------------------------------------------------- |
| `AgentInstanceKey` | `AgentInstanceKey` | The system-generated key for the created agent instance. |

## AgentInstanceDefinition

The static definition of an agent instance, set once at creation.

```csharp
public sealed class AgentInstanceDefinition
```

| Property       | Type     | Description                                           |
| -------------- | -------- | ----------------------------------------------------- |
| `Model`        | `String` | The LLM model identifier (for example, gpt-4o).       |
| `Provider`     | `String` | The LLM provider (for example, openai or anthropic).  |
| `SystemPrompt` | `String` | The system prompt configured for this agent instance. |

## AgentInstanceDocumentContent

A Camunda Document Store reference content block.

```csharp
public sealed class AgentInstanceDocumentContent : AgentInstanceMessageContent
```

| Property            | Type                | Description                                                     |
| ------------------- | ------------------- | --------------------------------------------------------------- |
| `DocumentReference` | `DocumentReference` | A reference to a document stored in the Camunda Document Store. |

## AgentInstanceFilter

Agent instance search filter.

```csharp
public sealed class AgentInstanceFilter
```

| Property                      | Type                                     | Description                                                                                                                                                                                     |
| ----------------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `AgentInstanceKey`            | `AgentInstanceKeyFilterProperty`         | The unique key of the agent instance.                                                                                                                                                           |
| `Status`                      | `AgentInstanceStatusFilterProperty`      | The current status of the agent instance.                                                                                                                                                       |
| `ElementId`                   | `ElementIdFilterProperty`                | The BPMN element ID of the agent task.                                                                                                                                                          |
| `ProcessInstanceKey`          | `ProcessInstanceKeyFilterProperty`       | The key of the process instance that owns this agent instance.                                                                                                                                  |
| `RootProcessInstanceKey`      | `ProcessInstanceKeyFilterProperty`       | The key of the root process instance. Filters agent instances belonging to a specific call hierarchy. The root process instance is the top-level ancestor in the process instance hierarchy.    |
| `ProcessDefinitionKey`        | `ProcessDefinitionKeyFilterProperty`     | The key of the process definition associated with this agent instance.                                                                                                                          |
| `TenantId`                    | `StringFilterProperty`                   | The tenant ID of the agent instance.                                                                                                                                                            |
| `CreationDate`                | `DateTimeFilterProperty`                 | The creation date of the agent instance.                                                                                                                                                        |
| `LastUpdatedDate`             | `DateTimeFilterProperty`                 | The date the agent instance was last updated.                                                                                                                                                   |
| `CompletionDate`              | `DateTimeFilterProperty`                 | The completion date of the agent instance.                                                                                                                                                      |
| `ElementInstanceKeys`         | `List<ElementInstanceKeyFilterProperty>` | The keys of element instances associated with this agent instance. If multiple keys are provided, the filter matches agent instances associated with all of the provided keys at the same time. |
| `ProcessDefinitionId`         | `StringFilterProperty`                   | The BPMN process ID of the process definition associated with this agent instance.                                                                                                              |
| `ProcessDefinitionVersion`    | `IntegerFilterProperty`                  | The version of the process definition associated with this agent instance.                                                                                                                      |
| `ProcessDefinitionVersionTag` | `StringFilterProperty`                   | The version tag of the process definition associated with this agent instance.                                                                                                                  |

## AgentInstanceHistoryCommitStatusExactMatch

Matches the value exactly.

```csharp
public readonly record struct AgentInstanceHistoryCommitStatusExactMatch : ICamundaKey, IEquatable<AgentInstanceHistoryCommitStatusExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AgentInstanceHistoryCommitStatusFilterProperty

AgentInstanceHistoryCommitStatusEnum property with full advanced search capabilities.

```csharp
public sealed class AgentInstanceHistoryCommitStatusFilterProperty
```

| Property     | Type                                             | Description                                                                                                                      |
| ------------ | ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AgentInstanceHistoryCommitStatusEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<AgentInstanceHistoryCommitStatusEnum>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<AgentInstanceHistoryCommitStatusEnum>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`                              | Checks if the current property exists.                                                                                           |
| `In`         | `List<AgentInstanceHistoryCommitStatusEnum>`     | Checks if the property matches any of the provided values.                                                                       |

## AgentInstanceHistoryFilter

Agent instance history item search filter.

```csharp
public sealed class AgentInstanceHistoryFilter
```

| Property             | Type                                             | Description                                                                                                                                          |
| -------------------- | ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HistoryItemKey`     | `AgentHistoryItemKeyFilterProperty`              | The unique key of the history item.                                                                                                                  |
| `Role`               | `AgentInstanceHistoryRoleFilterProperty`         | The role of the history item.                                                                                                                        |
| `ElementInstanceKey` | `ElementInstanceKeyFilterProperty`               | The key of the element instance under which the history item was produced.                                                                           |
| `JobKey`             | `JobKeyFilterProperty`                           | The key of the job activation that produced the history item.                                                                                        |
| `LoopIteration`      | `IntegerFilterProperty`                          | Filter by loopIteration number. A loopIteration is one pass through the agent feedback loop (one LLM call, its tool dispatches, and their results).  |
| `CommitStatus`       | `AgentInstanceHistoryCommitStatusFilterProperty` | The commit status of the history item. Defaults to COMMITTED only. Include PENDING or DISCARDED explicitly to debug in-flight or failed activations. |
| `ProducedAt`         | `DateTimeFilterProperty`                         | The timestamp when the history item was produced.                                                                                                    |

## AgentInstanceHistoryItemCreationResult

Response returned after successfully appending a history item.

```csharp
public sealed class AgentInstanceHistoryItemCreationResult
```

| Property         | Type                  | Description                                            |
| ---------------- | --------------------- | ------------------------------------------------------ |
| `HistoryItemKey` | `AgentHistoryItemKey` | The system-generated key for the created history item. |

## AgentInstanceHistoryItemMetrics

Per-call token and latency metrics for an ASSISTANT history item.

```csharp
public sealed class AgentInstanceHistoryItemMetrics
```

| Property       | Type              | Description                                                                  |
| -------------- | ----------------- | ---------------------------------------------------------------------------- |
| `InputTokens`  | `Nullable<Int64>` | Input tokens consumed by this LLM call. Null when not provided.              |
| `OutputTokens` | `Nullable<Int64>` | Output tokens produced by this LLM call. Null when not provided.             |
| `DurationMs`   | `Nullable<Int64>` | Wall-clock duration of the LLM call in milliseconds. Null when not provided. |

## AgentInstanceHistoryItemRequest

Request to append a single history item to an agent instance's conversation history.

```csharp
public sealed class AgentInstanceHistoryItemRequest
```

| Property             | Type                                | Description                                                                                                                                                                                                                                                         |
| -------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ElementInstanceKey` | `ElementInstanceKey`                | The key of the currently-active element instance.                                                                                                                                                                                                                   |
| `JobKey`             | `JobKey`                            | The key of the current job activation during which this history item was produced.                                                                                                                                                                                  |
| `JobLease`           | `String`                            | Opaque lease token received from the job activation response.                                                                                                                                                                                                       |
| `LoopIteration`      | `Nullable<LoopIterationId>`         | The loopIteration this item belongs to. A loopIteration is one pass through the agent feedback loop: one LLM call, its tool dispatches, and their results. Omit if not grouping items by loopIteration.                                                             |
| `Role`               | `AgentInstanceHistoryRoleEnum`      | The role of this history item in the conversation.                                                                                                                                                                                                                  |
| `Content`            | `List<AgentInstanceMessageContent>` | The content blocks of this history item.                                                                                                                                                                                                                            |
| `ToolCalls`          | `List<AgentInstanceToolCall>`       | Tool calls associated with this history item. For ASSISTANT items: tool calls dispatched by this LLM response, with arguments populated. For TOOL_RESULT items: single-entry array referencing the originating tool call, with arguments null. Omit for USER items. |
| `Metrics`            | `AgentInstanceHistoryItemMetrics`   | Per-call token and latency metrics. Present on ASSISTANT items only.                                                                                                                                                                                                |
| `ProducedAt`         | `DateTimeOffset`                    | The connector-side timestamp of when this message was produced.                                                                                                                                                                                                     |

## AgentInstanceHistoryItemResult

A single conversation history item belonging to an agent instance.

```csharp
public sealed class AgentInstanceHistoryItemResult
```

| Property             | Type                                   | Description                                                                                                                                                                                                                                                |
| -------------------- | -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HistoryItemKey`     | `AgentHistoryItemKey`                  | The unique key for this history item. Stable and sortable by creation order.                                                                                                                                                                               |
| `AgentInstanceKey`   | `AgentInstanceKey`                     | The key of the agent instance this item belongs to.                                                                                                                                                                                                        |
| `ElementInstanceKey` | `ElementInstanceKey`                   | The key of the AI Agent Task or ad-hoc sub-process element instance under which this item was produced.                                                                                                                                                    |
| `JobKey`             | `JobKey`                               | The key of the job activation during which this item was produced.                                                                                                                                                                                         |
| `JobLease`           | `String`                               | The lease token of the activation that produced this item.                                                                                                                                                                                                 |
| `LoopIteration`      | `Nullable<LoopIterationId>`            | The loopIteration this item belongs to. A loopIteration is one pass through the agent feedback loop: one LLM call, its tool dispatches, and their results. Null if not provided by the connector.                                                          |
| `Role`               | `AgentInstanceHistoryRoleEnum`         | The role of this history item in the conversation.                                                                                                                                                                                                         |
| `Content`            | `List<AgentInstanceMessageContent>`    | The content blocks of this history item.                                                                                                                                                                                                                   |
| `ToolCalls`          | `List<AgentInstanceToolCall>`          | Tool calls for this item. Empty for USER items and ASSISTANT items with no tool dispatches. ASSISTANT items: dispatched tool calls with arguments populated. TOOL_RESULT items: single-entry array referencing the originating tool call (arguments null). |
| `Metrics`            | `AgentInstanceHistoryItemMetrics`      | Per-call token and latency metrics. Null when metrics were not provided at creation time.                                                                                                                                                                  |
| `CommitStatus`       | `AgentInstanceHistoryCommitStatusEnum` | The commit status of this history item.                                                                                                                                                                                                                    |
| `ProducedAt`         | `DateTimeOffset`                       | The connector-side timestamp of when this message was produced.                                                                                                                                                                                            |

## AgentInstanceHistoryRoleExactMatch

Matches the value exactly.

```csharp
public readonly record struct AgentInstanceHistoryRoleExactMatch : ICamundaKey, IEquatable<AgentInstanceHistoryRoleExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AgentInstanceHistoryRoleFilterProperty

AgentInstanceHistoryRoleEnum property with full advanced search capabilities.

```csharp
public sealed class AgentInstanceHistoryRoleFilterProperty
```

| Property     | Type                                     | Description                                                                                                                      |
| ------------ | ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AgentInstanceHistoryRoleEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<AgentInstanceHistoryRoleEnum>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<AgentInstanceHistoryRoleEnum>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`                      | Checks if the current property exists.                                                                                           |
| `In`         | `List<AgentInstanceHistoryRoleEnum>`     | Checks if the property matches any of the provided values.                                                                       |

## AgentInstanceHistorySearchQuery

Agent instance history search request.

```csharp
public sealed class AgentInstanceHistorySearchQuery
```

| Property | Type                                               | Description                      |
| -------- | -------------------------------------------------- | -------------------------------- |
| `Sort`   | `List<AgentInstanceHistorySearchQuerySortRequest>` | Sort field criteria.             |
| `Filter` | `AgentInstanceHistoryFilter`                       | The history item search filters. |
| `Page`   | `SearchQueryPageRequest`                           | Pagination criteria.             |

## AgentInstanceHistorySearchQueryResult

Agent instance history search response.

```csharp
public sealed class AgentInstanceHistorySearchQueryResult
```

| Property | Type                                   | Description                                      |
| -------- | -------------------------------------- | ------------------------------------------------ |
| `Items`  | `List<AgentInstanceHistoryItemResult>` | The matching history items.                      |
| `Page`   | `SearchQueryPageResponse`              | Pagination information about the search results. |

## AgentInstanceHistorySearchQuerySortRequest

```csharp
public sealed class AgentInstanceHistorySearchQuerySortRequest
```

| Property | Type                                              | Description                                   |
| -------- | ------------------------------------------------- | --------------------------------------------- |
| `Field`  | `AgentInstanceHistorySearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                         | The order in which to sort the related field. |

## AgentInstanceKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct AgentInstanceKeyExactMatch : ICamundaKey, IEquatable<AgentInstanceKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AgentInstanceKeyFilterProperty

AgentInstanceKey property with full advanced search capabilities.

```csharp
public sealed class AgentInstanceKeyFilterProperty
```

| Property     | Type                         | Description                                                                                                                      |
| ------------ | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AgentInstanceKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<AgentInstanceKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<AgentInstanceKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`          | Checks if the current property exists.                                                                                           |
| `In`         | `List<AgentInstanceKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<AgentInstanceKey>`     | Checks if the property matches none of the provided values.                                                                      |

## AgentInstanceLimits

The configured limits for an agent instance, set once at creation.

```csharp
public sealed class AgentInstanceLimits
```

| Property        | Type    | Description                                                 |
| --------------- | ------- | ----------------------------------------------------------- |
| `MaxModelCalls` | `Int32` | Maximum LLM calls allowed. -1 if no limit is configured.    |
| `MaxToolCalls`  | `Int32` | Maximum tool calls allowed. -1 if no limit is configured.   |
| `MaxTokens`     | `Int64` | Maximum total tokens allowed. -1 if no limit is configured. |

## AgentInstanceMessageContent

A single content block within a history item. Discriminated by `contentType`.

```csharp
public abstract class AgentInstanceMessageContent
```

## AgentInstanceMetrics

Aggregated metrics for an agent instance across all model calls.

```csharp
public sealed class AgentInstanceMetrics
```

| Property       | Type    | Description                                          |
| -------------- | ------- | ---------------------------------------------------- |
| `InputTokens`  | `Int64` | Total input tokens consumed across all model calls.  |
| `OutputTokens` | `Int64` | Total output tokens produced across all model calls. |
| `ModelCalls`   | `Int32` | Total number of LLM calls made.                      |
| `ToolCalls`    | `Int32` | Total number of tool calls made.                     |

## AgentInstanceMetricsDelta

Metric increments to apply to the agent instance aggregate counters. The engine accumulates these deltas into running totals on each UPDATED event. All fields are optional; omit a field to leave the corresponding counter unchanged.

```csharp
public sealed class AgentInstanceMetricsDelta
```

| Property       | Type              | Description                                           |
| -------------- | ----------------- | ----------------------------------------------------- |
| `InputTokens`  | `Nullable<Int64>` | Increment to apply to the total input token counter.  |
| `OutputTokens` | `Nullable<Int64>` | Increment to apply to the total output token counter. |
| `ModelCalls`   | `Nullable<Int32>` | Increment to apply to the total model call counter.   |
| `ToolCalls`    | `Nullable<Int32>` | Increment to apply to the total tool call counter.    |

## AgentInstanceObjectContent

An arbitrary structured content block. Accepts any valid JSON value: objects, arrays, numbers, booleans, or strings. Use TEXT content for human-readable natural language; use OBJECT content for machine-readable structured data.

```csharp
public sealed class AgentInstanceObjectContent : AgentInstanceMessageContent
```

| Property | Type     | Description                                                                                      |
| -------- | -------- | ------------------------------------------------------------------------------------------------ |
| `Object` | `Object` | Arbitrary structured content — any valid JSON value (object, array, number, boolean, or string). |

## AgentInstanceResult

```csharp
public sealed class AgentInstanceResult
```

| Property                      | Type                       | Description                                                                                                                  |
| ----------------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `AgentInstanceKey`            | `AgentInstanceKey`         | The unique key for this agent instance.                                                                                      |
| `Status`                      | `AgentInstanceStatusEnum`  | The current status of an agent instance.                                                                                     |
| `Definition`                  | `AgentInstanceDefinition`  | The static definition of the agent, including model, provider, and system prompt.                                            |
| `Metrics`                     | `AgentInstanceMetrics`     | Aggregated metrics across all loopIterations of this agent instance.                                                         |
| `Limits`                      | `AgentInstanceLimits`      | The configured limits for this agent instance, set once at creation.                                                         |
| `Tools`                       | `List<AgentTool>`          | The tools available to the agent.                                                                                            |
| `ElementId`                   | `ElementId`                | The BPMN element ID of the ad-hoc sub-process or AI agent task that owns this agent instance.                                |
| `ProcessInstanceKey`          | `ProcessInstanceKey`       | The key of the process instance that owns this agent instance.                                                               |
| `RootProcessInstanceKey`      | `ProcessInstanceKey`       | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. |
| `ProcessDefinitionKey`        | `ProcessDefinitionKey`     | The key of the process definition associated with this agent instance.                                                       |
| `ProcessDefinitionId`         | `ProcessDefinitionId`      | The BPMN process ID of the process definition associated with this agent instance.                                           |
| `ProcessDefinitionVersion`    | `Int32`                    | The version of the process definition associated with this agent instance.                                                   |
| `ProcessDefinitionVersionTag` | `String`                   | The version tag of the process definition associated with this agent instance.                                               |
| `TenantId`                    | `TenantId`                 | The tenant ID of this agent instance.                                                                                        |
| `CreationDate`                | `DateTimeOffset`           | The date when this agent instance was created.                                                                               |
| `LastUpdatedDate`             | `DateTimeOffset`           | The date when this agent instance was last updated.                                                                          |
| `CompletionDate`              | `Nullable<DateTimeOffset>` | The date when this agent instance completed. Null while the agent is still running.                                          |
| `ElementInstanceKeys`         | `List<ElementInstanceKey>` | The keys of all element instances associated with this agent instance.                                                       |

## AgentInstanceSearchQuery

Agent instance search request.

```csharp
public sealed class AgentInstanceSearchQuery
```

| Property | Type                                        | Description                        |
| -------- | ------------------------------------------- | ---------------------------------- |
| `Sort`   | `List<AgentInstanceSearchQuerySortRequest>` | Sort field criteria.               |
| `Filter` | `AgentInstanceFilter`                       | The agent instance search filters. |
| `Page`   | `SearchQueryPageRequest`                    | Pagination criteria.               |

## AgentInstanceSearchQueryResult

Agent instance search response.

```csharp
public sealed class AgentInstanceSearchQueryResult
```

| Property | Type                        | Description                                      |
| -------- | --------------------------- | ------------------------------------------------ |
| `Items`  | `List<AgentInstanceResult>` | The matching agent instances.                    |
| `Page`   | `SearchQueryPageResponse`   | Pagination information about the search results. |

## AgentInstanceSearchQuerySortRequest

```csharp
public sealed class AgentInstanceSearchQuerySortRequest
```

| Property | Type                                       | Description                                   |
| -------- | ------------------------------------------ | --------------------------------------------- |
| `Field`  | `AgentInstanceSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                  | The order in which to sort the related field. |

## AgentInstanceStatusExactMatch

Matches the value exactly.

```csharp
public readonly record struct AgentInstanceStatusExactMatch : ICamundaKey, IEquatable<AgentInstanceStatusExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AgentInstanceStatusFilterProperty

AgentInstanceStatusEnum property with full advanced search capabilities.

```csharp
public sealed class AgentInstanceStatusFilterProperty
```

| Property     | Type                                | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AgentInstanceStatusEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<AgentInstanceStatusEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<AgentInstanceStatusEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<AgentInstanceStatusEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`              | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AgentInstanceTextContent

A plain-text content block.

```csharp
public sealed class AgentInstanceTextContent : AgentInstanceMessageContent
```

| Property | Type     | Description       |
| -------- | -------- | ----------------- |
| `Text`   | `String` | The text content. |

## AgentInstanceToolCall

A tool call associated with a history item. Used in both ASSISTANT and TOOL_RESULT items. ASSISTANT items carry arguments; TOOL_RESULT items carry arguments as null.

```csharp
public sealed class AgentInstanceToolCall
```

| Property     | Type     | Description                                                                                    |
| ------------ | -------- | ---------------------------------------------------------------------------------------------- |
| `ToolCallId` | `String` | The LLM-assigned tool call ID. Correlates ASSISTANT items to their matching TOOL_RESULT items. |
| `ToolName`   | `String` | The LLM-visible tool name.                                                                     |
| `ElementId`  | `String` | The BPMN element ID handling this tool.                                                        |
| `Arguments`  | `Object` | The tool call arguments as provided by the LLM. Null on TOOL_RESULT items.                     |

## AgentInstanceUpdateRequest

Request to update the mutable state of an agent instance.

```csharp
public sealed class AgentInstanceUpdateRequest
```

| Property             | Type                                      | Description                                                                                                                                                                                                                                                                                                                                                               |
| -------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ElementInstanceKey` | `ElementInstanceKey`                      | The key of the currently-active element instance for this agent instance. Used for ownership/equality validation against the stored agent instance and, when the supplied key differs from the previous association (re-entry of an ad-hoc sub-process or AI Agent task), appended to elementInstanceKeys with the reverse link updated on the supplied element instance. |
| `Status`             | `Nullable<AgentInstanceUpdateStatusEnum>` | The new status of the agent instance.                                                                                                                                                                                                                                                                                                                                     |
| `Metrics`            | `AgentInstanceMetricsDelta`               | Metric increments to apply to the aggregate counters.                                                                                                                                                                                                                                                                                                                     |
| `Tools`              | `List<AgentTool>`                         | The complete list of tools available to the agent, replacing any previously stored tools. When provided, the engine replaces the existing tool list with this value.                                                                                                                                                                                                      |

## AgentTool

A tool available to the agent.

```csharp
public sealed class AgentTool
```

| Property      | Type     | Description                                                            |
| ------------- | -------- | ---------------------------------------------------------------------- |
| `Name`        | `String` | The tool name as visible to the LLM.                                   |
| `Description` | `String` | A human-readable description of the tool.                              |
| `ElementId`   | `String` | The BPMN element ID of the tool element within the ad-hoc sub-process. |

## AncestorScopeInstruction

Defines the ancestor scope for the created element instances. The default behavior resembles a "direct" scope instruction with an `ancestorElementInstanceKey` of `"-1"`.

```csharp
public abstract class AncestorScopeInstruction
```

## AuditLogActorTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct AuditLogActorTypeExactMatch : ICamundaKey, IEquatable<AuditLogActorTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AuditLogActorTypeFilterProperty

AuditLogActorTypeEnum property with full advanced search capabilities.

```csharp
public sealed class AuditLogActorTypeFilterProperty
```

| Property     | Type                              | Description                                                                                                                                                                                                                                               |
| ------------ | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogActorTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<AuditLogActorTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<AuditLogActorTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`               | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<AuditLogActorTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`            | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AuditLogEntityKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct AuditLogEntityKeyExactMatch : ICamundaKey, IEquatable<AuditLogEntityKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AuditLogEntityKeyFilterProperty

EntityKey property with full advanced search capabilities.

```csharp
public sealed class AuditLogEntityKeyFilterProperty
```

| Property     | Type                          | Description                                                                                                                      |
| ------------ | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogEntityKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<AuditLogEntityKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<AuditLogEntityKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                           |
| `In`         | `List<AuditLogEntityKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<AuditLogEntityKey>`     | Checks if the property matches none of the provided values.                                                                      |

## AuditLogFilter

Audit log filter request

```csharp
public sealed class AuditLogFilter
```

| Property                  | Type                                    | Description                                        |
| ------------------------- | --------------------------------------- | -------------------------------------------------- |
| `AuditLogKey`             | `AuditLogKeyFilterProperty`             | The audit log key search filter.                   |
| `ProcessDefinitionKey`    | `ProcessDefinitionKeyFilterProperty`    | The process definition key search filter.          |
| `ProcessInstanceKey`      | `ProcessInstanceKeyFilterProperty`      | The process instance key search filter.            |
| `ElementInstanceKey`      | `ElementInstanceKeyFilterProperty`      | The element instance key search filter.            |
| `OperationType`           | `OperationTypeFilterProperty`           | The operation type search filter.                  |
| `Result`                  | `AuditLogResultFilterProperty`          | The result search filter.                          |
| `Timestamp`               | `DateTimeFilterProperty`                | The timestamp search filter.                       |
| `ActorId`                 | `StringFilterProperty`                  | The actor ID search filter.                        |
| `ActorType`               | `AuditLogActorTypeFilterProperty`       | The actor type search filter.                      |
| `AgentElementId`          | `StringFilterProperty`                  | The agent element ID search filter.                |
| `EntityKey`               | `AuditLogEntityKeyFilterProperty`       | The entity key search filter.                      |
| `EntityType`              | `EntityTypeFilterProperty`              | The entity type search filter.                     |
| `TenantId`                | `StringFilterProperty`                  | The tenant ID search filter.                       |
| `Category`                | `CategoryFilterProperty`                | The category search filter.                        |
| `DeploymentKey`           | `DeploymentKeyFilterProperty`           | The deployment key search filter.                  |
| `FormKey`                 | `FormKeyFilterProperty`                 | The form key search filter.                        |
| `ResourceKey`             | `ResourceKeyFilterProperty`             | The resource key search filter.                    |
| `BatchOperationType`      | `BatchOperationTypeFilterProperty`      | The batch operation type search filter.            |
| `ProcessDefinitionId`     | `StringFilterProperty`                  | The process definition ID search filter.           |
| `JobKey`                  | `JobKeyFilterProperty`                  | The job key search filter.                         |
| `UserTaskKey`             | `BasicStringFilterProperty`             | The user task key search filter.                   |
| `DecisionRequirementsId`  | `StringFilterProperty`                  | The decision requirements ID search filter.        |
| `DecisionRequirementsKey` | `DecisionRequirementsKeyFilterProperty` | The decision requirements key search filter.       |
| `DecisionDefinitionId`    | `StringFilterProperty`                  | The decision definition ID search filter.          |
| `DecisionDefinitionKey`   | `DecisionDefinitionKeyFilterProperty`   | The decision definition key search filter.         |
| `DecisionEvaluationKey`   | `DecisionEvaluationKeyFilterProperty`   | The decision evaluation key search filter.         |
| `RelatedEntityKey`        | `AuditLogEntityKeyFilterProperty`       | The related entity key search filter.              |
| `RelatedEntityType`       | `EntityTypeFilterProperty`              | The related entity type search filter.             |
| `EntityDescription`       | `StringFilterProperty`                  | The entity description filter.                     |
| `InboundChannelType`      | `StringFilterProperty`                  | The inbound channel type search filter (e.g. MCP). |
| `InboundChannelToolName`  | `StringFilterProperty`                  | The inbound channel tool name search filter.       |

## AuditLogKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct AuditLogKeyExactMatch : ICamundaKey, IEquatable<AuditLogKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AuditLogKeyFilterProperty

AuditLogKey property with full advanced search capabilities.

```csharp
public sealed class AuditLogKeyFilterProperty
```

| Property     | Type                    | Description                                                                                                                      |
| ------------ | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<AuditLogKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<AuditLogKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`     | Checks if the current property exists.                                                                                           |
| `In`         | `List<AuditLogKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<AuditLogKey>`     | Checks if the property matches none of the provided values.                                                                      |

## AuditLogResult

Audit log item.

```csharp
public sealed class AuditLogResult
```

| Property                  | Type                                | Description                                                                                                                                                                                                                                 |
| ------------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `AuditLogKey`             | `AuditLogKey`                       | The unique key of the audit log entry.                                                                                                                                                                                                      |
| `EntityKey`               | `AuditLogEntityKey`                 | System-generated entity key for an audit log entry.                                                                                                                                                                                         |
| `EntityType`              | `AuditLogEntityTypeEnum`            | The type of entity affected by the operation.                                                                                                                                                                                               |
| `OperationType`           | `AuditLogOperationTypeEnum`         | The type of operation performed.                                                                                                                                                                                                            |
| `BatchOperationKey`       | `Nullable<BatchOperationKey>`       | Key of the batch operation.                                                                                                                                                                                                                 |
| `BatchOperationType`      | `Nullable<BatchOperationTypeEnum>`  | The type of batch operation performed, if this is part of a batch.                                                                                                                                                                          |
| `Timestamp`               | `DateTimeOffset`                    | The timestamp when the operation occurred.                                                                                                                                                                                                  |
| `ActorId`                 | `String`                            | The ID of the actor who performed the operation.                                                                                                                                                                                            |
| `ActorType`               | `Nullable<AuditLogActorTypeEnum>`   | The type of the actor who performed the operation.                                                                                                                                                                                          |
| `AgentElementId`          | `String`                            | The element ID of the agent that performed the operation (e.g. ad-hoc subprocess element ID).                                                                                                                                               |
| `TenantId`                | `Nullable<TenantId>`                | The tenant ID of the audit log.                                                                                                                                                                                                             |
| `Result`                  | `AuditLogResultEnum`                | The result status of the operation.                                                                                                                                                                                                         |
| `Category`                | `AuditLogCategoryEnum`              | The category of the audit log operation.                                                                                                                                                                                                    |
| `ProcessDefinitionId`     | `Nullable<ProcessDefinitionId>`     | The process definition ID.                                                                                                                                                                                                                  |
| `ProcessDefinitionKey`    | `Nullable<ProcessDefinitionKey>`    | The key of the process definition.                                                                                                                                                                                                          |
| `ProcessInstanceKey`      | `Nullable<ProcessInstanceKey>`      | The key of the process instance.                                                                                                                                                                                                            |
| `RootProcessInstanceKey`  | `Nullable<ProcessInstanceKey>`      | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `ElementInstanceKey`      | `Nullable<ElementInstanceKey>`      | The key of the element instance.                                                                                                                                                                                                            |
| `JobKey`                  | `Nullable<JobKey>`                  | The key of the job.                                                                                                                                                                                                                         |
| `UserTaskKey`             | `Nullable<UserTaskKey>`             | The key of the user task.                                                                                                                                                                                                                   |
| `DecisionRequirementsId`  | `String`                            | The decision requirements ID.                                                                                                                                                                                                               |
| `DecisionRequirementsKey` | `Nullable<DecisionRequirementsKey>` | The assigned key of the decision requirements.                                                                                                                                                                                              |
| `DecisionDefinitionId`    | `Nullable<DecisionDefinitionId>`    | The decision definition ID.                                                                                                                                                                                                                 |
| `DecisionDefinitionKey`   | `Nullable<DecisionDefinitionKey>`   | The key of the decision definition.                                                                                                                                                                                                         |
| `DecisionEvaluationKey`   | `Nullable<DecisionEvaluationKey>`   | The key of the decision evaluation.                                                                                                                                                                                                         |
| `DeploymentKey`           | `Nullable<DeploymentKey>`           | The key of the deployment.                                                                                                                                                                                                                  |
| `FormKey`                 | `Nullable<FormKey>`                 | The key of the form.                                                                                                                                                                                                                        |
| `ResourceKey`             | `Nullable<ResourceKey>`             | The system-assigned key for this resource.                                                                                                                                                                                                  |
| `RelatedEntityKey`        | `Nullable<AuditLogEntityKey>`       | The key of the related entity. The content depends on the operation type and entity type. For example, for authorization operations, this will contain the ID of the owner (e.g., user or group) the authorization belongs to.              |
| `RelatedEntityType`       | `Nullable<AuditLogEntityTypeEnum>`  | The type of the related entity. The content depends on the operation type and entity type. For example, for authorization operations, this will contain the type of the owner (e.g., USER or GROUP) the authorization belongs to.           |
| `EntityDescription`       | `String`                            | Additional description of the entity affected by the operation. For example, for variable operations, this will contain the variable name.                                                                                                  |
| `InboundChannelType`      | `String`                            | The type of the inbound channel that triggered the operation (e.g. MCP).                                                                                                                                                                    |
| `InboundChannelToolName`  | `String`                            | The tool name of the inbound channel (e.g. the MCP tool that triggered the operation).                                                                                                                                                      |

## AuditLogResultExactMatch

Matches the value exactly.

```csharp
public readonly record struct AuditLogResultExactMatch : ICamundaKey, IEquatable<AuditLogResultExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## AuditLogResultFilterProperty

AuditLogResultEnum property with full advanced search capabilities.

```csharp
public sealed class AuditLogResultFilterProperty
```

| Property     | Type                           | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogResultEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<AuditLogResultEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<AuditLogResultEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`            | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<AuditLogResultEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`         | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## AuditLogSearchQueryRequest

Audit log search request.

```csharp
public sealed class AuditLogSearchQueryRequest
```

| Property | Type                                   | Description                   |
| -------- | -------------------------------------- | ----------------------------- |
| `Sort`   | `List<AuditLogSearchQuerySortRequest>` | Sort field criteria.          |
| `Filter` | `AuditLogFilter`                       | The audit log search filters. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria.          |

## AuditLogSearchQueryResult

Audit log search response.

```csharp
public sealed class AuditLogSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<AuditLogResult>`    | The matching audit logs.                         |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## AuditLogSearchQuerySortRequest

```csharp
public sealed class AuditLogSearchQuerySortRequest
```

| Property | Type                                  | Description                                   |
| -------- | ------------------------------------- | --------------------------------------------- |
| `Field`  | `AuditLogSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`             | The order in which to sort the related field. |

## AuthenticationConfigurationResponse

Configuration for authentication and session management.

```csharp
public sealed class AuthenticationConfigurationResponse
```

| Property           | Type      | Description                                                  |
| ------------------ | --------- | ------------------------------------------------------------ |
| `CanLogout`        | `Boolean` | Whether users can log out (false for SaaS deployments).      |
| `IsLoginDelegated` | `Boolean` | Whether login is delegated to an external identity provider. |

## AuthorizationCreateResult

```csharp
public sealed class AuthorizationCreateResult
```

| Property           | Type               | Description                           |
| ------------------ | ------------------ | ------------------------------------- |
| `AuthorizationKey` | `AuthorizationKey` | The key of the created authorization. |

## AuthorizationFilter

Authorization search filter.

```csharp
public sealed class AuthorizationFilter
```

| Property                | Type                         | Description                                                     |
| ----------------------- | ---------------------------- | --------------------------------------------------------------- |
| `OwnerId`               | `String`                     | The ID of the owner of permissions.                             |
| `OwnerType`             | `Nullable<OwnerTypeEnum>`    | The type of the owner of permissions.                           |
| `ResourceIds`           | `List<String>`               | The IDs of the resource to search permissions for.              |
| `ResourcePropertyNames` | `List<String>`               | The names of the resource properties to search permissions for. |
| `ResourceType`          | `Nullable<ResourceTypeEnum>` | The type of resource to search permissions for.                 |

## AuthorizationIdBasedRequest

```csharp
public sealed class AuthorizationIdBasedRequest : AuthorizationRequest
```

| Property          | Type                       | Description                                   |
| ----------------- | -------------------------- | --------------------------------------------- |
| `OwnerId`         | `String`                   | The ID of the owner of the permissions.       |
| `OwnerType`       | `OwnerTypeEnum`            | The type of the owner of permissions.         |
| `ResourceId`      | `String`                   | The ID of the resource to add permissions to. |
| `ResourceType`    | `ResourceTypeEnum`         | The type of resource to add permissions to.   |
| `PermissionTypes` | `List<PermissionTypeEnum>` | The permission types to add.                  |

## AuthorizationPropertyBasedRequest

```csharp
public sealed class AuthorizationPropertyBasedRequest : AuthorizationRequest
```

| Property               | Type                       | Description                                                             |
| ---------------------- | -------------------------- | ----------------------------------------------------------------------- |
| `OwnerId`              | `String`                   | The ID of the owner of the permissions.                                 |
| `OwnerType`            | `OwnerTypeEnum`            | The type of the owner of permissions.                                   |
| `ResourcePropertyName` | `String`                   | The name of the resource property on which this authorization is based. |
| `ResourceType`         | `ResourceTypeEnum`         | The type of resource to add permissions to.                             |
| `PermissionTypes`      | `List<PermissionTypeEnum>` | The permission types to add.                                            |

## AuthorizationRequest

Defines an authorization request.

Either an id-based or a property-based authorization can be provided.

```csharp
public abstract class AuthorizationRequest
```

## AuthorizationResult

```csharp
public sealed class AuthorizationResult
```

| Property               | Type                       | Description                                                                                         |
| ---------------------- | -------------------------- | --------------------------------------------------------------------------------------------------- |
| `OwnerId`              | `String`                   | The ID of the owner of permissions.                                                                 |
| `OwnerType`            | `OwnerTypeEnum`            | The type of the owner of permissions.                                                               |
| `ResourceType`         | `ResourceTypeEnum`         | The type of resource that the permissions relate to.                                                |
| `ResourceId`           | `String`                   | ID of the resource the permission relates to (mutually exclusive with `resourcePropertyName`).      |
| `ResourcePropertyName` | `String`                   | The name of the resource property the permission relates to (mutually exclusive with `resourceId`). |
| `PermissionTypes`      | `List<PermissionTypeEnum>` | Specifies the types of the permissions.                                                             |
| `AuthorizationKey`     | `AuthorizationKey`         | The key of the authorization.                                                                       |

## AuthorizationSearchQuery

```csharp
public sealed class AuthorizationSearchQuery
```

| Property | Type                                        | Description                       |
| -------- | ------------------------------------------- | --------------------------------- |
| `Sort`   | `List<AuthorizationSearchQuerySortRequest>` | Sort field criteria.              |
| `Filter` | `AuthorizationFilter`                       | The authorization search filters. |
| `Page`   | `SearchQueryPageRequest`                    | Pagination criteria.              |

## AuthorizationSearchQuerySortRequest

```csharp
public sealed class AuthorizationSearchQuerySortRequest
```

| Property | Type                                       | Description                                   |
| -------- | ------------------------------------------ | --------------------------------------------- |
| `Field`  | `AuthorizationSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                  | The order in which to sort the related field. |

## AuthorizationSearchResult

```csharp
public sealed class AuthorizationSearchResult
```

| Property | Type                        | Description                                      |
| -------- | --------------------------- | ------------------------------------------------ |
| `Items`  | `List<AuthorizationResult>` | The matching authorizations.                     |
| `Page`   | `SearchQueryPageResponse`   | Pagination information about the search results. |

## BackpressureState

```csharp
public sealed class BackpressureState
```

| Property      | Type              | Description |
| ------------- | ----------------- | ----------- |
| `Severity`    | `String`          |             |
| `PermitsMax`  | `Nullable<Int32>` |             |
| `Consecutive` | `Int32`           |             |

## BaseProcessInstanceFilterFields

Base process instance search filter.

```csharp
public sealed class BaseProcessInstanceFilterFields
```

| Property                     | Type                                 | Description                                                                                                                                                                                                                              |
| ---------------------------- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `StartDate`                  | `DateTimeFilterProperty`             | The start date.                                                                                                                                                                                                                          |
| `EndDate`                    | `DateTimeFilterProperty`             | The end date.                                                                                                                                                                                                                            |
| `State`                      | `ProcessInstanceStateFilterProperty` | The process instance state.                                                                                                                                                                                                              |
| `HasIncident`                | `Nullable<Boolean>`                  | Whether this process instance has a related incident or not.                                                                                                                                                                             |
| `TenantId`                   | `StringFilterProperty`               | The tenant id.                                                                                                                                                                                                                           |
| `Variables`                  | `List<VariableValueFilterProperty>`  | The process instance variables.                                                                                                                                                                                                          |
| `ProcessInstanceKey`         | `ProcessInstanceKeyFilterProperty`   | The key of this process instance.                                                                                                                                                                                                        |
| `ParentProcessInstanceKey`   | `ProcessInstanceKeyFilterProperty`   | The parent process instance key.                                                                                                                                                                                                         |
| `ParentElementInstanceKey`   | `ElementInstanceKeyFilterProperty`   | The parent element instance key.                                                                                                                                                                                                         |
| `BatchOperationId`           | `StringFilterProperty`               | The batch operation id. **Deprecated**: Use `batchOperationKey` instead. This field will be removed in a future release. If both `batchOperationId` and `batchOperationKey` are provided, the request will be rejected with a 400 error. |
| `BatchOperationKey`          | `StringFilterProperty`               | The batch operation key.                                                                                                                                                                                                                 |
| `ErrorMessage`               | `StringFilterProperty`               | The error message related to the process.                                                                                                                                                                                                |
| `HasRetriesLeft`             | `Nullable<Boolean>`                  | Whether the process has failed jobs with retries left.                                                                                                                                                                                   |
| `ElementInstanceState`       | `ElementInstanceStateFilterProperty` | The state of the element instances associated with the process instance.                                                                                                                                                                 |
| `ElementId`                  | `StringFilterProperty`               | The element id associated with the process instance.                                                                                                                                                                                     |
| `HasElementInstanceIncident` | `Nullable<Boolean>`                  | Whether the element instance has an incident or not.                                                                                                                                                                                     |
| `IncidentErrorHashCode`      | `IntegerFilterProperty`              | The incident error hash code, associated with this process.                                                                                                                                                                              |
| `Tags`                       | `List<Tag>`                          | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                 |
| `BusinessId`                 | `StringFilterProperty`               | The business id associated with the process instance.                                                                                                                                                                                    |

## BasicStringFilter

Basic advanced string filter.

```csharp
public sealed class BasicStringFilter
```

| Property | Type                | Description                                                 |
| -------- | ------------------- | ----------------------------------------------------------- |
| `Eq`     | `String`            | Checks for equality with the provided value.                |
| `Neq`    | `String`            | Checks for inequality with the provided value.              |
| `Exists` | `Nullable<Boolean>` | Checks if the current property exists.                      |
| `In`     | `List<String>`      | Checks if the property matches any of the provided values.  |
| `NotIn`  | `List<String>`      | Checks if the property matches none of the provided values. |

## BasicStringFilterProperty

String property with basic advanced search capabilities.

```csharp
public sealed class BasicStringFilterProperty
```

| Property     | Type                | Description                                                                                                                      |
| ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `String`            | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `String`            | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `String`            | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>` | Checks if the current property exists.                                                                                           |
| `In`         | `List<String>`      | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<String>`      | Checks if the property matches none of the provided values.                                                                      |

## BatchOperationCreatedResult

The created batch operation.

```csharp
public sealed class BatchOperationCreatedResult
```

| Property             | Type                     | Description                      |
| -------------------- | ------------------------ | -------------------------------- |
| `BatchOperationKey`  | `BatchOperationKey`      | Key of the batch operation.      |
| `BatchOperationType` | `BatchOperationTypeEnum` | The type of the batch operation. |

## BatchOperationError

```csharp
public sealed class BatchOperationError
```

| Property      | Type                      | Description                                                     |
| ------------- | ------------------------- | --------------------------------------------------------------- |
| `PartitionId` | `Int32`                   | The partition ID where the error occurred.                      |
| `Type`        | `BatchOperationErrorType` | The type of the error that occurred during the batch operation. |
| `Message`     | `String`                  | The error message that occurred during the batch operation.     |

## BatchOperationFilter

Batch operation filter request.

```csharp
public sealed class BatchOperationFilter
```

| Property            | Type                                | Description                                            |
| ------------------- | ----------------------------------- | ------------------------------------------------------ |
| `BatchOperationKey` | `BasicStringFilterProperty`         | The key (or operate legacy ID) of the batch operation. |
| `OperationType`     | `BatchOperationTypeFilterProperty`  | The type of the batch operation.                       |
| `State`             | `BatchOperationStateFilterProperty` | The state of the batch operation.                      |
| `ActorType`         | `Nullable<AuditLogActorTypeEnum>`   | The type of the actor who performed the operation.     |
| `ActorId`           | `StringFilterProperty`              | The ID of the actor who performed the operation.       |

## BatchOperationItemFilter

Batch operation item filter request.

```csharp
public sealed class BatchOperationItemFilter
```

| Property             | Type                               | Description                                            |
| -------------------- | ---------------------------------- | ------------------------------------------------------ |
| `BatchOperationKey`  | `BasicStringFilterProperty`        | The key (or operate legacy ID) of the batch operation. |
| `ItemKey`            | `BasicStringFilterProperty`        | The key of the item, e.g. a process instance key.      |
| `ProcessInstanceKey` | `ProcessInstanceKeyFilterProperty` | The process instance key of the processed item.        |
| `State`              | `String`                           | The state of the batch operation.                      |
| `OperationType`      | `BatchOperationTypeFilterProperty` | The type of the batch operation.                       |

## BatchOperationItemResponse

```csharp
public sealed class BatchOperationItemResponse
```

| Property                 | Type                              | Description                                                                                                                                                                                                                                 |
| ------------------------ | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OperationType`          | `BatchOperationTypeEnum`          | The type of the batch operation.                                                                                                                                                                                                            |
| `BatchOperationKey`      | `BatchOperationKey`               | The key (or operate legacy ID) of the batch operation.                                                                                                                                                                                      |
| `ItemKey`                | `String`                          | Key of the item, e.g. a process instance key.                                                                                                                                                                                               |
| `ProcessInstanceKey`     | `Nullable<ProcessInstanceKey>`    | The process instance key of the processed item. Null for batch-op types whose targets are not process instances (e.g. DELETE_DECISION_INSTANCE, DELETE_DECISION_DEFINITION, DELETE_PROCESS_DEFINITION).                                     |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>`    | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `State`                  | `BatchOperationItemResponseState` | State of the item.                                                                                                                                                                                                                          |
| `ProcessedDate`          | `Nullable<DateTimeOffset>`        | The date this item was processed. This is `null` if the item has not yet been processed.                                                                                                                                                    |
| `ErrorMessage`           | `String`                          | The error message from the engine in case of a failed operation.                                                                                                                                                                            |

## BatchOperationItemSearchQuery

Batch operation item search request.

```csharp
public sealed class BatchOperationItemSearchQuery
```

| Property | Type                                             | Description                              |
| -------- | ------------------------------------------------ | ---------------------------------------- |
| `Sort`   | `List<BatchOperationItemSearchQuerySortRequest>` | Sort field criteria.                     |
| `Filter` | `BatchOperationItemFilter`                       | The batch operation item search filters. |
| `Page`   | `SearchQueryPageRequest`                         | Pagination criteria.                     |

## BatchOperationItemSearchQueryResult

```csharp
public sealed class BatchOperationItemSearchQueryResult
```

| Property | Type                               | Description                                      |
| -------- | ---------------------------------- | ------------------------------------------------ |
| `Items`  | `List<BatchOperationItemResponse>` | The matching batch operation items.              |
| `Page`   | `SearchQueryPageResponse`          | Pagination information about the search results. |

## BatchOperationItemSearchQuerySortRequest

```csharp
public sealed class BatchOperationItemSearchQuerySortRequest
```

| Property | Type                                            | Description                                   |
| -------- | ----------------------------------------------- | --------------------------------------------- |
| `Field`  | `BatchOperationItemSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                       | The order in which to sort the related field. |

## BatchOperationItemStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct BatchOperationItemStateExactMatch : ICamundaKey, IEquatable<BatchOperationItemStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## BatchOperationItemStateFilterProperty

BatchOperationItemStateEnum property with full advanced search capabilities.

```csharp
public sealed class BatchOperationItemStateFilterProperty
```

| Property     | Type                                    | Description                                                                                                                                                                                                                                               |
| ------------ | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<BatchOperationItemStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<BatchOperationItemStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<BatchOperationItemStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                     | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<BatchOperationItemStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`                  | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## BatchOperationResponse

```csharp
public sealed class BatchOperationResponse
```

| Property                   | Type                              | Description                                                                                                                                                    |
| -------------------------- | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `BatchOperationKey`        | `BatchOperationKey`               | Key or (Operate Legacy ID = UUID) of the batch operation.                                                                                                      |
| `State`                    | `BatchOperationStateEnum`         | The batch operation state.                                                                                                                                     |
| `BatchOperationType`       | `BatchOperationTypeEnum`          | The type of the batch operation.                                                                                                                               |
| `StartDate`                | `Nullable<DateTimeOffset>`        | The start date of the batch operation. This is `null` if the batch operation has not yet started.                                                              |
| `EndDate`                  | `Nullable<DateTimeOffset>`        | The end date of the batch operation. This is `null` if the batch operation is still running.                                                                   |
| `ActorType`                | `Nullable<AuditLogActorTypeEnum>` | The type of the actor who performed the operation. This is `null` if the batch operation was created before 8.9, or if the actor information is not available. |
| `ActorId`                  | `String`                          | The ID of the actor who performed the operation. Available for batch operations created since 8.9.                                                             |
| `OperationsTotalCount`     | `Int32`                           | The total number of items contained in this batch operation.                                                                                                   |
| `OperationsFailedCount`    | `Int32`                           | The number of items which failed during execution of the batch operation. (e.g. because they are rejected by the Zeebe engine).                                |
| `OperationsCompletedCount` | `Int32`                           | The number of successfully completed tasks.                                                                                                                    |
| `Errors`                   | `List<BatchOperationError>`       | The errors that occurred per partition during the batch operation.                                                                                             |

## BatchOperationSearchQuery

Batch operation search request.

```csharp
public sealed class BatchOperationSearchQuery
```

| Property | Type                                         | Description                         |
| -------- | -------------------------------------------- | ----------------------------------- |
| `Sort`   | `List<BatchOperationSearchQuerySortRequest>` | Sort field criteria.                |
| `Filter` | `BatchOperationFilter`                       | The batch operation search filters. |
| `Page`   | `SearchQueryPageRequest`                     | Pagination criteria.                |

## BatchOperationSearchQueryResult

The batch operation search query result.

```csharp
public sealed class BatchOperationSearchQueryResult
```

| Property | Type                           | Description                                      |
| -------- | ------------------------------ | ------------------------------------------------ |
| `Items`  | `List<BatchOperationResponse>` | The matching batch operations.                   |
| `Page`   | `SearchQueryPageResponse`      | Pagination information about the search results. |

## BatchOperationSearchQuerySortRequest

```csharp
public sealed class BatchOperationSearchQuerySortRequest
```

| Property | Type                                        | Description                                   |
| -------- | ------------------------------------------- | --------------------------------------------- |
| `Field`  | `BatchOperationSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                   | The order in which to sort the related field. |

## BatchOperationStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct BatchOperationStateExactMatch : ICamundaKey, IEquatable<BatchOperationStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## BatchOperationStateFilterProperty

BatchOperationStateEnum property with full advanced search capabilities.

```csharp
public sealed class BatchOperationStateFilterProperty
```

| Property     | Type                                | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<BatchOperationStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<BatchOperationStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<BatchOperationStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<BatchOperationStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`              | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## BatchOperationTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct BatchOperationTypeExactMatch : ICamundaKey, IEquatable<BatchOperationTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## BatchOperationTypeFilterProperty

BatchOperationTypeEnum property with full advanced search capabilities.

```csharp
public sealed class BatchOperationTypeFilterProperty
```

| Property     | Type                               | Description                                                                                                                                                                                                                                               |
| ------------ | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<BatchOperationTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<BatchOperationTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<BatchOperationTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<BatchOperationTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`             | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## BpmnErrorException

Throw from a job handler to trigger a BPMN error boundary event on the job's task. The error code is matched against error catch events in the process model.

```csharp
public sealed class BpmnErrorException : Exception, ISerializable
```

| Property       | Type     | Description                                               |
| -------------- | -------- | --------------------------------------------------------- |
| `ErrorCode`    | `String` | The error code matched against BPMN error catch events.   |
| `ErrorMessage` | `String` | Optional additional context message.                      |
| `Variables`    | `Object` | Optional variables to set at the error catch event scope. |

## BrokerInfo

Provides information on a broker node.

```csharp
public sealed class BrokerInfo
```

| Property     | Type              | Description                                                                                                                                                                                                                                                                                                                                                                               |
| ------------ | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `NodeId`     | `Int32`           | The node ID for the broker. The uniqueness of this identifier depends if the cluster is zone-aware or not. - non zone-aware: (default) nodeId is unique across the cluster - zone-aware: (opt-in) nodeId is unique only within its zone. If you are migrating to a zone aware cluster, you must use `brokerId` instead. This property is deprecated, as it's been replaced by `brokerId`. |
| `BrokerId`   | `String`          | The unique (within a cluster) broker identifier. When the cluster is not zoned, then it's a string that represents the nodeId (an integer). When the cluster is zoned, instead, it's of the form "$zoneName_$nodeId", providing uniqueness even across zones.                                                                                                                             |
| `Host`       | `String`          | The hostname for reaching the broker.                                                                                                                                                                                                                                                                                                                                                     |
| `Port`       | `Int32`           | The port for reaching the broker.                                                                                                                                                                                                                                                                                                                                                         |
| `Partitions` | `List<Partition>` | A list of partitions managed or replicated on this broker.                                                                                                                                                                                                                                                                                                                                |
| `Version`    | `String`          | The broker version.                                                                                                                                                                                                                                                                                                                                                                       |

## BusinessId

An optional, user-defined string identifier that identifies the process instance within the scope of a process definition (scoped by tenant). If provided and uniqueness enforcement is enabled, the engine will reject creation if another root process instance with the same business id is already active for the same process definition. Note that any active child process instances with the same business id are not taken into account.

```csharp
public readonly record struct BusinessId : ICamundaKey, IEquatable<BusinessId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## CamundaAuthException

Authentication-specific exception.

```csharp
public sealed class CamundaAuthException : Exception, ISerializable
```

| Property | Type                   | Description |
| -------- | ---------------------- | ----------- |
| `Code`   | `CamundaAuthErrorCode` |             |

## CamundaConfigurationException

Thrown when configuration hydration encounters validation errors.

```csharp
public sealed class CamundaConfigurationException : Exception, ISerializable
```

| Property | Type                               | Description |
| -------- | ---------------------------------- | ----------- |
| `Errors` | `IReadOnlyList<ConfigErrorDetail>` |             |

## CamundaKeyJsonConverterFactory

JSON converter factory that handles any `ICamundaKey` struct. Serializes as a plain JSON string; deserializes by calling the static AssumeExists factory.

```csharp
public sealed class CamundaKeyJsonConverterFactory : JsonConverterFactory
```

## CamundaKeyValidation

Validation helpers for domain key constraints.

```csharp
public static class CamundaKeyValidation
```

## CamundaLongKeyJsonConverterFactory

JSON converter factory that handles any `ICamundaLongKey` struct. Serializes as a JSON number; deserializes by calling the static AssumeExists factory.

```csharp
public sealed class CamundaLongKeyJsonConverterFactory : JsonConverterFactory
```

## CamundaSdkException

SDK error types mirroring the JS SDK's error structure.

```csharp
public class CamundaSdkException : Exception, ISerializable
```

| Property      | Type              | Description |
| ------------- | ----------------- | ----------- |
| `OperationId` | `String`          |             |
| `Status`      | `Nullable<Int32>` |             |

## CamundaUserResult

```csharp
public sealed class CamundaUserResult
```

| Property               | Type                         | Description                                                   |
| ---------------------- | ---------------------------- | ------------------------------------------------------------- |
| `Username`             | `Username`                   | The username of the user.                                     |
| `DisplayName`          | `String`                     | The display name of the user.                                 |
| `Email`                | `String`                     | The email of the user.                                        |
| `AuthorizedComponents` | `List<String>`               | The web components the user is authorized to use.             |
| `Tenants`              | `List<TenantResult>`         | The tenants the user is a member of.                          |
| `Groups`               | `List<String>`               | The groups assigned to the user.                              |
| `Roles`                | `List<String>`               | The roles assigned to the user.                               |
| `SalesPlanType`        | `String`                     | The plan of the user.                                         |
| `C8Links`              | `Dictionary<String, String>` | The links to the components in the C8 stack.                  |
| `CanLogout`            | `Boolean`                    | Flag for understanding if the user is able to perform logout. |

## CancelProcessInstanceRequest

```csharp
public sealed class CancelProcessInstanceRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## CancelSdkException

Thrown when a cancellable operation is cancelled.

```csharp
public sealed class CancelSdkException : CamundaSdkException, ISerializable
```

## CategoryExactMatch

Matches the value exactly.

```csharp
public readonly record struct CategoryExactMatch : ICamundaKey, IEquatable<CategoryExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## CategoryFilterProperty

AuditLogCategoryEnum property with full advanced search capabilities.

```csharp
public sealed class CategoryFilterProperty
```

| Property     | Type                             | Description                                                                                                                                                                                                                                               |
| ------------ | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogCategoryEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<AuditLogCategoryEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<AuditLogCategoryEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`              | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<AuditLogCategoryEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`           | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## Changeset

JSON object with changed task attribute values.

The following attributes can be adjusted with this endpoint, additional attributes will be ignored:

- `candidateGroups` - reset by providing an empty list
- `candidateUsers` - reset by providing an empty list
- `dueDate` - reset by providing an empty String
- `followUpDate` - reset by providing an empty String
- `priority` - minimum 0, maximum 100, default 50

Providing any of those attributes with a `null` value or omitting it preserves the persisted attribute's value.

The assignee cannot be adjusted with this endpoint, use the Assign task endpoint. This ensures correct event emission for assignee changes.

```csharp
public sealed class Changeset
```

| Property          | Type                       | Description                                                                 |
| ----------------- | -------------------------- | --------------------------------------------------------------------------- |
| `DueDate`         | `Nullable<DateTimeOffset>` | The due date of the task. Reset by providing an empty String.               |
| `FollowUpDate`    | `Nullable<DateTimeOffset>` | The follow-up date of the task. Reset by providing an empty String.         |
| `CandidateUsers`  | `List<String>`             | The list of candidate users of the task. Reset by providing an empty list.  |
| `CandidateGroups` | `List<String>`             | The list of candidate groups of the task. Reset by providing an empty list. |
| `Priority`        | `Nullable<Int32>`          | The priority of the task.                                                   |

## ClientId

The unique identifier of an OAuth client.

Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed with OIDC by the external identity provider (e.g. EntraID, Keycloak, Okta). In Self-Managed with Basic authentication, machine-to-machine applications are modelled as users instead — see the user identifier.

```csharp
public readonly record struct ClientId : ICamundaKey, IEquatable<ClientId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ClockPinRequest

```csharp
public sealed class ClockPinRequest
```

| Property    | Type    | Description                                                               |
| ----------- | ------- | ------------------------------------------------------------------------- |
| `Timestamp` | `Int64` | The exact time in epoch milliseconds to which the clock should be pinned. |

## CloudConfigurationResponse

Configuration for SaaS/cloud-specific settings.

```csharp
public sealed class CloudConfigurationResponse
```

| Property | Type     | Description                 |
| -------- | -------- | --------------------------- |
| `Stage`  | `String` | The cloud deployment stage. |

## ClusterModeChangeOperation

A single operation that is part of a cluster mode change.

```csharp
public sealed class ClusterModeChangeOperation
```

| Property    | Type     | Description                                      |
| ----------- | -------- | ------------------------------------------------ |
| `Operation` | `String` | The type of the operation.                       |
| `Mode`      | `String` | The target mode of the operation, if applicable. |

## ClusterModeChangeResponse

The planned changes resulting from a cluster mode transition request.

```csharp
public sealed class ClusterModeChangeResponse
```

| Property         | Type                               | Description                                                                 |
| ---------------- | ---------------------------------- | --------------------------------------------------------------------------- |
| `ChangeId`       | `String`                           | The ID of the cluster change that was triggered by the request.             |
| `PlannedChanges` | `List<ClusterModeChangeOperation>` | The ordered list of operations that will be applied to complete the change. |

## ClusterVariableKindExactMatch

Matches the value exactly.

```csharp
public readonly record struct ClusterVariableKindExactMatch : ICamundaKey, IEquatable<ClusterVariableKindExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ClusterVariableKindFilterProperty

ClusterVariableKindEnum property with full advanced search capabilities.

```csharp
public sealed class ClusterVariableKindFilterProperty
```

| Property     | Type                                | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ClusterVariableKindEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<ClusterVariableKindEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<ClusterVariableKindEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<ClusterVariableKindEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`              | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## ClusterVariableName

The name of a cluster variable. Unique within its scope (global or tenant-specific).

```csharp
public readonly record struct ClusterVariableName : ICamundaKey, IEquatable<ClusterVariableName>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ClusterVariableResult

```csharp
public sealed class ClusterVariableResult
```

| Property   | Type                         | Description                                                                                                                                                              |
| ---------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Value`    | `String`                     | Full value of this cluster variable.                                                                                                                                     |
| `Name`     | `ClusterVariableName`        | The name of the cluster variable. Unique within its scope (global or tenant-specific).                                                                                   |
| `Scope`    | `ClusterVariableScopeEnum`   | The scope of a cluster variable.                                                                                                                                         |
| `TenantId` | `String`                     | Only provided if the cluster variable scope is TENANT. Null for global scope variables.                                                                                  |
| `Metadata` | `Dictionary<String, Object>` | A generic key-value metadata bag attached to the cluster variable. Values are strings or numbers.                                                                        |
| `Kind`     | `ClusterVariableKindEnum`    | The kind of a cluster variable. JSON is the default. SECRET_REFERENCE allows the value to contain camunda.secrets.X references that are resolved at job activation time. |

## ClusterVariableResultBase

Cluster variable response item.

```csharp
public sealed class ClusterVariableResultBase
```

| Property   | Type                         | Description                                                                                                                                                              |
| ---------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Name`     | `ClusterVariableName`        | The name of the cluster variable. Unique within its scope (global or tenant-specific).                                                                                   |
| `Scope`    | `ClusterVariableScopeEnum`   | The scope of a cluster variable.                                                                                                                                         |
| `TenantId` | `String`                     | Only provided if the cluster variable scope is TENANT. Null for global scope variables.                                                                                  |
| `Metadata` | `Dictionary<String, Object>` | A generic key-value metadata bag attached to the cluster variable. Values are strings or numbers.                                                                        |
| `Kind`     | `ClusterVariableKindEnum`    | The kind of a cluster variable. JSON is the default. SECRET_REFERENCE allows the value to contain camunda.secrets.X references that are resolved at job activation time. |

## ClusterVariableScopeExactMatch

Matches the value exactly.

```csharp
public readonly record struct ClusterVariableScopeExactMatch : ICamundaKey, IEquatable<ClusterVariableScopeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ClusterVariableScopeFilterProperty

ClusterVariableScopeEnum property with full advanced search capabilities.

```csharp
public sealed class ClusterVariableScopeFilterProperty
```

| Property     | Type                                 | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ClusterVariableScopeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<ClusterVariableScopeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<ClusterVariableScopeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<ClusterVariableScopeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## ClusterVariableSearchQueryFilterRequest

Cluster variable filter request.

```csharp
public sealed class ClusterVariableSearchQueryFilterRequest
```

| Property      | Type                                              | Description                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Name`        | `StringFilterProperty`                            | Name of the cluster variable.                                                                                                                                                                                                                                                                                                                                                        |
| `Value`       | `StringFilterProperty`                            | The value of the cluster variable.                                                                                                                                                                                                                                                                                                                                                   |
| `Scope`       | `ClusterVariableScopeFilterProperty`              | The scope filter for cluster variables.                                                                                                                                                                                                                                                                                                                                              |
| `TenantId`    | `StringFilterProperty`                            | Tenant ID of this variable.                                                                                                                                                                                                                                                                                                                                                          |
| `IsTruncated` | `Nullable<Boolean>`                               | Filter cluster variables by truncation status of their stored values. When true, returns only variables whose stored values are truncated (i.e., the value exceeds the storage size limit and is truncated in storage). When false, returns only variables with non-truncated stored values. This filter is based on the underlying storage characteristic, not the response format. |
| `Metadata`    | `Dictionary<String, AdvancedMetadataValueFilter>` | Filter by metadata entries. A map of metadata key to an advanced filter on that key's value. Metadata values are strings or numbers.                                                                                                                                                                                                                                                 |
| `Kind`        | `ClusterVariableKindFilterProperty`               | The kind filter for cluster variables.                                                                                                                                                                                                                                                                                                                                               |

## ClusterVariableSearchQueryRequest

Cluster variable search query request.

```csharp
public sealed class ClusterVariableSearchQueryRequest
```

| Property | Type                                          | Description                          |
| -------- | --------------------------------------------- | ------------------------------------ |
| `Sort`   | `List<ClusterVariableSearchQuerySortRequest>` | Sort field criteria.                 |
| `Filter` | `ClusterVariableSearchQueryFilterRequest`     | The cluster variable search filters. |
| `Page`   | `SearchQueryPageRequest`                      | Pagination criteria.                 |

## ClusterVariableSearchQueryResult

Cluster variable search query response.

```csharp
public sealed class ClusterVariableSearchQueryResult
```

| Property | Type                                | Description                                      |
| -------- | ----------------------------------- | ------------------------------------------------ |
| `Items`  | `List<ClusterVariableSearchResult>` | The matching cluster variables.                  |
| `Page`   | `SearchQueryPageResponse`           | Pagination information about the search results. |

## ClusterVariableSearchQuerySortRequest

```csharp
public sealed class ClusterVariableSearchQuerySortRequest
```

| Property | Type                                         | Description                                   |
| -------- | -------------------------------------------- | --------------------------------------------- |
| `Field`  | `ClusterVariableSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                    | The order in which to sort the related field. |

## ClusterVariableSearchResult

Cluster variable search response item.

```csharp
public sealed class ClusterVariableSearchResult
```

| Property      | Type                         | Description                                                                                                                                                              |
| ------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Value`       | `String`                     | Value of this cluster variable. Can be truncated.                                                                                                                        |
| `IsTruncated` | `Boolean`                    | Whether the value is truncated or not.                                                                                                                                   |
| `Name`        | `ClusterVariableName`        | The name of the cluster variable. Unique within its scope (global or tenant-specific).                                                                                   |
| `Scope`       | `ClusterVariableScopeEnum`   | The scope of a cluster variable.                                                                                                                                         |
| `TenantId`    | `String`                     | Only provided if the cluster variable scope is TENANT. Null for global scope variables.                                                                                  |
| `Metadata`    | `Dictionary<String, Object>` | A generic key-value metadata bag attached to the cluster variable. Values are strings or numbers.                                                                        |
| `Kind`        | `ClusterVariableKindEnum`    | The kind of a cluster variable. JSON is the default. SECRET_REFERENCE allows the value to contain camunda.secrets.X references that are resolved at job activation time. |

## ComponentsConfigurationResponse

Configuration for active Camunda components in the deployment.

```csharp
public sealed class ComponentsConfigurationResponse
```

| Property | Type                    | Description                                                       |
| -------- | ----------------------- | ----------------------------------------------------------------- |
| `Active` | `List<WebappComponent>` | List of webapp components whose UI is enabled in this deployment. |

## ConditionWaitStateDetails

```csharp
public sealed class ConditionWaitStateDetails : WaitStateDetails
```

| Property     | Type           | Description                                                                       |
| ------------ | -------------- | --------------------------------------------------------------------------------- |
| `Expression` | `String`       | The condition expression that must evaluate to true to proceed.                   |
| `Events`     | `List<String>` | The variable events that trigger condition re-evaluation. Empty means all events. |

## ConditionalEvaluationInstruction

```csharp
public sealed class ConditionalEvaluationInstruction : ITenantIdSettable
```

| Property               | Type                             | Description                                                                                                                                                                                         |
| ---------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `TenantId`             | `Nullable<TenantId>`             | Used to evaluate root-level conditional start events for a tenant with the given ID. This will only evaluate root-level conditional start events of process definitions which belong to the tenant. |
| `ProcessDefinitionKey` | `Nullable<ProcessDefinitionKey>` | Used to evaluate root-level conditional start events of the process definition with the given key.                                                                                                  |
| `Variables`            | `Object`                         | JSON object representing the variables to use for evaluation of the conditions and to pass to the process instances that have been triggered.                                                       |

## ConsistencyOptions<T>

Options for eventual consistency polling behavior.

```csharp
public sealed class ConsistencyOptions<T>
```

| Property         | Type                 | Description                                                                                                                                        |
| ---------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `WaitUpToMs`     | `Int32`              | Maximum time to wait for the data to become consistent, in milliseconds. Set to 0 to skip eventual consistency handling.                           |
| `PollIntervalMs` | `Int32`              | Poll interval in milliseconds (default: 500).                                                                                                      |
| `IsConsistent`   | `Func<<T>, Boolean>` | Optional predicate: when true, the response is considered consistent. If not set, any non-null response with items (where applicable) is accepted. |

## CorrelatedMessageSubscriptionFilter

Correlated message subscriptions search filter.

```csharp
public sealed class CorrelatedMessageSubscriptionFilter
```

| Property               | Type                                   | Description                                                                                                                                                                                                                                                                                                                                     |
| ---------------------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `BusinessId`           | `StringFilterProperty`                 | Filter by the business id stored on the correlated message subscription — for message start event correlations the correlating message's business id, and for catch, boundary, or intermediate event correlations the subscribing process instance's business id. Supports advanced string filtering, including `$like` with `*`/`?` wildcards. |
| `CorrelationKey`       | `StringFilterProperty`                 | The correlation key of the message.                                                                                                                                                                                                                                                                                                             |
| `CorrelationTime`      | `DateTimeFilterProperty`               | The time when the message was correlated.                                                                                                                                                                                                                                                                                                       |
| `ElementId`            | `StringFilterProperty`                 | The element ID that received the message.                                                                                                                                                                                                                                                                                                       |
| `ElementInstanceKey`   | `ElementInstanceKeyFilterProperty`     | The element instance key that received the message.                                                                                                                                                                                                                                                                                             |
| `MessageKey`           | `BasicStringFilterProperty`            | The message key.                                                                                                                                                                                                                                                                                                                                |
| `MessageName`          | `StringFilterProperty`                 | The name of the message.                                                                                                                                                                                                                                                                                                                        |
| `PartitionId`          | `IntegerFilterProperty`                | The partition ID that correlated the message.                                                                                                                                                                                                                                                                                                   |
| `ProcessDefinitionId`  | `StringFilterProperty`                 | The process definition ID associated with this correlated message subscription.                                                                                                                                                                                                                                                                 |
| `ProcessDefinitionKey` | `ProcessDefinitionKeyFilterProperty`   | The process definition key associated with this correlated message subscription. For intermediate message events, this only works for data created with 8.9 and later.                                                                                                                                                                          |
| `ProcessInstanceKey`   | `ProcessInstanceKeyFilterProperty`     | The process instance key associated with this correlated message subscription.                                                                                                                                                                                                                                                                  |
| `SubscriptionKey`      | `MessageSubscriptionKeyFilterProperty` | The subscription key that received the message.                                                                                                                                                                                                                                                                                                 |
| `TenantId`             | `StringFilterProperty`                 | The tenant ID associated with this correlated message subscription.                                                                                                                                                                                                                                                                             |

## CorrelatedMessageSubscriptionResult

```csharp
public sealed class CorrelatedMessageSubscriptionResult
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------ | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `BusinessId`             | `Nullable<BusinessId>`         | The business id associated with this correlated message subscription. For a message start event correlation, it is the business id carried by the correlating message that was stamped on the started process instance to enforce its uniqueness. For a catch, boundary, or intermediate event correlation, it is the business id of the subscribing process instance, captured when the subscription was opened. It is `null` when the relevant process instance has no business id. |
| `CorrelationKey`         | `String`                       | The correlation key of the message.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `CorrelationTime`        | `DateTimeOffset`               | The time when the message was correlated.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `ElementId`              | `String`                       | The element ID that received the message.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `ElementInstanceKey`     | `Nullable<ElementInstanceKey>` | The element instance key that received the message. It is `null` for start event subscriptions.                                                                                                                                                                                                                                                                                                                                                                                       |
| `MessageKey`             | `MessageKey`                   | The message key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `MessageName`            | `String`                       | The name of the message.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `PartitionId`            | `Int32`                        | The partition ID that correlated the message.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `ProcessDefinitionId`    | `ProcessDefinitionId`          | The process definition ID associated with this correlated message subscription.                                                                                                                                                                                                                                                                                                                                                                                                       |
| `ProcessDefinitionKey`   | `ProcessDefinitionKey`         | The process definition key associated with this correlated message subscription.                                                                                                                                                                                                                                                                                                                                                                                                      |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The process instance key associated with this correlated message subscription.                                                                                                                                                                                                                                                                                                                                                                                                        |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                                                                                                                                                                                                                           |
| `SubscriptionKey`        | `MessageSubscriptionKey`       | The subscription key that received the message.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `TenantId`               | `TenantId`                     | The tenant ID associated with this correlated message subscription.                                                                                                                                                                                                                                                                                                                                                                                                                   |

## CorrelatedMessageSubscriptionSearchQuery

```csharp
public sealed class CorrelatedMessageSubscriptionSearchQuery
```

| Property | Type                                                        | Description                                          |
| -------- | ----------------------------------------------------------- | ---------------------------------------------------- |
| `Sort`   | `List<CorrelatedMessageSubscriptionSearchQuerySortRequest>` | Sort field criteria.                                 |
| `Filter` | `CorrelatedMessageSubscriptionFilter`                       | The correlated message subscriptions search filters. |
| `Page`   | `SearchQueryPageRequest`                                    | Pagination criteria.                                 |

## CorrelatedMessageSubscriptionSearchQueryResult

```csharp
public sealed class CorrelatedMessageSubscriptionSearchQueryResult
```

| Property | Type                                        | Description                                      |
| -------- | ------------------------------------------- | ------------------------------------------------ |
| `Items`  | `List<CorrelatedMessageSubscriptionResult>` | The matching correlated message subscriptions.   |
| `Page`   | `SearchQueryPageResponse`                   | Pagination information about the search results. |

## CorrelatedMessageSubscriptionSearchQuerySortRequest

```csharp
public sealed class CorrelatedMessageSubscriptionSearchQuerySortRequest
```

| Property | Type                                                       | Description                                   |
| -------- | ---------------------------------------------------------- | --------------------------------------------- |
| `Field`  | `CorrelatedMessageSubscriptionSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                                  | The order in which to sort the related field. |

## CreateClusterVariableRequest

```csharp
public sealed class CreateClusterVariableRequest
```

| Property   | Type                                | Description                                                                                                                                                                                                                                                                                             |
| ---------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`     | `ClusterVariableName`               | The name of the cluster variable. Must be unique within its scope (global or tenant-specific).                                                                                                                                                                                                          |
| `Value`    | `Object`                            | The value of the cluster variable. Can be any JSON object or primitive value. Will be serialized as a JSON string in responses.                                                                                                                                                                         |
| `Metadata` | `Dictionary<String, Object>`        | A generic key-value metadata bag attached to the cluster variable. Values must be strings or numbers. Limited to 100 entries and a configurable maximum serialized size (default: 100 entries at max key length of a cluster variable name (256 chars) plus the maximum value length, 8192 characters). |
| `Kind`     | `Nullable<ClusterVariableKindEnum>` | The kind of the cluster variable. Defaults to JSON if not specified.                                                                                                                                                                                                                                    |

## CreateGlobalTaskListenerRequest

```csharp
public sealed class CreateGlobalTaskListenerRequest
```

| Property         | Type                                    | Description                                                                                                     |
| ---------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `Id`             | `GlobalListenerId`                      | The user-defined id for the global listener                                                                     |
| `EventTypes`     | `List<GlobalTaskListenerEventTypeEnum>` | List of user task event types that trigger the listener.                                                        |
| `Type`           | `String`                                | The name of the job type, used as a reference to specify which job workers request the respective listener job. |
| `Retries`        | `Nullable<Int32>`                       | Number of retries for the listener job.                                                                         |
| `AfterNonGlobal` | `Nullable<Boolean>`                     | Whether the listener should run after model-level listeners.                                                    |
| `Priority`       | `Nullable<Int32>`                       | The priority of the listener. Higher priority listeners are executed before lower priority ones.                |

## CreateProcessInstanceResult

```csharp
public sealed class CreateProcessInstanceResult
```

| Property                   | Type                   | Description                                                                                                                                            |
| -------------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ProcessDefinitionId`      | `ProcessDefinitionId`  | The BPMN process id of the process definition which was used to create the process. instance                                                           |
| `ProcessDefinitionVersion` | `Int32`                | The version of the process definition which was used to create the process instance.                                                                   |
| `TenantId`                 | `TenantId`             | The tenant id of the created process instance.                                                                                                         |
| `Variables`                | `Object`               | All the variables visible in the root scope.                                                                                                           |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey` | The key of the process definition which was used to create the process instance.                                                                       |
| `ProcessInstanceKey`       | `ProcessInstanceKey`   | The unique identifier of the created process instance; to be used wherever a request needs a process instance key (e.g. CancelProcessInstanceRequest). |
| `Tags`                     | `List<Tag>`            | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                               |
| `BusinessId`               | `Nullable<BusinessId>` | Business id as provided on creation.                                                                                                                   |

## CursorBackwardPagination

```csharp
public sealed class CursorBackwardPagination : SearchQueryPageRequest
```

| Property | Type                    | Description                                                                                   |
| -------- | ----------------------- | --------------------------------------------------------------------------------------------- |
| `Before` | `Nullable<StartCursor>` | Use the `startCursor` value from the previous response to fetch the previous page of results. |
| `Limit`  | `Nullable<Int32>`       | The maximum number of items to return in one request.                                         |

## CursorForwardPagination

```csharp
public sealed class CursorForwardPagination : SearchQueryPageRequest
```

| Property | Type                  | Description                                                                             |
| -------- | --------------------- | --------------------------------------------------------------------------------------- |
| `After`  | `Nullable<EndCursor>` | Use the `endCursor` value from the previous response to fetch the next page of results. |
| `Limit`  | `Nullable<Int32>`     | The maximum number of items to return in one request.                                   |

## DateTimeFilterProperty

Date-time property with full advanced search capabilities.

```csharp
public sealed class DateTimeFilterProperty
```

| Property     | Type                       | Description                                                                                                                      |
| ------------ | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DateTimeOffset>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<DateTimeOffset>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<DateTimeOffset>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`        | Checks if the current property exists.                                                                                           |
| `Gt`         | `Nullable<DateTimeOffset>` | Greater than comparison with the provided value.                                                                                 |
| `Gte`        | `Nullable<DateTimeOffset>` | Greater than or equal comparison with the provided value.                                                                        |
| `Lt`         | `Nullable<DateTimeOffset>` | Lower than comparison with the provided value.                                                                                   |
| `Lte`        | `Nullable<DateTimeOffset>` | Lower than or equal comparison with the provided value.                                                                          |
| `In`         | `List<DateTimeOffset>`     | Checks if the property matches any of the provided values.                                                                       |

## DecisionDefinitionFilter

Decision definition search filter.

```csharp
public sealed class DecisionDefinitionFilter
```

| Property                      | Type                                | Description                                                                                                                                                                                                                                                                                                   |
| ----------------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `DecisionDefinitionId`        | `Nullable<DecisionDefinitionId>`    | The DMN ID of the decision definition.                                                                                                                                                                                                                                                                        |
| `Name`                        | `String`                            | The DMN name of the decision definition.                                                                                                                                                                                                                                                                      |
| `IsLatestVersion`             | `Nullable<Boolean>`                 | Whether to only return the latest version of each decision definition. When using this filter, pagination functionality is limited, you can only paginate forward using `after` and `limit`. The response contains no `startCursor` in the `page`, and requests ignore the `from` and `before` in the `page`. |
| `Version`                     | `Nullable<Int32>`                   | The assigned version of the decision definition.                                                                                                                                                                                                                                                              |
| `DecisionRequirementsId`      | `String`                            | the DMN ID of the decision requirements graph that the decision definition is part of.                                                                                                                                                                                                                        |
| `TenantId`                    | `Nullable<TenantId>`                | The tenant ID of the decision definition.                                                                                                                                                                                                                                                                     |
| `DecisionDefinitionKey`       | `Nullable<DecisionDefinitionKey>`   | The assigned key, which acts as a unique identifier for this decision definition.                                                                                                                                                                                                                             |
| `DecisionRequirementsKey`     | `Nullable<DecisionRequirementsKey>` | The assigned key of the decision requirements graph that the decision definition is part of.                                                                                                                                                                                                                  |
| `DecisionRequirementsName`    | `String`                            | The DMN name of the decision requirements that the decision definition is part of.                                                                                                                                                                                                                            |
| `DecisionRequirementsVersion` | `Nullable<Int32>`                   | The assigned version of the decision requirements that the decision definition is part of.                                                                                                                                                                                                                    |

## DecisionDefinitionId

Id of a decision definition, from the model. Only ids of decision definitions that are deployed are useful.

```csharp
public readonly record struct DecisionDefinitionId : ICamundaKey, IEquatable<DecisionDefinitionId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DecisionDefinitionKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct DecisionDefinitionKeyExactMatch : ICamundaKey, IEquatable<DecisionDefinitionKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DecisionDefinitionKeyFilterProperty

DecisionDefinitionKey property with full advanced search capabilities.

```csharp
public sealed class DecisionDefinitionKeyFilterProperty
```

| Property     | Type                              | Description                                                                                                                      |
| ------------ | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DecisionDefinitionKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<DecisionDefinitionKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<DecisionDefinitionKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`               | Checks if the current property exists.                                                                                           |
| `In`         | `List<DecisionDefinitionKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<DecisionDefinitionKey>`     | Checks if the property matches none of the provided values.                                                                      |

## DecisionDefinitionResult

```csharp
public sealed class DecisionDefinitionResult
```

| Property                      | Type                      | Description                                                                                  |
| ----------------------------- | ------------------------- | -------------------------------------------------------------------------------------------- |
| `DecisionDefinitionId`        | `DecisionDefinitionId`    | The DMN ID of the decision definition.                                                       |
| `DecisionDefinitionKey`       | `DecisionDefinitionKey`   | The assigned key, which acts as a unique identifier for this decision definition.            |
| `DecisionRequirementsId`      | `String`                  | the DMN ID of the decision requirements graph that the decision definition is part of.       |
| `DecisionRequirementsKey`     | `DecisionRequirementsKey` | The assigned key of the decision requirements graph that the decision definition is part of. |
| `DecisionRequirementsName`    | `String`                  | The DMN name of the decision requirements that the decision definition is part of.           |
| `DecisionRequirementsVersion` | `Int32`                   | The assigned version of the decision requirements that the decision definition is part of.   |
| `Name`                        | `String`                  | The DMN name of the decision definition.                                                     |
| `TenantId`                    | `TenantId`                | The tenant ID of the decision definition.                                                    |
| `Version`                     | `Int32`                   | The assigned version of the decision definition.                                             |

## DecisionDefinitionSearchQuery

```csharp
public sealed class DecisionDefinitionSearchQuery
```

| Property | Type                                             | Description                             |
| -------- | ------------------------------------------------ | --------------------------------------- |
| `Sort`   | `List<DecisionDefinitionSearchQuerySortRequest>` | Sort field criteria.                    |
| `Filter` | `DecisionDefinitionFilter`                       | The decision definition search filters. |
| `Page`   | `SearchQueryPageRequest`                         | Pagination criteria.                    |

## DecisionDefinitionSearchQueryResult

```csharp
public sealed class DecisionDefinitionSearchQueryResult
```

| Property | Type                             | Description                                      |
| -------- | -------------------------------- | ------------------------------------------------ |
| `Items`  | `List<DecisionDefinitionResult>` | The matching decision definitions.               |
| `Page`   | `SearchQueryPageResponse`        | Pagination information about the search results. |

## DecisionDefinitionSearchQuerySortRequest

```csharp
public sealed class DecisionDefinitionSearchQuerySortRequest
```

| Property | Type                                            | Description                                   |
| -------- | ----------------------------------------------- | --------------------------------------------- |
| `Field`  | `DecisionDefinitionSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                       | The order in which to sort the related field. |

## DecisionEvaluationById

```csharp
public sealed class DecisionEvaluationById : DecisionEvaluationInstruction, ITenantIdSettable
```

| Property               | Type                   | Description                                                                                                              |
| ---------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `DecisionDefinitionId` | `DecisionDefinitionId` | The ID of the decision to be evaluated. When using the decision ID, the latest deployed version of the decision is used. |
| `Variables`            | `Object`               | The decision evaluation variables as JSON document.                                                                      |
| `TenantId`             | `Nullable<TenantId>`   | The tenant ID of the decision.                                                                                           |

## DecisionEvaluationByKey

```csharp
public sealed class DecisionEvaluationByKey : DecisionEvaluationInstruction, ITenantIdSettable
```

| Property                | Type                    | Description                                         |
| ----------------------- | ----------------------- | --------------------------------------------------- |
| `DecisionDefinitionKey` | `DecisionDefinitionKey` | System-generated key for a decision definition.     |
| `Variables`             | `Object`                | The decision evaluation variables as JSON document. |
| `TenantId`              | `Nullable<TenantId>`    | The tenant ID of the decision.                      |

## DecisionEvaluationInstanceKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct DecisionEvaluationInstanceKeyExactMatch : ICamundaKey, IEquatable<DecisionEvaluationInstanceKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DecisionEvaluationInstanceKeyFilterProperty

DecisionEvaluationInstanceKey property with full advanced search capabilities.

```csharp
public sealed class DecisionEvaluationInstanceKeyFilterProperty
```

| Property     | Type                                      | Description                                                                                                                      |
| ------------ | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DecisionEvaluationInstanceKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<DecisionEvaluationInstanceKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<DecisionEvaluationInstanceKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`                       | Checks if the current property exists.                                                                                           |
| `In`         | `List<DecisionEvaluationInstanceKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<DecisionEvaluationInstanceKey>`     | Checks if the property matches none of the provided values.                                                                      |

## DecisionEvaluationInstruction

```csharp
public abstract class DecisionEvaluationInstruction
```

## DecisionEvaluationKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct DecisionEvaluationKeyExactMatch : ICamundaKey, IEquatable<DecisionEvaluationKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DecisionEvaluationKeyFilterProperty

DecisionEvaluationKey property with full advanced search capabilities.

```csharp
public sealed class DecisionEvaluationKeyFilterProperty
```

| Property     | Type                              | Description                                                                                                                      |
| ------------ | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DecisionEvaluationKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<DecisionEvaluationKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<DecisionEvaluationKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`               | Checks if the current property exists.                                                                                           |
| `In`         | `List<DecisionEvaluationKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<DecisionEvaluationKey>`     | Checks if the property matches none of the provided values.                                                                      |

## DecisionInstanceDeletionBatchOperationRequest

The decision instance filter that defines which decision instances should be deleted.

```csharp
public sealed class DecisionInstanceDeletionBatchOperationRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `DecisionInstanceFilter`       | The decision instance filter.                                                                                               |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## DecisionInstanceFilter

Decision instance search filter.

```csharp
public sealed class DecisionInstanceFilter
```

| Property                        | Type                                          | Description                                                                                                                                                                                                                                                           |
| ------------------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `DecisionEvaluationInstanceKey` | `DecisionEvaluationInstanceKeyFilterProperty` | The key of the decision evaluation instance.                                                                                                                                                                                                                          |
| `State`                         | `DecisionInstanceStateFilterProperty`         | The state of the decision instance.                                                                                                                                                                                                                                   |
| `EvaluationFailure`             | `String`                                      | The evaluation failure of the decision instance.                                                                                                                                                                                                                      |
| `EvaluationDate`                | `DateTimeFilterProperty`                      | The evaluation date of the decision instance.                                                                                                                                                                                                                         |
| `DecisionDefinitionId`          | `Nullable<DecisionDefinitionId>`              | The ID of the DMN decision.                                                                                                                                                                                                                                           |
| `DecisionDefinitionName`        | `String`                                      | The name of the DMN decision.                                                                                                                                                                                                                                         |
| `DecisionDefinitionVersion`     | `Nullable<Int32>`                             | The version of the decision.                                                                                                                                                                                                                                          |
| `DecisionDefinitionType`        | `Nullable<DecisionDefinitionTypeEnum>`        | The type of the decision. UNSPECIFIED is deprecated and should not be used anymore, for removal in 8.10                                                                                                                                                               |
| `TenantId`                      | `Nullable<TenantId>`                          | The tenant ID of the decision instance.                                                                                                                                                                                                                               |
| `DecisionEvaluationKey`         | `Nullable<DecisionEvaluationKey>`             | The key of the parent decision evaluation. Note that this is not the identifier of an individual decision instance; the `decisionEvaluationInstanceKey` is the identifier for a decision instance.                                                                    |
| `ProcessDefinitionKey`          | `Nullable<ProcessDefinitionKey>`              | The key of the process definition.                                                                                                                                                                                                                                    |
| `ProcessInstanceKey`            | `Nullable<ProcessInstanceKey>`                | The key of the process instance.                                                                                                                                                                                                                                      |
| `BusinessId`                    | `StringFilterProperty`                        | The business ID of the owning process instance the decision instance belongs to. This only works for decision instances created with 8.10 and onwards. Decision instances from prior versions and standalone evaluations don't contain this data and cannot be found. |
| `DecisionDefinitionKey`         | `DecisionDefinitionKeyFilterProperty`         | The key of the decision.                                                                                                                                                                                                                                              |
| `ElementInstanceKey`            | `ElementInstanceKeyFilterProperty`            | The key of the element instance this decision instance is linked to.                                                                                                                                                                                                  |
| `RootDecisionDefinitionKey`     | `DecisionDefinitionKeyFilterProperty`         | The key of the root decision definition.                                                                                                                                                                                                                              |
| `DecisionRequirementsKey`       | `DecisionRequirementsKeyFilterProperty`       | The key of the decision requirements definition.                                                                                                                                                                                                                      |

## DecisionInstanceGetQueryResult

```csharp
public sealed class DecisionInstanceGetQueryResult
```

| Property                        | Type                               | Description                                                                                                                                                                                                                                                                              |
| ------------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `BusinessId`                    | `Nullable<BusinessId>`             | The business ID of the owning process instance, inherited when the decision instance was evaluated. This is `null` for decision instances created before version 8.10, for standalone decision evaluations, and for decision instances whose owning process instance has no business ID. |
| `DecisionDefinitionId`          | `DecisionDefinitionId`             | The ID of the DMN decision.                                                                                                                                                                                                                                                              |
| `DecisionDefinitionKey`         | `DecisionDefinitionKey`            | The key of the decision.                                                                                                                                                                                                                                                                 |
| `DecisionDefinitionName`        | `String`                           | The name of the DMN decision.                                                                                                                                                                                                                                                            |
| `DecisionDefinitionType`        | `DecisionDefinitionTypeEnum`       | The type of the decision. UNSPECIFIED is deprecated and should not be used anymore, for removal in 8.10                                                                                                                                                                                  |
| `DecisionDefinitionVersion`     | `Int32`                            | The version of the decision.                                                                                                                                                                                                                                                             |
| `DecisionEvaluationInstanceKey` | `DecisionEvaluationInstanceKey`    | System-generated identifier for a decision evaluation instance. It is composed of the parent decision evaluation key and the 1-based index of the evaluated decision within that evaluation, joined by a hyphen (format: `-`).                                                           |
| `DecisionEvaluationKey`         | `DecisionEvaluationKey`            | The key of the decision evaluation where this instance was created.                                                                                                                                                                                                                      |
| `ElementInstanceKey`            | `Nullable<ElementInstanceKey>`     | The key of the element instance this decision instance is linked to.                                                                                                                                                                                                                     |
| `EvaluationDate`                | `DateTimeOffset`                   | The evaluation date of the decision instance.                                                                                                                                                                                                                                            |
| `EvaluationFailure`             | `String`                           | The evaluation failure of the decision instance.                                                                                                                                                                                                                                         |
| `ProcessDefinitionKey`          | `Nullable<ProcessDefinitionKey>`   | The key of the process definition.                                                                                                                                                                                                                                                       |
| `ProcessInstanceKey`            | `Nullable<ProcessInstanceKey>`     | The key of the process instance.                                                                                                                                                                                                                                                         |
| `Result`                        | `String`                           | The result of the decision instance.                                                                                                                                                                                                                                                     |
| `RootDecisionDefinitionKey`     | `DecisionDefinitionKey`            | The key of the root decision definition.                                                                                                                                                                                                                                                 |
| `RootProcessInstanceKey`        | `Nullable<ProcessInstanceKey>`     | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                              |
| `State`                         | `DecisionInstanceStateEnum`        | The state of the decision instance. UNSPECIFIED and UNKNOWN are deprecated and should not be used anymore, for removal in 8.10                                                                                                                                                           |
| `TenantId`                      | `TenantId`                         | The tenant ID of the decision instance.                                                                                                                                                                                                                                                  |
| `EvaluatedInputs`               | `List<EvaluatedDecisionInputItem>` | The evaluated inputs of the decision instance.                                                                                                                                                                                                                                           |
| `MatchedRules`                  | `List<MatchedDecisionRuleItem>`    | The matched rules of the decision instance.                                                                                                                                                                                                                                              |

## DecisionInstanceResult

```csharp
public sealed class DecisionInstanceResult
```

| Property                        | Type                             | Description                                                                                                                                                                                                                                                                              |
| ------------------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `BusinessId`                    | `Nullable<BusinessId>`           | The business ID of the owning process instance, inherited when the decision instance was evaluated. This is `null` for decision instances created before version 8.10, for standalone decision evaluations, and for decision instances whose owning process instance has no business ID. |
| `DecisionDefinitionId`          | `DecisionDefinitionId`           | The ID of the DMN decision.                                                                                                                                                                                                                                                              |
| `DecisionDefinitionKey`         | `DecisionDefinitionKey`          | The key of the decision.                                                                                                                                                                                                                                                                 |
| `DecisionDefinitionName`        | `String`                         | The name of the DMN decision.                                                                                                                                                                                                                                                            |
| `DecisionDefinitionType`        | `DecisionDefinitionTypeEnum`     | The type of the decision. UNSPECIFIED is deprecated and should not be used anymore, for removal in 8.10                                                                                                                                                                                  |
| `DecisionDefinitionVersion`     | `Int32`                          | The version of the decision.                                                                                                                                                                                                                                                             |
| `DecisionEvaluationInstanceKey` | `DecisionEvaluationInstanceKey`  | System-generated identifier for a decision evaluation instance. It is composed of the parent decision evaluation key and the 1-based index of the evaluated decision within that evaluation, joined by a hyphen (format: `-`).                                                           |
| `DecisionEvaluationKey`         | `DecisionEvaluationKey`          | The key of the decision evaluation where this instance was created.                                                                                                                                                                                                                      |
| `ElementInstanceKey`            | `Nullable<ElementInstanceKey>`   | The key of the element instance this decision instance is linked to.                                                                                                                                                                                                                     |
| `EvaluationDate`                | `DateTimeOffset`                 | The evaluation date of the decision instance.                                                                                                                                                                                                                                            |
| `EvaluationFailure`             | `String`                         | The evaluation failure of the decision instance.                                                                                                                                                                                                                                         |
| `ProcessDefinitionKey`          | `Nullable<ProcessDefinitionKey>` | The key of the process definition.                                                                                                                                                                                                                                                       |
| `ProcessInstanceKey`            | `Nullable<ProcessInstanceKey>`   | The key of the process instance.                                                                                                                                                                                                                                                         |
| `Result`                        | `String`                         | The result of the decision instance.                                                                                                                                                                                                                                                     |
| `RootDecisionDefinitionKey`     | `DecisionDefinitionKey`          | The key of the root decision definition.                                                                                                                                                                                                                                                 |
| `RootProcessInstanceKey`        | `Nullable<ProcessInstanceKey>`   | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                              |
| `State`                         | `DecisionInstanceStateEnum`      | The state of the decision instance. UNSPECIFIED and UNKNOWN are deprecated and should not be used anymore, for removal in 8.10                                                                                                                                                           |
| `TenantId`                      | `TenantId`                       | The tenant ID of the decision instance.                                                                                                                                                                                                                                                  |

## DecisionInstanceSearchQuery

```csharp
public sealed class DecisionInstanceSearchQuery
```

| Property | Type                                           | Description                           |
| -------- | ---------------------------------------------- | ------------------------------------- |
| `Sort`   | `List<DecisionInstanceSearchQuerySortRequest>` | Sort field criteria.                  |
| `Filter` | `DecisionInstanceFilter`                       | The decision instance search filters. |
| `Page`   | `SearchQueryPageRequest`                       | Pagination criteria.                  |

## DecisionInstanceSearchQueryResult

```csharp
public sealed class DecisionInstanceSearchQueryResult
```

| Property | Type                           | Description                                      |
| -------- | ------------------------------ | ------------------------------------------------ |
| `Items`  | `List<DecisionInstanceResult>` | The matching decision instances.                 |
| `Page`   | `SearchQueryPageResponse`      | Pagination information about the search results. |

## DecisionInstanceSearchQuerySortRequest

```csharp
public sealed class DecisionInstanceSearchQuerySortRequest
```

| Property | Type                                          | Description                                   |
| -------- | --------------------------------------------- | --------------------------------------------- |
| `Field`  | `DecisionInstanceSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                     | The order in which to sort the related field. |

## DecisionInstanceStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct DecisionInstanceStateExactMatch : ICamundaKey, IEquatable<DecisionInstanceStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DecisionInstanceStateFilterProperty

DecisionInstanceStateEnum property with full advanced search capabilities.

```csharp
public sealed class DecisionInstanceStateFilterProperty
```

| Property     | Type                                  | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DecisionInstanceStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<DecisionInstanceStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<DecisionInstanceStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                   | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<DecisionInstanceStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`      | `List<DecisionInstanceStateEnum>`     | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`       | `Nullable<LikeFilter>`                | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## DecisionRequirementsFilter

Decision requirements search filter.

```csharp
public sealed class DecisionRequirementsFilter
```

| Property                   | Type                                | Description                                                               |
| -------------------------- | ----------------------------------- | ------------------------------------------------------------------------- |
| `DecisionRequirementsName` | `String`                            | The DMN name of the decision requirements.                                |
| `DecisionRequirementsId`   | `String`                            | the DMN ID of the decision requirements.                                  |
| `DecisionRequirementsKey`  | `Nullable<DecisionRequirementsKey>` | System-generated key for a deployed decision requirements definition.     |
| `Version`                  | `Nullable<Int32>`                   | The assigned version of the decision requirements.                        |
| `TenantId`                 | `Nullable<TenantId>`                | The tenant ID of the decision requirements.                               |
| `ResourceName`             | `String`                            | The name of the resource from which the decision requirements were parsed |

## DecisionRequirementsKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct DecisionRequirementsKeyExactMatch : ICamundaKey, IEquatable<DecisionRequirementsKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DecisionRequirementsKeyFilterProperty

DecisionRequirementsKey property with full advanced search capabilities.

```csharp
public sealed class DecisionRequirementsKeyFilterProperty
```

| Property     | Type                                | Description                                                                                                                      |
| ------------ | ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DecisionRequirementsKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<DecisionRequirementsKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<DecisionRequirementsKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`                 | Checks if the current property exists.                                                                                           |
| `In`         | `List<DecisionRequirementsKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<DecisionRequirementsKey>`     | Checks if the property matches none of the provided values.                                                                      |

## DecisionRequirementsResult

```csharp
public sealed class DecisionRequirementsResult
```

| Property                   | Type                      | Description                                                                         |
| -------------------------- | ------------------------- | ----------------------------------------------------------------------------------- |
| `DecisionRequirementsId`   | `String`                  | The DMN ID of the decision requirements.                                            |
| `DecisionRequirementsKey`  | `DecisionRequirementsKey` | The assigned key, which acts as a unique identifier for this decision requirements. |
| `DecisionRequirementsName` | `String`                  | The DMN name of the decision requirements.                                          |
| `ResourceName`             | `String`                  | The name of the resource from which this decision requirements was parsed.          |
| `TenantId`                 | `TenantId`                | The tenant ID of the decision requirements.                                         |
| `Version`                  | `Int32`                   | The assigned version of the decision requirements.                                  |

## DecisionRequirementsSearchQuery

```csharp
public sealed class DecisionRequirementsSearchQuery
```

| Property | Type                                               | Description                             |
| -------- | -------------------------------------------------- | --------------------------------------- |
| `Sort`   | `List<DecisionRequirementsSearchQuerySortRequest>` | Sort field criteria.                    |
| `Filter` | `DecisionRequirementsFilter`                       | The decision definition search filters. |
| `Page`   | `SearchQueryPageRequest`                           | Pagination criteria.                    |

## DecisionRequirementsSearchQueryResult

```csharp
public sealed class DecisionRequirementsSearchQueryResult
```

| Property | Type                               | Description                                      |
| -------- | ---------------------------------- | ------------------------------------------------ |
| `Items`  | `List<DecisionRequirementsResult>` | The matching decision requirements.              |
| `Page`   | `SearchQueryPageResponse`          | Pagination information about the search results. |

## DecisionRequirementsSearchQuerySortRequest

```csharp
public sealed class DecisionRequirementsSearchQuerySortRequest
```

| Property | Type                                              | Description                                   |
| -------- | ------------------------------------------------- | --------------------------------------------- |
| `Field`  | `DecisionRequirementsSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                         | The order in which to sort the related field. |

## DeleteDecisionInstanceRequest

```csharp
public sealed class DeleteDecisionInstanceRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## DeleteProcessInstanceRequest

```csharp
public sealed class DeleteProcessInstanceRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## DeleteResourceRequest

```csharp
public sealed class DeleteResourceRequest
```

| Property             | Type                           | Description                                                                                                                                                                                                                                                                                                                                                            |
| -------------------- | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided.                                                                                                                                                                                                                                            |
| `DeleteHistory`      | `Nullable<Boolean>`            | Indicates if the historic data of a process resource should be deleted via a batch operation asynchronously. This flag is only effective for process resources. For other resource types (decisions, forms, generic resources), this flag is ignored and no history will be deleted. In those cases, the `batchOperation` field in the response will not be populated. |

## DeleteResourceResponse

```csharp
public sealed class DeleteResourceResponse
```

| Property         | Type                          | Description                                                                                                                                                                                                                                                                                    |
| ---------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ResourceKey`    | `ResourceKey`                 | The system-assigned key for this resource, requested to be deleted.                                                                                                                                                                                                                            |
| `BatchOperation` | `BatchOperationCreatedResult` | The batch operation created for asynchronously deleting the historic data. This field is only populated when the request `deleteHistory` is set to `true` and the resource is a process definition. For other resource types (decisions, forms, generic resources), this field will be `null`. |

## DeploymentConfigurationResponse

Configuration for deployment characteristics.

```csharp
public sealed class DeploymentConfigurationResponse
```

| Property                | Type      | Description                             |
| ----------------------- | --------- | --------------------------------------- |
| `IsMultiTenancyEnabled` | `Boolean` | Whether multi-tenancy is enabled.       |
| `MaxRequestSize`        | `Int64`   | The maximum HTTP request size in bytes. |

## DeploymentDecisionRequirementsResult

Deployed decision requirements.

```csharp
public sealed class DeploymentDecisionRequirementsResult
```

| Property                   | Type                      | Description                                                                                               |
| -------------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
| `DecisionRequirementsId`   | `String`                  | The id of the deployed decision requirements.                                                             |
| `DecisionRequirementsName` | `String`                  | The name of the deployed decision requirements.                                                           |
| `Version`                  | `Int32`                   | The version of the deployed decision requirements.                                                        |
| `ResourceName`             | `String`                  | The name of the resource.                                                                                 |
| `TenantId`                 | `TenantId`                | The tenant ID of the deployed decision requirements.                                                      |
| `DecisionRequirementsKey`  | `DecisionRequirementsKey` | The assigned decision requirements key, which acts as a unique identifier for this decision requirements. |

## DeploymentDecisionResult

A deployed decision.

```csharp
public sealed class DeploymentDecisionResult
```

| Property                  | Type                      | Description                                                                                                                    |
| ------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `DecisionDefinitionId`    | `DecisionDefinitionId`    | The dmn decision ID, as parsed during deployment, together with the version forms a unique identifier for a specific decision. |
| `Version`                 | `Int32`                   | The assigned decision version.                                                                                                 |
| `Name`                    | `String`                  | The DMN name of the decision, as parsed during deployment.                                                                     |
| `TenantId`                | `TenantId`                | The tenant ID of the deployed decision.                                                                                        |
| `DecisionRequirementsId`  | `String`                  | The dmn ID of the decision requirements graph that this decision is part of, as parsed during deployment.                      |
| `DecisionDefinitionKey`   | `DecisionDefinitionKey`   | The assigned decision key, which acts as a unique identifier for this decision.                                                |
| `DecisionRequirementsKey` | `DecisionRequirementsKey` | The assigned key of the decision requirements graph that this decision is part of.                                             |

## DeploymentFormResult

A deployed form.

```csharp
public sealed class DeploymentFormResult
```

| Property       | Type       | Description                                                                                                        |
| -------------- | ---------- | ------------------------------------------------------------------------------------------------------------------ |
| `FormId`       | `FormId`   | The form ID, as parsed during deployment, together with the version forms a unique identifier for a specific form. |
| `Version`      | `Int32`    | The version of the deployed form.                                                                                  |
| `ResourceName` | `String`   | The name of the resource.                                                                                          |
| `TenantId`     | `TenantId` | The unique identifier of the tenant.                                                                               |
| `FormKey`      | `FormKey`  | The assigned key, which acts as a unique identifier for this form.                                                 |

## DeploymentKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct DeploymentKeyExactMatch : ICamundaKey, IEquatable<DeploymentKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DeploymentKeyFilterProperty

DeploymentKey property with full advanced search capabilities.

```csharp
public sealed class DeploymentKeyFilterProperty
```

| Property     | Type                      | Description                                                                                                                      |
| ------------ | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<DeploymentKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<DeploymentKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<DeploymentKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`       | Checks if the current property exists.                                                                                           |
| `In`         | `List<DeploymentKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<DeploymentKey>`     | Checks if the property matches none of the provided values.                                                                      |

## DeploymentMetadataResult

```csharp
public sealed class DeploymentMetadataResult
```

| Property               | Type                                   | Description                               |
| ---------------------- | -------------------------------------- | ----------------------------------------- |
| `ProcessDefinition`    | `DeploymentProcessResult`              | Deployed process.                         |
| `DecisionDefinition`   | `DeploymentDecisionResult`             | Deployed decision.                        |
| `DecisionRequirements` | `DeploymentDecisionRequirementsResult` | Deployed decision requirement definition. |
| `Form`                 | `DeploymentFormResult`                 | Deployed form.                            |
| `Resource`             | `DeploymentResourceResult`             | Deployed resource.                        |

## DeploymentProcessResult

A deployed process.

```csharp
public sealed class DeploymentProcessResult
```

| Property                   | Type                   | Description                                                                                                                              |
| -------------------------- | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`      | `ProcessDefinitionId`  | The bpmn process ID, as parsed during deployment, together with the version forms a unique identifier for a specific process definition. |
| `ProcessDefinitionVersion` | `Int32`                | The assigned process version.                                                                                                            |
| `ResourceName`             | `String`               | The resource name from which this process was parsed.                                                                                    |
| `TenantId`                 | `TenantId`             | The tenant ID of the deployed process.                                                                                                   |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey` | The assigned key, which acts as a unique identifier for this process.                                                                    |

## DeploymentResourceResult

A deployed Resource.

```csharp
public sealed class DeploymentResourceResult
```

| Property       | Type          | Description                                                            |
| -------------- | ------------- | ---------------------------------------------------------------------- |
| `ResourceId`   | `String`      | The resource id of the deployed resource.                              |
| `ResourceName` | `String`      | The name of the deployed resource.                                     |
| `Version`      | `Int32`       | The description of the deployed resource.                              |
| `TenantId`     | `TenantId`    | The unique identifier of the tenant.                                   |
| `ResourceKey`  | `ResourceKey` | The assigned key, which acts as a unique identifier for this Resource. |

## DeploymentResult

```csharp
public sealed class DeploymentResult
```

| Property        | Type                             | Description                                   |
| --------------- | -------------------------------- | --------------------------------------------- |
| `DeploymentKey` | `DeploymentKey`                  | The unique key identifying the deployment.    |
| `TenantId`      | `TenantId`                       | The tenant ID associated with the deployment. |
| `Deployments`   | `List<DeploymentMetadataResult>` | Items deployed by the request.                |

## DirectAncestorKeyInstruction

Provides a concrete key to use as ancestor scope for the created element instance.

```csharp
public sealed class DirectAncestorKeyInstruction : AncestorScopeInstruction
```

| Property                     | Type                 | Description                                                                                                                                                                                                                                                                                                   |
| ---------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `AncestorElementInstanceKey` | `ElementInstanceKey` | The key of the ancestor scope the element instance should be created in. Set to -1 to create the new element instance within an existing element instance of the flow scope. If multiple instances of the target element's flow scope exist, choose one specifically with this property by providing its key. |

## DocumentCreationBatchResponse

```csharp
public sealed class DocumentCreationBatchResponse
```

| Property           | Type                                  | Description                               |
| ------------------ | ------------------------------------- | ----------------------------------------- |
| `FailedDocuments`  | `List<DocumentCreationFailureDetail>` | Documents that were successfully created. |
| `CreatedDocuments` | `List<DocumentReference>`             | Documents that failed creation.           |

## DocumentCreationFailureDetail

```csharp
public sealed class DocumentCreationFailureDetail
```

| Property   | Type     | Description                                                              |
| ---------- | -------- | ------------------------------------------------------------------------ |
| `FileName` | `String` | The name of the file that failed to upload.                              |
| `Status`   | `Int32`  | The HTTP status code of the failure.                                     |
| `Title`    | `String` | A short, human-readable summary of the problem type.                     |
| `Detail`   | `String` | A human-readable explanation specific to this occurrence of the problem. |

## DocumentId

Document Id that uniquely identifies a document.

```csharp
public readonly record struct DocumentId : ICamundaKey, IEquatable<DocumentId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## DocumentLink

```csharp
public sealed class DocumentLink
```

| Property    | Type             | Description                              |
| ----------- | ---------------- | ---------------------------------------- |
| `Url`       | `String`         | The link to the document.                |
| `ExpiresAt` | `DateTimeOffset` | The date and time when the link expires. |

## DocumentLinkRequest

```csharp
public sealed class DocumentLinkRequest
```

| Property     | Type              | Description                                  |
| ------------ | ----------------- | -------------------------------------------- |
| `TimeToLive` | `Nullable<Int64>` | The time-to-live of the document link in ms. |

## DocumentMetadata

Information about the document.

```csharp
public sealed class DocumentMetadata
```

| Property              | Type                            | Description                                                 |
| --------------------- | ------------------------------- | ----------------------------------------------------------- |
| `ContentType`         | `String`                        | The content type of the document.                           |
| `FileName`            | `String`                        | The name of the file.                                       |
| `ExpiresAt`           | `Nullable<DateTimeOffset>`      | The date and time when the document expires.                |
| `Size`                | `Nullable<Int64>`               | The size of the document in bytes.                          |
| `ProcessDefinitionId` | `Nullable<ProcessDefinitionId>` | The ID of the process definition that created the document. |
| `ProcessInstanceKey`  | `Nullable<ProcessInstanceKey>`  | The key of the process instance that created the document.  |
| `CustomProperties`    | `Object`                        | Custom properties of the document.                          |

## DocumentMetadataResponse

Information about the document that is returned in responses.

```csharp
public sealed class DocumentMetadataResponse
```

| Property              | Type                            | Description                                                 |
| --------------------- | ------------------------------- | ----------------------------------------------------------- |
| `ContentType`         | `String`                        | The content type of the document.                           |
| `FileName`            | `String`                        | The name of the file.                                       |
| `ExpiresAt`           | `Nullable<DateTimeOffset>`      | The date and time when the document expires.                |
| `Size`                | `Int64`                         | The size of the document in bytes.                          |
| `ProcessDefinitionId` | `Nullable<ProcessDefinitionId>` | The ID of the process definition that created the document. |
| `ProcessInstanceKey`  | `Nullable<ProcessInstanceKey>`  | The key of the process instance that created the document.  |
| `CustomProperties`    | `Object`                        | Custom properties of the document.                          |

## DocumentReference

```csharp
public sealed class DocumentReference
```

| Property              | Type                                   | Description                                                   |
| --------------------- | -------------------------------------- | ------------------------------------------------------------- |
| `CamundaDocumentType` | `DocumentReferenceCamundaDocumentType` | Document discriminator. Always set to "camunda".              |
| `StoreId`             | `String`                               | The ID of the document store.                                 |
| `DocumentId`          | `DocumentId`                           | The ID of the document.                                       |
| `ContentHash`         | `String`                               | The hash of the document.                                     |
| `Metadata`            | `DocumentMetadataResponse`             | Information about the document that is returned in responses. |

## ElementId

The model-defined id of an element.

```csharp
public readonly record struct ElementId : ICamundaKey, IEquatable<ElementId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ElementIdExactMatch

Matches the value exactly.

```csharp
public readonly record struct ElementIdExactMatch : ICamundaKey, IEquatable<ElementIdExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ElementIdFilterProperty

ElementId property with full advanced search capabilities.

```csharp
public sealed class ElementIdFilterProperty
```

| Property     | Type                   | Description                                                                                                                                                                                                                                               |
| ------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ElementId>`  | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<ElementId>`  | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<ElementId>`  | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`    | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<ElementId>`      | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`      | `List<ElementId>`      | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`       | `Nullable<LikeFilter>` | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## ElementInstanceFilter

Element instance search filter.

```csharp
public sealed class ElementInstanceFilter
```

| Property                  | Type                                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ------------------------- | ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`     | `Nullable<ProcessDefinitionId>`       | The process definition ID associated to this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `State`                   | `ElementInstanceStateFilterProperty`  | State of element instance as defined set of values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `Type`                    | `Nullable<ElementInstanceFilterType>` | Type of element as defined set of values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `ElementId`               | `ElementIdFilterProperty`             | The element ID for this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `ElementName`             | `StringFilterProperty`                | The element name. This only works for data created with 8.8 and onwards. Instances from prior versions don't contain this data and cannot be found.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `HasIncident`             | `Nullable<Boolean>`                   | Shows whether this element instance has an incident related to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `TenantId`                | `Nullable<TenantId>`                  | The unique identifier of the tenant.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `ElementInstanceKey`      | `Nullable<ElementInstanceKey>`        | The assigned key, which acts as a unique identifier for this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `ProcessInstanceKey`      | `Nullable<ProcessInstanceKey>`        | The process instance key associated to this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `ProcessDefinitionKey`    | `Nullable<ProcessDefinitionKey>`      | The process definition key associated to this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `IncidentKey`             | `Nullable<IncidentKey>`               | The key of incident if field incident is true.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `StartDate`               | `DateTimeFilterProperty`              | The start date of this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `EndDate`                 | `DateTimeFilterProperty`              | The end date of this element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ElementInstanceScopeKey` | `String`                              | The scope key of this element instance. If provided with a process instance key it will return element instances that are immediate children of the process instance. If provided with an element instance key it will return element instances that are immediate children of the element instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `Or`                      | `List<ElementInstanceFilterFields>`   | Defines a list of alternative filter groups combined using OR logic. Each object in the array is evaluated independently, and the filter matches if any one of them is satisfied. Top-level fields and the `$or` clause are combined using AND logic — meaning: (top-level filters) AND (any of the `$or` filters) must match.  Example: `json {   "processInstanceKey": "2251799813685323",   "$or": [     { "elementName": { "$like": "*Order*" } },     { "elementId":   { "$like": "*Order*" } }   ] } ` This matches element instances scoped to the given process instance whose:  <code>elementName</code> contains Order, or <code>elementId</code> contains Order   Note: Using complex <code>$or</code> conditions may impact performance, use with caution in high-volume environments. |

## ElementInstanceFilterFields

Element instance filter fields.

```csharp
public sealed class ElementInstanceFilterFields
```

| Property                  | Type                                        | Description                                                                                                                                                                                                                                                                                          |
| ------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`     | `Nullable<ProcessDefinitionId>`             | The process definition ID associated to this element instance.                                                                                                                                                                                                                                       |
| `State`                   | `ElementInstanceStateFilterProperty`        | State of element instance as defined set of values.                                                                                                                                                                                                                                                  |
| `Type`                    | `Nullable<ElementInstanceFilterFieldsType>` | Type of element as defined set of values.                                                                                                                                                                                                                                                            |
| `ElementId`               | `ElementIdFilterProperty`                   | The element ID for this element instance.                                                                                                                                                                                                                                                            |
| `ElementName`             | `StringFilterProperty`                      | The element name. This only works for data created with 8.8 and onwards. Instances from prior versions don't contain this data and cannot be found.                                                                                                                                                  |
| `HasIncident`             | `Nullable<Boolean>`                         | Shows whether this element instance has an incident related to.                                                                                                                                                                                                                                      |
| `TenantId`                | `Nullable<TenantId>`                        | The unique identifier of the tenant.                                                                                                                                                                                                                                                                 |
| `ElementInstanceKey`      | `Nullable<ElementInstanceKey>`              | The assigned key, which acts as a unique identifier for this element instance.                                                                                                                                                                                                                       |
| `ProcessInstanceKey`      | `Nullable<ProcessInstanceKey>`              | The process instance key associated to this element instance.                                                                                                                                                                                                                                        |
| `ProcessDefinitionKey`    | `Nullable<ProcessDefinitionKey>`            | The process definition key associated to this element instance.                                                                                                                                                                                                                                      |
| `IncidentKey`             | `Nullable<IncidentKey>`                     | The key of incident if field incident is true.                                                                                                                                                                                                                                                       |
| `StartDate`               | `DateTimeFilterProperty`                    | The start date of this element instance.                                                                                                                                                                                                                                                             |
| `EndDate`                 | `DateTimeFilterProperty`                    | The end date of this element instance.                                                                                                                                                                                                                                                               |
| `ElementInstanceScopeKey` | `String`                                    | The scope key of this element instance. If provided with a process instance key it will return element instances that are immediate children of the process instance. If provided with an element instance key it will return element instances that are immediate children of the element instance. |

## ElementInstanceKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct ElementInstanceKeyExactMatch : ICamundaKey, IEquatable<ElementInstanceKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ElementInstanceKeyFilterProperty

ElementInstanceKey property with full advanced search capabilities.

```csharp
public sealed class ElementInstanceKeyFilterProperty
```

| Property     | Type                           | Description                                                                                                                      |
| ------------ | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ElementInstanceKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<ElementInstanceKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<ElementInstanceKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`            | Checks if the current property exists.                                                                                           |
| `In`         | `List<ElementInstanceKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<ElementInstanceKey>`     | Checks if the property matches none of the provided values.                                                                      |

## ElementInstanceResult

```csharp
public sealed class ElementInstanceResult
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                 |
| ------------------------ | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`    | `ProcessDefinitionId`          | The process definition ID associated to this element instance.                                                                                                                                                                              |
| `StartDate`              | `DateTimeOffset`               | Date when element instance started.                                                                                                                                                                                                         |
| `EndDate`                | `Nullable<DateTimeOffset>`     | Date when element instance finished.                                                                                                                                                                                                        |
| `ElementId`              | `ElementId`                    | The element ID for this element instance.                                                                                                                                                                                                   |
| `ElementName`            | `String`                       | The element name for this element instance.                                                                                                                                                                                                 |
| `Type`                   | `ElementInstanceResultType`    | Type of element as defined set of values.                                                                                                                                                                                                   |
| `State`                  | `ElementInstanceStateEnum`     | State of element instance as defined set of values.                                                                                                                                                                                         |
| `HasIncident`            | `Boolean`                      | Shows whether this element instance has an incident. If true also an incidentKey is provided.                                                                                                                                               |
| `TenantId`               | `TenantId`                     | The tenant ID of the incident.                                                                                                                                                                                                              |
| `ElementInstanceKey`     | `ElementInstanceKey`           | The assigned key, which acts as a unique identifier for this element instance.                                                                                                                                                              |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The process instance key associated to this element instance.                                                                                                                                                                               |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `ProcessDefinitionKey`   | `ProcessDefinitionKey`         | The process definition key associated to this element instance.                                                                                                                                                                             |
| `IncidentKey`            | `Nullable<IncidentKey>`        | Incident key associated with this element instance.                                                                                                                                                                                         |

## ElementInstanceSearchQuery

Element instance search request.

```csharp
public sealed class ElementInstanceSearchQuery
```

| Property | Type                                          | Description                          |
| -------- | --------------------------------------------- | ------------------------------------ |
| `Sort`   | `List<ElementInstanceSearchQuerySortRequest>` | Sort field criteria.                 |
| `Filter` | `ElementInstanceFilter`                       | The element instance search filters. |
| `Page`   | `SearchQueryPageRequest`                      | Pagination criteria.                 |

## ElementInstanceSearchQueryResult

```csharp
public sealed class ElementInstanceSearchQueryResult
```

| Property | Type                          | Description                                      |
| -------- | ----------------------------- | ------------------------------------------------ |
| `Items`  | `List<ElementInstanceResult>` | The matching element instances.                  |
| `Page`   | `SearchQueryPageResponse`     | Pagination information about the search results. |

## ElementInstanceSearchQuerySortRequest

```csharp
public sealed class ElementInstanceSearchQuerySortRequest
```

| Property | Type                                         | Description                                   |
| -------- | -------------------------------------------- | --------------------------------------------- |
| `Field`  | `ElementInstanceSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                    | The order in which to sort the related field. |

## ElementInstanceStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct ElementInstanceStateExactMatch : ICamundaKey, IEquatable<ElementInstanceStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ElementInstanceStateFilterProperty

ElementInstanceStateEnum property with full advanced search capabilities.

```csharp
public sealed class ElementInstanceStateFilterProperty
```

| Property     | Type                                 | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ElementInstanceStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<ElementInstanceStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<ElementInstanceStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<ElementInstanceStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## ElementInstanceWaitStateFilter

Filters for the element instance inspection.

```csharp
public sealed class ElementInstanceWaitStateFilter
```

| Property                 | Type                                 | Description                          |
| ------------------------ | ------------------------------------ | ------------------------------------ |
| `ElementInstanceKey`     | `ElementInstanceKeyFilterProperty`   | Filter by element instance key.      |
| `ProcessInstanceKey`     | `ProcessInstanceKeyFilterProperty`   | Filter by process instance key.      |
| `RootProcessInstanceKey` | `ProcessInstanceKeyFilterProperty`   | Filter by root process instance key. |
| `ElementId`              | `ElementIdFilterProperty`            | Filter by element ID.                |
| `ElementType`            | `WaitStateElementTypeFilterProperty` | Filter by element type.              |
| `WaitStateType`          | `WaitStateTypeFilterProperty`        | Filter by wait state type.           |

## ElementInstanceWaitStateQuery

Element instance inspection request.

```csharp
public sealed class ElementInstanceWaitStateQuery
```

| Property | Type                                             | Description                         |
| -------- | ------------------------------------------------ | ----------------------------------- |
| `Sort`   | `List<ElementInstanceWaitStateQuerySortRequest>` | Sort field criteria.                |
| `Filter` | `ElementInstanceWaitStateFilter`                 | Filter criteria for the inspection. |
| `Page`   | `SearchQueryPageRequest`                         | Pagination criteria.                |

## ElementInstanceWaitStateQueryResult

```csharp
public sealed class ElementInstanceWaitStateQueryResult
```

| Property | Type                                   | Description                                      |
| -------- | -------------------------------------- | ------------------------------------------------ |
| `Items`  | `List<ElementInstanceWaitStateResult>` | The matching waiting states.                     |
| `Page`   | `SearchQueryPageResponse`              | Pagination information about the search results. |

## ElementInstanceWaitStateQuerySortRequest

```csharp
public sealed class ElementInstanceWaitStateQuerySortRequest
```

| Property | Type                                            | Description                                   |
| -------- | ----------------------------------------------- | --------------------------------------------- |
| `Field`  | `ElementInstanceWaitStateQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                       | The order in which to sort the related field. |

## ElementInstanceWaitStateResult

An element instance waiting state.

```csharp
public sealed class ElementInstanceWaitStateResult
```

| Property                 | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | Key of the root process instance.                                                  |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The process instance key associated to this element instance.                      |
| `ElementInstanceKey`     | `ElementInstanceKey`           | The element instance key associated to this element instance.                      |
| `ElementId`              | `ElementId`                    | The element ID for this element instance.                                          |
| `ElementType`            | `WaitStateElementTypeEnum`     | The BPMN element type of this element instance.                                    |
| `TenantId`               | `TenantId`                     | The tenant ID of the element instance.                                             |
| `BpmnProcessId`          | `String`                       | The BPMN process ID of the process definition associated to this element instance. |
| `Details`                | `WaitStateDetails`             | Wait-state-specific details, resolved by waitStateType.                            |

## EndCursor

The end cursor in a search query result set.

```csharp
public readonly record struct EndCursor : ICamundaKey, IEquatable<EndCursor>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## EntityTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct EntityTypeExactMatch : ICamundaKey, IEquatable<EntityTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## EntityTypeFilterProperty

AuditLogEntityTypeEnum property with full advanced search capabilities.

```csharp
public sealed class EntityTypeFilterProperty
```

| Property     | Type                               | Description                                                                                                                                                                                                                                               |
| ------------ | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogEntityTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<AuditLogEntityTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<AuditLogEntityTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<AuditLogEntityTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`             | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## EvaluateConditionalResult

```csharp
public sealed class EvaluateConditionalResult
```

| Property                   | Type                             | Description                                                                                                             |
| -------------------------- | -------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `ConditionalEvaluationKey` | `ConditionalEvaluationKey`       | The unique key of the conditional evaluation operation.                                                                 |
| `TenantId`                 | `TenantId`                       | The tenant ID of the conditional evaluation operation.                                                                  |
| `ProcessInstances`         | `List<ProcessInstanceReference>` | List of process instances created. If no root-level conditional start events evaluated to true, the list will be empty. |

## EvaluateDecisionResult

```csharp
public sealed class EvaluateDecisionResult
```

| Property                     | Type                             | Description                                                                                                  |
| ---------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `DecisionDefinitionId`       | `DecisionDefinitionId`           | The ID of the decision which was evaluated.                                                                  |
| `DecisionDefinitionKey`      | `DecisionDefinitionKey`          | The unique key identifying the decision which was evaluated.                                                 |
| `DecisionDefinitionName`     | `String`                         | The name of the decision which was evaluated.                                                                |
| `DecisionDefinitionVersion`  | `Int32`                          | The version of the decision which was evaluated.                                                             |
| `DecisionEvaluationKey`      | `DecisionEvaluationKey`          | The unique key identifying this decision evaluation.                                                         |
| `DecisionInstanceKey`        | `DecisionInstanceKey`            | Deprecated, please refer to `decisionEvaluationKey`.                                                         |
| `DecisionRequirementsId`     | `String`                         | The ID of the decision requirements graph that the decision which was evaluated is part of.                  |
| `DecisionRequirementsKey`    | `DecisionRequirementsKey`        | The unique key identifying the decision requirements graph that the decision which was evaluated is part of. |
| `EvaluatedDecisions`         | `List<EvaluatedDecisionResult>`  | Decisions that were evaluated within the requested decision evaluation.                                      |
| `FailedDecisionDefinitionId` | `Nullable<DecisionDefinitionId>` | The ID of the decision which failed during evaluation.                                                       |
| `FailureMessage`             | `String`                         | Message describing why the decision which was evaluated failed.                                              |
| `Output`                     | `String`                         | JSON document that will instantiate the result of the decision which was evaluated.                          |
| `TenantId`                   | `TenantId`                       | The tenant ID of the evaluated decision.                                                                     |

## EvaluatedDecisionInputItem

A decision input that was evaluated within this decision evaluation.

```csharp
public sealed class EvaluatedDecisionInputItem
```

| Property     | Type     | Description                           |
| ------------ | -------- | ------------------------------------- |
| `InputId`    | `String` | The identifier of the decision input. |
| `InputName`  | `String` | The name of the decision input.       |
| `InputValue` | `String` | The value of the decision input.      |

## EvaluatedDecisionOutputItem

The evaluated decision outputs.

```csharp
public sealed class EvaluatedDecisionOutputItem
```

| Property      | Type              | Description                                           |
| ------------- | ----------------- | ----------------------------------------------------- |
| `OutputId`    | `String`          | The ID of the evaluated decison output item.          |
| `OutputName`  | `String`          | The name of the of the evaluated decison output item. |
| `OutputValue` | `String`          | The value of the evaluated decison output item.       |
| `RuleId`      | `String`          | The ID of the matched rule.                           |
| `RuleIndex`   | `Nullable<Int32>` | The index of the matched rule.                        |

## EvaluatedDecisionResult

A decision that was evaluated.

```csharp
public sealed class EvaluatedDecisionResult
```

| Property                        | Type                               | Description                                                                         |
| ------------------------------- | ---------------------------------- | ----------------------------------------------------------------------------------- |
| `DecisionDefinitionId`          | `DecisionDefinitionId`             | The ID of the decision which was evaluated.                                         |
| `DecisionDefinitionName`        | `String`                           | The name of the decision which was evaluated.                                       |
| `DecisionDefinitionVersion`     | `Int32`                            | The version of the decision which was evaluated.                                    |
| `DecisionDefinitionType`        | `String`                           | The type of the decision which was evaluated.                                       |
| `Output`                        | `String`                           | JSON document that will instantiate the result of the decision which was evaluated. |
| `TenantId`                      | `TenantId`                         | The tenant ID of the evaluated decision.                                            |
| `MatchedRules`                  | `List<MatchedDecisionRuleItem>`    | The decision rules that matched within this decision evaluation.                    |
| `EvaluatedInputs`               | `List<EvaluatedDecisionInputItem>` | The decision inputs that were evaluated within this decision evaluation.            |
| `DecisionDefinitionKey`         | `DecisionDefinitionKey`            | The unique key identifying the decision which was evaluate.                         |
| `DecisionEvaluationInstanceKey` | `DecisionEvaluationInstanceKey`    | The unique key identifying this decision evaluation instance.                       |

## EventualConsistencyTimeoutException

Thrown when an eventually consistent endpoint times out waiting for data.

```csharp
public sealed class EventualConsistencyTimeoutException : CamundaSdkException, ISerializable
```

| Property   | Type    | Description |
| ---------- | ------- | ----------- |
| `WaitedMs` | `Int32` |             |

## ExpressionEvaluationRequest

```csharp
public sealed class ExpressionEvaluationRequest : ITenantIdSettable
```

| Property     | Type                 | Description                                                                                                                                                                                                                                                                                                                                                                 |
| ------------ | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Expression` | `String`             | The expression to evaluate (e.g., "=x + y")                                                                                                                                                                                                                                                                                                                                 |
| `TenantId`   | `String`             | Required when the expression references tenant-scoped cluster variables                                                                                                                                                                                                                                                                                                     |
| `ScopeKey`   | `Nullable<ScopeKey>` | Key of the process instance or element instance whose variables should be made visible to the expression. Use a process instance key to evaluate against the process instance scope, or an element instance key to evaluate against that element instance scope. If omitted, the expression is evaluated unscoped, using only cluster variables and request-body variables. |
| `Variables`  | `Object`             | Optional variables for expression evaluation. These variables are only used for the current evaluation and do not persist beyond it.                                                                                                                                                                                                                                        |

## ExpressionEvaluationResult

```csharp
public sealed class ExpressionEvaluationResult
```

| Property     | Type                                    | Description                                             |
| ------------ | --------------------------------------- | ------------------------------------------------------- |
| `Expression` | `String`                                | The evaluated expression                                |
| `Result`     | `Object`                                | The result value. Its type can vary.                    |
| `Warnings`   | `List<ExpressionEvaluationWarningItem>` | List of warnings generated during expression evaluation |

## ExpressionEvaluationWarningItem

```csharp
public sealed class ExpressionEvaluationWarningItem
```

| Property  | Type     | Description         |
| --------- | -------- | ------------------- |
| `Message` | `String` | The warning message |

## ExtendedDeploymentResponse

Extended deployment result with typed convenience properties for direct access to deployed artifacts by category (processes, decisions, forms, etc.).

```csharp
public sealed class ExtendedDeploymentResponse
```

| Property               | Type                                         | Description                                   |
| ---------------------- | -------------------------------------------- | --------------------------------------------- |
| `Raw`                  | `DeploymentResult`                           | The underlying raw deployment response.       |
| `DeploymentKey`        | `DeploymentKey`                              | The unique key identifying the deployment.    |
| `TenantId`             | `TenantId`                                   | The tenant ID associated with the deployment. |
| `Deployments`          | `List<DeploymentMetadataResult>`             | All items deployed by the request.            |
| `Processes`            | `List<DeploymentProcessResult>`              | Deployed process definitions.                 |
| `Decisions`            | `List<DeploymentDecisionResult>`             | Deployed decision definitions.                |
| `DecisionRequirements` | `List<DeploymentDecisionRequirementsResult>` | Deployed decision requirements.               |
| `Forms`                | `List<DeploymentFormResult>`                 | Deployed forms.                               |
| `Resources`            | `List<DeploymentResourceResult>`             | Deployed resources.                           |

## FormId

The user-defined id for the form

```csharp
public readonly record struct FormId : ICamundaKey, IEquatable<FormId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## FormKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct FormKeyExactMatch : ICamundaKey, IEquatable<FormKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## FormKeyFilterProperty

FormKey property with full advanced search capabilities.

```csharp
public sealed class FormKeyFilterProperty
```

| Property     | Type                | Description                                                                                                                      |
| ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<FormKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<FormKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<FormKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>` | Checks if the current property exists.                                                                                           |
| `In`         | `List<FormKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<FormKey>`     | Checks if the property matches none of the provided values.                                                                      |

## FormResult

```csharp
public sealed class FormResult
```

| Property   | Type       | Description                                                        |
| ---------- | ---------- | ------------------------------------------------------------------ |
| `TenantId` | `TenantId` | The tenant ID of the form.                                         |
| `FormId`   | `FormId`   | The user-provided identifier of the form.                          |
| `Schema`   | `String`   | The form schema as a JSON document serialized as a string.         |
| `Version`  | `Int64`    | The version of the the deployed form.                              |
| `FormKey`  | `FormKey`  | The assigned key, which acts as a unique identifier for this form. |

## GlobalJobStatisticsQueryResult

Global job statistics query result.

```csharp
public sealed class GlobalJobStatisticsQueryResult
```

| Property       | Type           | Description                                                                                           |
| -------------- | -------------- | ----------------------------------------------------------------------------------------------------- |
| `Created`      | `StatusMetric` | Metric for a single job status.                                                                       |
| `Completed`    | `StatusMetric` | Metric for a single job status.                                                                       |
| `Failed`       | `StatusMetric` | Metric for a single job status.                                                                       |
| `IsIncomplete` | `Boolean`      | True if some data is missing because internal limits were reached and some metrics were not recorded. |

## GlobalListenerBase

```csharp
public sealed class GlobalListenerBase
```

| Property         | Type                | Description                                                                                                     |
| ---------------- | ------------------- | --------------------------------------------------------------------------------------------------------------- |
| `Type`           | `String`            | The name of the job type, used as a reference to specify which job workers request the respective listener job. |
| `Retries`        | `Nullable<Int32>`   | Number of retries for the listener job.                                                                         |
| `AfterNonGlobal` | `Nullable<Boolean>` | Whether the listener should run after model-level listeners.                                                    |
| `Priority`       | `Nullable<Int32>`   | The priority of the listener. Higher priority listeners are executed before lower priority ones.                |

## GlobalListenerId

The user-defined id for the global listener

```csharp
public readonly record struct GlobalListenerId : ICamundaKey, IEquatable<GlobalListenerId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## GlobalListenerSourceExactMatch

Matches the value exactly.

```csharp
public readonly record struct GlobalListenerSourceExactMatch : ICamundaKey, IEquatable<GlobalListenerSourceExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## GlobalListenerSourceFilterProperty

Global listener source property with full advanced search capabilities.

```csharp
public sealed class GlobalListenerSourceFilterProperty
```

| Property     | Type                                 | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<GlobalListenerSourceEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<GlobalListenerSourceEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<GlobalListenerSourceEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<GlobalListenerSourceEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## GlobalTaskListenerBase

```csharp
public sealed class GlobalTaskListenerBase
```

| Property         | Type                                    | Description                                                                                                     |
| ---------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `EventTypes`     | `List<GlobalTaskListenerEventTypeEnum>` | List of user task event types that trigger the listener.                                                        |
| `Type`           | `String`                                | The name of the job type, used as a reference to specify which job workers request the respective listener job. |
| `Retries`        | `Nullable<Int32>`                       | Number of retries for the listener job.                                                                         |
| `AfterNonGlobal` | `Nullable<Boolean>`                     | Whether the listener should run after model-level listeners.                                                    |
| `Priority`       | `Nullable<Int32>`                       | The priority of the listener. Higher priority listeners are executed before lower priority ones.                |

## GlobalTaskListenerEventTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct GlobalTaskListenerEventTypeExactMatch : ICamundaKey, IEquatable<GlobalTaskListenerEventTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## GlobalTaskListenerEventTypeFilterProperty

Global listener event type property with full advanced search capabilities.

```csharp
public sealed class GlobalTaskListenerEventTypeFilterProperty
```

| Property     | Type                                        | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<GlobalTaskListenerEventTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<GlobalTaskListenerEventTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<GlobalTaskListenerEventTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                         | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<GlobalTaskListenerEventTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`                      | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## GlobalTaskListenerResult

```csharp
public sealed class GlobalTaskListenerResult
```

| Property         | Type                                    | Description                                                                                                     |
| ---------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `Id`             | `GlobalListenerId`                      | The user-defined id for the global listener                                                                     |
| `Source`         | `GlobalListenerSourceEnum`              | How the global listener was defined.                                                                            |
| `EventTypes`     | `List<GlobalTaskListenerEventTypeEnum>` | List of user task event types that trigger the listener.                                                        |
| `Type`           | `String`                                | The name of the job type, used as a reference to specify which job workers request the respective listener job. |
| `Retries`        | `Int32`                                 | Number of retries for the listener job.                                                                         |
| `AfterNonGlobal` | `Boolean`                               | Whether the listener should run after model-level listeners.                                                    |
| `Priority`       | `Int32`                                 | The priority of the listener. Higher priority listeners are executed before lower priority ones.                |

## GlobalTaskListenerSearchQueryFilterRequest

Global listener filter request.

```csharp
public sealed class GlobalTaskListenerSearchQueryFilterRequest
```

| Property         | Type                                              | Description                                            |
| ---------------- | ------------------------------------------------- | ------------------------------------------------------ |
| `Id`             | `StringFilterProperty`                            | Id of the global listener.                             |
| `Type`           | `StringFilterProperty`                            | Job type of the global listener.                       |
| `Retries`        | `IntegerFilterProperty`                           | Number of retries of the global listener.              |
| `EventTypes`     | `List<GlobalTaskListenerEventTypeFilterProperty>` | Event types of the global listener.                    |
| `AfterNonGlobal` | `Nullable<Boolean>`                               | Whether the listener runs after model-level listeners. |
| `Priority`       | `IntegerFilterProperty`                           | Priority of the global listener.                       |
| `Source`         | `GlobalListenerSourceFilterProperty`              | How the global listener was defined.                   |

## GlobalTaskListenerSearchQueryRequest

Global listener search query request.

```csharp
public sealed class GlobalTaskListenerSearchQueryRequest
```

| Property | Type                                             | Description                         |
| -------- | ------------------------------------------------ | ----------------------------------- |
| `Sort`   | `List<GlobalTaskListenerSearchQuerySortRequest>` | Sort field criteria.                |
| `Filter` | `GlobalTaskListenerSearchQueryFilterRequest`     | The global listener search filters. |
| `Page`   | `SearchQueryPageRequest`                         | Pagination criteria.                |

## GlobalTaskListenerSearchQueryResult

Global listener search query response.

```csharp
public sealed class GlobalTaskListenerSearchQueryResult
```

| Property | Type                             | Description                                      |
| -------- | -------------------------------- | ------------------------------------------------ |
| `Items`  | `List<GlobalTaskListenerResult>` | The matching global listeners.                   |
| `Page`   | `SearchQueryPageResponse`        | Pagination information about the search results. |

## GlobalTaskListenerSearchQuerySortRequest

```csharp
public sealed class GlobalTaskListenerSearchQuerySortRequest
```

| Property | Type                                            | Description                                   |
| -------- | ----------------------------------------------- | --------------------------------------------- |
| `Field`  | `GlobalTaskListenerSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                       | The order in which to sort the related field. |

## GroupClientResult

```csharp
public sealed class GroupClientResult
```

| Property   | Type       | Description           |
| ---------- | ---------- | --------------------- |
| `ClientId` | `ClientId` | The ID of the client. |

## GroupClientSearchQueryRequest

```csharp
public sealed class GroupClientSearchQueryRequest
```

| Property | Type                                      | Description          |
| -------- | ----------------------------------------- | -------------------- |
| `Sort`   | `List<GroupClientSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                  | Pagination criteria. |

## GroupClientSearchQuerySortRequest

```csharp
public sealed class GroupClientSearchQuerySortRequest
```

| Property | Type                                     | Description                                   |
| -------- | ---------------------------------------- | --------------------------------------------- |
| `Field`  | `GroupClientSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                | The order in which to sort the related field. |

## GroupClientSearchResult

```csharp
public sealed class GroupClientSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<GroupClientResult>` | The matching client IDs.                         |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## GroupCreateRequest

```csharp
public sealed class GroupCreateRequest
```

| Property      | Type      | Description                        |
| ------------- | --------- | ---------------------------------- |
| `GroupId`     | `GroupId` | The ID of the new group.           |
| `Name`        | `String`  | The display name of the new group. |
| `Description` | `String`  | The description of the new group.  |

## GroupCreateResult

```csharp
public sealed class GroupCreateResult
```

| Property      | Type      | Description                            |
| ------------- | --------- | -------------------------------------- |
| `GroupId`     | `GroupId` | The ID of the created group.           |
| `Name`        | `String`  | The display name of the created group. |
| `Description` | `String`  | The description of the created group.  |

## GroupFilter

Group filter request

```csharp
public sealed class GroupFilter
```

| Property  | Type                   | Description                    |
| --------- | ---------------------- | ------------------------------ |
| `GroupId` | `StringFilterProperty` | The group ID search filters.   |
| `Name`    | `String`               | The group name search filters. |

## GroupId

The unique identifier of a group.

```csharp
public readonly record struct GroupId : ICamundaKey, IEquatable<GroupId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## GroupMappingRuleSearchResult

```csharp
public sealed class GroupMappingRuleSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<MappingRuleResult>` | The matching mapping rules.                      |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## GroupResult

Group search response item.

```csharp
public sealed class GroupResult
```

| Property      | Type      | Description            |
| ------------- | --------- | ---------------------- |
| `Name`        | `String`  | The group name.        |
| `GroupId`     | `GroupId` | The group ID.          |
| `Description` | `String`  | The group description. |

## GroupRoleSearchResult

```csharp
public sealed class GroupRoleSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<RoleResult>`        | The matching roles.                              |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## GroupSearchQueryRequest

Group search request.

```csharp
public sealed class GroupSearchQueryRequest
```

| Property | Type                                | Description               |
| -------- | ----------------------------------- | ------------------------- |
| `Sort`   | `List<GroupSearchQuerySortRequest>` | Sort field criteria.      |
| `Filter` | `GroupFilter`                       | The group search filters. |
| `Page`   | `SearchQueryPageRequest`            | Pagination criteria.      |

## GroupSearchQueryResult

Group search response.

```csharp
public sealed class GroupSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<GroupResult>`       | The matching groups.                             |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## GroupSearchQuerySortRequest

```csharp
public sealed class GroupSearchQuerySortRequest
```

| Property | Type                               | Description                                   |
| -------- | ---------------------------------- | --------------------------------------------- |
| `Field`  | `GroupSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`          | The order in which to sort the related field. |

## GroupUpdateRequest

```csharp
public sealed class GroupUpdateRequest
```

| Property      | Type     | Description                       |
| ------------- | -------- | --------------------------------- |
| `Name`        | `String` | The new name of the group.        |
| `Description` | `String` | The new description of the group. |

## GroupUpdateResult

```csharp
public sealed class GroupUpdateResult
```

| Property      | Type      | Description                   |
| ------------- | --------- | ----------------------------- |
| `GroupId`     | `GroupId` | The unique group ID.          |
| `Name`        | `String`  | The name of the group.        |
| `Description` | `String`  | The description of the group. |

## GroupUserResult

```csharp
public sealed class GroupUserResult
```

| Property   | Type       | Description                |
| ---------- | ---------- | -------------------------- |
| `Username` | `Username` | The unique name of a user. |

## GroupUserSearchQueryRequest

```csharp
public sealed class GroupUserSearchQueryRequest
```

| Property | Type                                    | Description          |
| -------- | --------------------------------------- | -------------------- |
| `Sort`   | `List<GroupUserSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                | Pagination criteria. |

## GroupUserSearchQuerySortRequest

```csharp
public sealed class GroupUserSearchQuerySortRequest
```

| Property | Type                                   | Description                                   |
| -------- | -------------------------------------- | --------------------------------------------- |
| `Field`  | `GroupUserSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`              | The order in which to sort the related field. |

## GroupUserSearchResult

```csharp
public sealed class GroupUserSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<GroupUserResult>`   | The matching members.                            |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## HttpSdkException

HTTP-specific SDK error with RFC 7807 Problem Details.

```csharp
public sealed class HttpSdkException : CamundaSdkException, ISerializable
```

| Property         | Type      | Description |
| ---------------- | --------- | ----------- |
| `Type`           | `String`  |             |
| `Title`          | `String`  |             |
| `Detail`         | `String`  |             |
| `Instance`       | `String`  |             |
| `IsBackpressure` | `Boolean` |             |

## ICamundaKey

Marker interface for all Camunda domain key types.

Enables generic constraints and JSON converter discovery.

```csharp
public interface ICamundaKey
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ICamundaLongKey

Marker interface for Camunda domain types backed by a long (int64) value.

```csharp
public interface ICamundaLongKey
```

| Property | Type    | Description                |
| -------- | ------- | -------------------------- |
| `Value`  | `Int64` | The underlying long value. |

## ITenantIdSettable

Implemented by request body types that have an optional tenantId property. The SDK uses this to inject the configured default tenant ID when the caller does not supply one explicitly.

```csharp
public interface ITenantIdSettable
```

## ITenantIdsSettable

Implemented by request body types that have an optional `tenantIds` array property (e.g. `JobActivationRequest`). The SDK uses this to inject `[DefaultTenantId]` when the caller does not supply a tenant list explicitly. Mirrors `ITenantIdSettable` for the plural array shape.

```csharp
public interface ITenantIdsSettable
```

## IncidentErrorTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct IncidentErrorTypeExactMatch : ICamundaKey, IEquatable<IncidentErrorTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## IncidentErrorTypeFilterProperty

IncidentErrorTypeEnum with full advanced search capabilities.

```csharp
public sealed class IncidentErrorTypeFilterProperty
```

| Property     | Type                              | Description                                                                                                                                                                                                                                               |
| ------------ | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<IncidentErrorTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<IncidentErrorTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<IncidentErrorTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`               | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<IncidentErrorTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`      | `List<IncidentErrorTypeEnum>`     | Checks if the property does not match any of the provided values.                                                                                                                                                                                         |
| `Like`       | `Nullable<LikeFilter>`            | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## IncidentFilter

Incident search filter.

```csharp
public sealed class IncidentFilter
```

| Property               | Type                                 | Description                                                            |
| ---------------------- | ------------------------------------ | ---------------------------------------------------------------------- |
| `ProcessDefinitionId`  | `StringFilterProperty`               | The process definition ID associated to this incident.                 |
| `ErrorType`            | `IncidentErrorTypeFilterProperty`    | Incident error type with a defined set of values.                      |
| `ErrorMessage`         | `StringFilterProperty`               | The error message of this incident.                                    |
| `ElementId`            | `StringFilterProperty`               | The element ID associated to this incident.                            |
| `CreationTime`         | `DateTimeFilterProperty`             | Date of incident creation.                                             |
| `State`                | `IncidentStateFilterProperty`        | State of this incident with a defined set of values.                   |
| `TenantId`             | `StringFilterProperty`               | The tenant ID of the incident.                                         |
| `IncidentKey`          | `BasicStringFilterProperty`          | The assigned key, which acts as a unique identifier for this incident. |
| `ProcessDefinitionKey` | `ProcessDefinitionKeyFilterProperty` | The process definition key associated to this incident.                |
| `ProcessInstanceKey`   | `ProcessInstanceKeyFilterProperty`   | The process instance key associated to this incident.                  |
| `ElementInstanceKey`   | `ElementInstanceKeyFilterProperty`   | The element instance key associated to this incident.                  |
| `JobKey`               | `JobKeyFilterProperty`               | The job key, if exists, associated with this incident.                 |

## IncidentProcessInstanceStatisticsByDefinitionFilter

Filter for the incident process instance statistics by definition query.

```csharp
public sealed class IncidentProcessInstanceStatisticsByDefinitionFilter
```

| Property        | Type    | Description                                                                        |
| --------------- | ------- | ---------------------------------------------------------------------------------- |
| `ErrorHashCode` | `Int32` | The error hash code of the incidents to filter the process instance statistics by. |

## IncidentProcessInstanceStatisticsByDefinitionQuery

```csharp
public sealed class IncidentProcessInstanceStatisticsByDefinitionQuery
```

| Property | Type                                                                  | Description                                                                     |
| -------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| `Filter` | `IncidentProcessInstanceStatisticsByDefinitionFilter`                 | Filter criteria for the aggregated process instance statistics.                 |
| `Page`   | `OffsetPagination`                                                    | Pagination parameters for the aggregated process instance statistics.           |
| `Sort`   | `List<IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest>` | Sorting criteria for process instance statistics grouped by process definition. |

## IncidentProcessInstanceStatisticsByDefinitionQueryResult

```csharp
public sealed class IncidentProcessInstanceStatisticsByDefinitionQueryResult
```

| Property | Type                                                        | Description                                                                                                             |
| -------- | ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `Items`  | `List<IncidentProcessInstanceStatisticsByDefinitionResult>` | Statistics of active process instances with incidents, grouped by process definition for the specified error hash code. |
| `Page`   | `SearchQueryPageResponse`                                   | Pagination information about the search results.                                                                        |

## IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest

```csharp
public sealed class IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest
```

| Property | Type                                                                 | Description                                                               |
| -------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| `Field`  | `IncidentProcessInstanceStatisticsByDefinitionQuerySortRequestField` | The aggregated field by which the process instance statistics are sorted. |
| `Order`  | `Nullable<SortOrderEnum>`                                            | The order in which to sort the related field.                             |

## IncidentProcessInstanceStatisticsByDefinitionResult

```csharp
public sealed class IncidentProcessInstanceStatisticsByDefinitionResult
```

| Property                        | Type                   | Description                                                                                                |
| ------------------------------- | ---------------------- | ---------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`           | `ProcessDefinitionId`  | Id of a process definition, from the model. Only ids of process definitions that are deployed are useful.  |
| `ProcessDefinitionKey`          | `ProcessDefinitionKey` | System-generated key for a deployed process definition.                                                    |
| `ProcessDefinitionName`         | `String`               | The name of the process definition.                                                                        |
| `ProcessDefinitionVersion`      | `Int32`                | The version of the process definition.                                                                     |
| `TenantId`                      | `TenantId`             | The unique identifier of the tenant.                                                                       |
| `ActiveInstancesWithErrorCount` | `Int64`                | The number of active process instances that currently have an incident with the specified error hash code. |

## IncidentProcessInstanceStatisticsByErrorQuery

```csharp
public sealed class IncidentProcessInstanceStatisticsByErrorQuery
```

| Property | Type                                                             | Description                                                                      |
| -------- | ---------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| `Page`   | `OffsetPagination`                                               | Pagination parameters for process instance statistics grouped by incident error. |
| `Sort`   | `List<IncidentProcessInstanceStatisticsByErrorQuerySortRequest>` | Sorting criteria for process instance statistics grouped by incident error.      |

## IncidentProcessInstanceStatisticsByErrorQueryResult

```csharp
public sealed class IncidentProcessInstanceStatisticsByErrorQueryResult
```

| Property | Type                                                   | Description                                                       |
| -------- | ------------------------------------------------------ | ----------------------------------------------------------------- |
| `Items`  | `List<IncidentProcessInstanceStatisticsByErrorResult>` | Statistics of active process instances grouped by incident error. |
| `Page`   | `SearchQueryPageResponse`                              | Pagination information about the search results.                  |

## IncidentProcessInstanceStatisticsByErrorQuerySortRequest

```csharp
public sealed class IncidentProcessInstanceStatisticsByErrorQuerySortRequest
```

| Property | Type                                                            | Description                                         |
| -------- | --------------------------------------------------------------- | --------------------------------------------------- |
| `Field`  | `IncidentProcessInstanceStatisticsByErrorQuerySortRequestField` | The field to sort the incident error statistics by. |
| `Order`  | `Nullable<SortOrderEnum>`                                       | The order in which to sort the related field.       |

## IncidentProcessInstanceStatisticsByErrorResult

```csharp
public sealed class IncidentProcessInstanceStatisticsByErrorResult
```

| Property                        | Type     | Description                                                                                    |
| ------------------------------- | -------- | ---------------------------------------------------------------------------------------------- |
| `ErrorHashCode`                 | `Int32`  | The hash code identifying a specific incident error..                                          |
| `ErrorMessage`                  | `String` | The error message associated with the incident error hash code.                                |
| `ActiveInstancesWithErrorCount` | `Int64`  | The number of active process instances that currently have an active incident with this error. |

## IncidentResolutionRequest

```csharp
public sealed class IncidentResolutionRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## IncidentResult

```csharp
public sealed class IncidentResult
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                 |
| ------------------------ | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`    | `ProcessDefinitionId`          | The process definition ID associated to this incident.                                                                                                                                                                                      |
| `ErrorType`              | `IncidentErrorTypeEnum`        | The type of the incident error.                                                                                                                                                                                                             |
| `ErrorMessage`           | `String`                       | Error message which describes the error in more detail.                                                                                                                                                                                     |
| `ElementId`              | `ElementId`                    | The element ID associated to this incident.                                                                                                                                                                                                 |
| `CreationTime`           | `DateTimeOffset`               | The creation time of the incident.                                                                                                                                                                                                          |
| `State`                  | `IncidentStateEnum`            | The incident state.                                                                                                                                                                                                                         |
| `TenantId`               | `TenantId`                     | The tenant ID of the incident.                                                                                                                                                                                                              |
| `IncidentKey`            | `IncidentKey`                  | The assigned key, which acts as a unique identifier for this incident.                                                                                                                                                                      |
| `ProcessDefinitionKey`   | `ProcessDefinitionKey`         | The process definition key associated to this incident.                                                                                                                                                                                     |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The process instance key associated to this incident.                                                                                                                                                                                       |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `ElementInstanceKey`     | `ElementInstanceKey`           | The element instance key associated to this incident.                                                                                                                                                                                       |
| `JobKey`                 | `Nullable<JobKey>`             | The job key, if exists, associated with this incident.                                                                                                                                                                                      |

## IncidentSearchQuery

```csharp
public sealed class IncidentSearchQuery
```

| Property | Type                                   | Description                  |
| -------- | -------------------------------------- | ---------------------------- |
| `Sort`   | `List<IncidentSearchQuerySortRequest>` | Sort field criteria.         |
| `Filter` | `IncidentFilter`                       | The incident search filters. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria.         |

## IncidentSearchQueryResult

```csharp
public sealed class IncidentSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<IncidentResult>`    | The matching incidents.                          |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## IncidentSearchQuerySortRequest

```csharp
public sealed class IncidentSearchQuerySortRequest
```

| Property | Type                                  | Description                                   |
| -------- | ------------------------------------- | --------------------------------------------- |
| `Field`  | `IncidentSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`             | The order in which to sort the related field. |

## IncidentStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct IncidentStateExactMatch : ICamundaKey, IEquatable<IncidentStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## IncidentStateFilterProperty

IncidentStateEnum with full advanced search capabilities.

```csharp
public sealed class IncidentStateFilterProperty
```

| Property     | Type                          | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<IncidentStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<IncidentStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<IncidentStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<IncidentStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`      | `List<IncidentStateEnum>`     | Checks if the property does not match any of the provided values.                                                                                                                                                                                         |
| `Like`       | `Nullable<LikeFilter>`        | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## InferredAncestorKeyInstruction

Instructs the engine to derive the ancestor scope key from the source element's hierarchy. The engine traverses the source element's ancestry to find an instance that matches one of the target element's flow scopes, ensuring the target is activated in the correct scope.

```csharp
public sealed class InferredAncestorKeyInstruction : AncestorScopeInstruction
```

## IntegerFilterProperty

Integer property with advanced search capabilities.

```csharp
public sealed class IntegerFilterProperty
```

| Property     | Type                | Description                                                                                                                      |
| ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<Int32>`   | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<Int32>`   | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<Int32>`   | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>` | Checks if the current property exists.                                                                                           |
| `Gt`         | `Nullable<Int32>`   | Greater than comparison with the provided value.                                                                                 |
| `Gte`        | `Nullable<Int32>`   | Greater than or equal comparison with the provided value.                                                                        |
| `Lt`         | `Nullable<Int32>`   | Lower than comparison with the provided value.                                                                                   |
| `Lte`        | `Nullable<Int32>`   | Lower than or equal comparison with the provided value.                                                                          |
| `In`         | `List<Int32>`       | Checks if the property matches any of the provided values.                                                                       |

## JobActivationRequest

```csharp
public sealed class JobActivationRequest : ITenantIdsSettable
```

| Property            | Type                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Type`              | `String`                     | The job type, as defined in the BPMN process (e.g. <zeebe:taskDefinition type="payment-service" />)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `Worker`            | `String`                     | The name of the worker activating the jobs, mostly used for logging purposes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Timeout`           | `Int64`                      | A job returned after this call will not be activated by another call until the timeout (in ms) has been reached.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `MaxJobsToActivate` | `Int32`                      | The maximum jobs to activate by this request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `FetchVariable`     | `List<String>`               | A list of variables to fetch as the job variables; if empty, all visible variables at the time of activation for the scope of the job will be returned.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `RequestTimeout`    | `Nullable<Int64>`            | The request will be completed when at least one job is activated or after the requestTimeout (in ms). If the requestTimeout = 0, a default timeout is used. If the requestTimeout < 0, long polling is disabled and the request is completed immediately, even when no job is activated.                                                                                                                                                                                                                                                                                                                                                                                           |
| `TenantIds`         | `List<TenantId>`             | A list of IDs of tenants for which to activate jobs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `TenantFilter`      | `Nullable<TenantFilterEnum>` | The tenant filtering strategy - determines whether to use provided tenant IDs or assigned tenant IDs from the authenticated principal's authorized tenants.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `WithLease`         | `Nullable<Boolean>`          | Whether to activate the jobs with a lease. When true, each activated job is assigned a distinct, opaque lease token, returned as ActivatedJobResult.leaseToken. The lease fences the complete, fail, and throw-error commands against a superseded activation of the same job (for example, after the job timed out or failed and was re-activated by another worker): a command carrying a stale lease token is rejected rather than racing with the newer activation. Once a job has been activated with a lease, it is served only to leasing workers of that job type; a homogeneous fleet per job type is recommended. Omit or set to false to activate jobs without a lease. |

## JobActivationResult

The list of activated jobs

```csharp
public sealed class JobActivationResult
```

| Property | Type                       | Description         |
| -------- | -------------------------- | ------------------- |
| `Jobs`   | `List<ActivatedJobResult>` | The activated jobs. |

## JobBatchUpdateRequest

The filter and changeset for a batch job update operation. The filter defines which jobs are updated; the changeset defines what to update. At least one changeset field must be non-null.

```csharp
public sealed class JobBatchUpdateRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `JobFilter`                    | The job filter. At least one dimension must be set.                                                                         |
| `Changeset`          | `JobChangeset`                 | The fields to update. At least one field must be non-null.                                                                  |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## JobChangeset

JSON object with changed job attribute values. The job cannot be completed or failed with this endpoint, use the complete job or fail job endpoints instead.

```csharp
public sealed class JobChangeset
```

| Property   | Type              | Description                                                           |
| ---------- | ----------------- | --------------------------------------------------------------------- |
| `Retries`  | `Nullable<Int32>` | The new number of retries for the job.                                |
| `Timeout`  | `Nullable<Int64>` | The new timeout for the job in milliseconds.                          |
| `Priority` | `Nullable<Int32>` | The new priority for the job. Higher values indicate higher priority. |

## JobCompletionRequest

```csharp
public sealed class JobCompletionRequest
```

| Property     | Type                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ------------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Variables`  | `Object`               | The variables to complete the job with.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `Result`     | `JobResult`            | The result of the completed job as determined by the worker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `LeaseToken` | `String`               | The token identifying a leased job's activation, obtained from `ActivatedJobResult.leaseToken`. For a leased job, the matching token must be supplied to prove the command comes from the worker that holds the current lease; a command with no token is rejected. A command carrying a stale token is likewise rejected, fencing the job against a superseded activation (for example, after the job timed out or failed and was re-activated by another worker). A job that was activated without a lease requires no token.                                                                                                                                                                                                                                                                                  |
| `BusinessId` | `Nullable<BusinessId>` | An optional business id to assign to the process instance the job belongs to, as part of completing the job, letting a worker set the identifier from work it just performed. The business id can only be assigned to a root process instance: if the job belongs to a child process instance (one started by a call activity), the completion is rejected. An empty business id is likewise rejected. The assignment is single and irreversible and is only accepted while business id uniqueness is disabled. Only artifacts created after the assignment carry the business id; already-existing ones are not enriched. Completing with a business id that differs from one already assigned rejects the whole completion, leaving the job open; re-sending the identical business id is an idempotent no-op. |

## JobErrorRequest

```csharp
public sealed class JobErrorRequest
```

| Property       | Type     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode`    | `String` | The error code that will be matched with an error catch event.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ErrorMessage` | `String` | An error message that provides additional context.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `Variables`    | `Object` | JSON object that will instantiate the variables at the local scope of the error catch event that catches the thrown error.                                                                                                                                                                                                                                                                                                                                                                                                      |
| `LeaseToken`   | `String` | The token identifying a leased job's activation, obtained from `ActivatedJobResult.leaseToken`. For a leased job, the matching token must be supplied to prove the command comes from the worker that holds the current lease; a command with no token is rejected. A command carrying a stale token is likewise rejected, fencing the job against a superseded activation (for example, after the job timed out or failed and was re-activated by another worker). A job that was activated without a lease requires no token. |

## JobErrorStatisticsFilter

Job error statistics search filter.

```csharp
public sealed class JobErrorStatisticsFilter
```

| Property       | Type                   | Description                                                            |
| -------------- | ---------------------- | ---------------------------------------------------------------------- |
| `From`         | `DateTimeOffset`       | Start of the time window to filter metrics. ISO 8601 date-time format. |
| `To`           | `DateTimeOffset`       | End of the time window to filter metrics. ISO 8601 date-time format.   |
| `JobType`      | `String`               | Job type to return error metrics for.                                  |
| `ErrorCode`    | `StringFilterProperty` | Optional error code filter with advanced search capabilities.          |
| `ErrorMessage` | `StringFilterProperty` | Optional error message filter with advanced search capabilities.       |

## JobErrorStatisticsItem

Aggregated error metrics for a single error type and message combination.

```csharp
public sealed class JobErrorStatisticsItem
```

| Property       | Type     | Description                                             |
| -------------- | -------- | ------------------------------------------------------- |
| `ErrorCode`    | `String` | The error code identifier.                              |
| `ErrorMessage` | `String` | The error message.                                      |
| `Workers`      | `Int32`  | Number of distinct workers that encountered this error. |

## JobErrorStatisticsQuery

Job error statistics query.

```csharp
public sealed class JobErrorStatisticsQuery
```

| Property | Type                       | Description                         |
| -------- | -------------------------- | ----------------------------------- |
| `Filter` | `JobErrorStatisticsFilter` | Job error statistics search filter. |
| `Page`   | `CursorForwardPagination`  | Search cursor pagination.           |

## JobErrorStatisticsQueryResult

Job error statistics query result.

```csharp
public sealed class JobErrorStatisticsQueryResult
```

| Property | Type                           | Description                                      |
| -------- | ------------------------------ | ------------------------------------------------ |
| `Items`  | `List<JobErrorStatisticsItem>` | The list of per-error statistics items.          |
| `Page`   | `SearchQueryPageResponse`      | Pagination information about the search results. |

## JobFailRequest

```csharp
public sealed class JobFailRequest
```

| Property       | Type              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| -------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Retries`      | `Nullable<Int32>` | The amount of retries the job should have left                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ErrorMessage` | `String`          | An optional error message describing why the job failed; if not provided, an empty string is used.                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `RetryBackOff` | `Nullable<Int64>` | An optional retry back off for the failed job. The job will not be retryable before the current time plus the back off time. The default is 0 which means the job is retryable immediately.                                                                                                                                                                                                                                                                                                                                     |
| `Variables`    | `Object`          | JSON object that will instantiate the variables at the local scope of the job's associated task.                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `LeaseToken`   | `String`          | The token identifying a leased job's activation, obtained from `ActivatedJobResult.leaseToken`. For a leased job, the matching token must be supplied to prove the command comes from the worker that holds the current lease; a command with no token is rejected. A command carrying a stale token is likewise rejected, fencing the job against a superseded activation (for example, after the job timed out or failed and was re-activated by another worker). A job that was activated without a lease requires no token. |

## JobFailureException

Throw from a job handler to explicitly fail a job with custom retry settings.

```csharp
public sealed class JobFailureException : Exception, ISerializable
```

| Property         | Type              | Description                                                              |
| ---------------- | ----------------- | ------------------------------------------------------------------------ |
| `Retries`        | `Nullable<Int32>` | How many retries the job should have remaining. `null` = server decides. |
| `RetryBackOffMs` | `Nullable<Int64>` | Retry back-off in milliseconds. `null` = immediate retry.                |

## JobFilter

Job search filter.

```csharp
public sealed class JobFilter
```

| Property                   | Type                                 | Description                                                                                                                          |
| -------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
| `Deadline`                 | `DateTimeFilterProperty`             | When the job can next be activated.                                                                                                  |
| `DeniedReason`             | `StringFilterProperty`               | The reason provided by the user task listener for denying the work.                                                                  |
| `ElementId`                | `StringFilterProperty`               | The element ID associated with the job.                                                                                              |
| `ElementInstanceKey`       | `ElementInstanceKeyFilterProperty`   | The element instance key associated with the job.                                                                                    |
| `EndTime`                  | `DateTimeFilterProperty`             | When the job ended.                                                                                                                  |
| `ErrorCode`                | `StringFilterProperty`               | The error code provided for the failed job.                                                                                          |
| `ErrorMessage`             | `StringFilterProperty`               | The error message that provides additional context for a failed job.                                                                 |
| `HasFailedWithRetriesLeft` | `Nullable<Boolean>`                  | Indicates whether the job has failed with retries left.                                                                              |
| `IsDenied`                 | `Nullable<Boolean>`                  | Indicates whether the user task listener denies the work.                                                                            |
| `JobKey`                   | `JobKeyFilterProperty`               | The key, a unique identifier for the job.                                                                                            |
| `Kind`                     | `JobKindFilterProperty`              | The kind of the job.                                                                                                                 |
| `ListenerEventType`        | `JobListenerEventTypeFilterProperty` | The listener event type of the job.                                                                                                  |
| `Priority`                 | `IntegerFilterProperty`              | The priority of the job. Jobs created before 8.10 have no stored priority and are excluded from results when this filter is applied. |
| `ProcessDefinitionId`      | `StringFilterProperty`               | The process definition ID associated with the job.                                                                                   |
| `ProcessDefinitionKey`     | `ProcessDefinitionKeyFilterProperty` | The process definition key associated with the job.                                                                                  |
| `ProcessInstanceKey`       | `ProcessInstanceKeyFilterProperty`   | The process instance key associated with the job.                                                                                    |
| `Retries`                  | `IntegerFilterProperty`              | The number of retries left.                                                                                                          |
| `State`                    | `JobStateFilterProperty`             | The state of the job.                                                                                                                |
| `TenantId`                 | `StringFilterProperty`               | The tenant ID.                                                                                                                       |
| `Type`                     | `StringFilterProperty`               | The type of the job.                                                                                                                 |
| `Worker`                   | `StringFilterProperty`               | The name of the worker for this job.                                                                                                 |
| `CreationTime`             | `DateTimeFilterProperty`             | When the job was created. Field is present for jobs created after 8.9.                                                               |
| `LastUpdateTime`           | `DateTimeFilterProperty`             | When the job was last updated. Field is present for jobs created after 8.9.                                                          |

## JobHandler

Delegate for job handler functions. Return the output variables to complete the job with, or `null` to complete with no output variables. Return a `JobCompletionRequest` to send a structured completion (e.g. with job corrections or a task denial).

To signal a BPMN error, throw `BpmnErrorException`.

To explicitly fail a job with custom retries, throw `JobFailureException`.

Any other unhandled exception auto-fails the job with `retries - 1`.

```csharp
public delegate Task<object?> JobHandler(ActivatedJob job, CancellationToken ct)
```

## JobKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct JobKeyExactMatch : ICamundaKey, IEquatable<JobKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## JobKeyFilterProperty

JobKey property with full advanced search capabilities.

```csharp
public sealed class JobKeyFilterProperty
```

| Property     | Type                | Description                                                                                                                      |
| ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<JobKey>`  | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<JobKey>`  | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<JobKey>`  | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>` | Checks if the current property exists.                                                                                           |
| `In`         | `List<JobKey>`      | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<JobKey>`      | Checks if the property matches none of the provided values.                                                                      |

## JobKindExactMatch

Matches the value exactly.

```csharp
public readonly record struct JobKindExactMatch : ICamundaKey, IEquatable<JobKindExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## JobKindFilterProperty

JobKindEnum property with full advanced search capabilities.

```csharp
public sealed class JobKindFilterProperty
```

| Property     | Type                    | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<JobKindEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<JobKindEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<JobKindEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`     | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<JobKindEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`  | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## JobListenerEventTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct JobListenerEventTypeExactMatch : ICamundaKey, IEquatable<JobListenerEventTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## JobListenerEventTypeFilterProperty

JobListenerEventTypeEnum property with full advanced search capabilities.

```csharp
public sealed class JobListenerEventTypeFilterProperty
```

| Property     | Type                                 | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<JobListenerEventTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<JobListenerEventTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<JobListenerEventTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<JobListenerEventTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## JobMetricsConfigurationResponse

Configuration for job metrics collection and export.

```csharp
public sealed class JobMetricsConfigurationResponse
```

| Property              | Type      | Description                                                              |
| --------------------- | --------- | ------------------------------------------------------------------------ |
| `Enabled`             | `Boolean` | Whether job metrics export is enabled.                                   |
| `ExportInterval`      | `String`  | The interval at which job metrics are exported, as an ISO 8601 duration. |
| `MaxWorkerNameLength` | `Int32`   | The maximum length of the worker name used in job metrics labels.        |
| `MaxJobTypeLength`    | `Int32`   | The maximum length of the job type used in job metrics labels.           |
| `MaxTenantIdLength`   | `Int32`   | The maximum length of the tenant ID used in job metrics labels.          |
| `MaxUniqueKeys`       | `Int32`   | The maximum number of unique metric keys tracked for job metrics.        |

## JobResult

The result of the completed job as determined by the worker.

```csharp
public abstract class JobResult
```

## JobResultActivateElement

Instruction to activate a single BPMN element within an ad‑hoc sub‑process, optionally providing variables scoped to that element.

```csharp
public sealed class JobResultActivateElement
```

| Property    | Type                  | Description                 |
| ----------- | --------------------- | --------------------------- |
| `ElementId` | `Nullable<ElementId>` | The element ID to activate. |
| `Variables` | `Object`              | Variables for the element.  |

## JobResultAdHocSubProcess

Job result details for an ad‑hoc sub‑process, including elements to activate and flags indicating completion or cancellation behavior.

```csharp
public sealed class JobResultAdHocSubProcess : JobResult
```

| Property                         | Type                             | Description                                                                            |
| -------------------------------- | -------------------------------- | -------------------------------------------------------------------------------------- |
| `ActivateElements`               | `List<JobResultActivateElement>` | Indicates which elements need to be activated in the ad-hoc subprocess.                |
| `IsCompletionConditionFulfilled` | `Nullable<Boolean>`              | Indicates whether the completion condition of the ad-hoc subprocess is fulfilled.      |
| `IsCancelRemainingInstances`     | `Nullable<Boolean>`              | Indicates whether the remaining instances of the ad-hoc subprocess should be canceled. |

## JobResultCorrections

JSON object with attributes that were corrected by the worker.

The following attributes can be corrected, additional attributes will be ignored:

- `assignee` - clear by providing an empty String
- `dueDate` - clear by providing an empty String
- `followUpDate` - clear by providing an empty String
- `candidateGroups` - clear by providing an empty list
- `candidateUsers` - clear by providing an empty list
- `priority` - minimum 0, maximum 100, default 50

Providing any of those attributes with a `null` value or omitting it preserves the persisted attribute's value.

```csharp
public sealed class JobResultCorrections
```

| Property          | Type                       | Description                               |
| ----------------- | -------------------------- | ----------------------------------------- |
| `Assignee`        | `String`                   | Assignee of the task.                     |
| `DueDate`         | `Nullable<DateTimeOffset>` | The due date of the task.                 |
| `FollowUpDate`    | `Nullable<DateTimeOffset>` | The follow-up date of the task.           |
| `CandidateUsers`  | `List<String>`             | The list of candidate users of the task.  |
| `CandidateGroups` | `List<String>`             | The list of candidate groups of the task. |
| `Priority`        | `Nullable<Int32>`          | The priority of the task.                 |

## JobResultUserTask

Job result details for a user task completion, optionally including a denial reason and corrected task properties.

```csharp
public sealed class JobResultUserTask : JobResult
```

| Property       | Type                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| -------------- | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Denied`       | `Nullable<Boolean>`    | Indicates whether the worker denies the work, i.e. explicitly doesn't approve it. For example, a user task listener can deny the completion of a task by setting this flag to true. In this example, the completion of a task is represented by a job that the worker can complete as denied. As a result, the completion request is rejected and the task remains active. Defaults to false.                                                                                                                                                                                            |
| `DeniedReason` | `String`               | The reason provided by the user task listener for denying the work.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Corrections`  | `JobResultCorrections` | JSON object with attributes that were corrected by the worker. The following attributes can be corrected, additional attributes will be ignored: * `assignee` - clear by providing an empty String * `dueDate` - clear by providing an empty String * `followUpDate` - clear by providing an empty String * `candidateGroups` - clear by providing an empty list * `candidateUsers` - clear by providing an empty list * `priority` - minimum 0, maximum 100, default 50 Providing any of those attributes with a `null` value or omitting it preserves the persisted attribute's value. |

## JobSearchQuery

Job search request.

```csharp
public sealed class JobSearchQuery
```

| Property | Type                              | Description             |
| -------- | --------------------------------- | ----------------------- |
| `Sort`   | `List<JobSearchQuerySortRequest>` | Sort field criteria.    |
| `Filter` | `JobFilter`                       | The job search filters. |
| `Page`   | `SearchQueryPageRequest`          | Pagination criteria.    |

## JobSearchQueryResult

Job search response.

```csharp
public sealed class JobSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<JobSearchResult>`   | The matching jobs.                               |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## JobSearchQuerySortRequest

```csharp
public sealed class JobSearchQuerySortRequest
```

| Property | Type                             | Description                                   |
| -------- | -------------------------------- | --------------------------------------------- |
| `Field`  | `JobSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`        | The order in which to sort the related field. |

## JobSearchResult

```csharp
public sealed class JobSearchResult
```

| Property                   | Type                           | Description                                                                                                                                                                                                                                    |
| -------------------------- | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CustomHeaders`            | `Dictionary<String, String>`   | A set of custom headers defined during modelling.                                                                                                                                                                                              |
| `Deadline`                 | `Nullable<DateTimeOffset>`     | If the job has been activated, when it will next be available to be activated.                                                                                                                                                                 |
| `DeniedReason`             | `String`                       | The reason provided by the user task listener for denying the work.                                                                                                                                                                            |
| `ElementId`                | `Nullable<ElementId>`          | The element ID associated with the job. May be missing on job failure.                                                                                                                                                                         |
| `ElementInstanceKey`       | `ElementInstanceKey`           | The element instance key associated with the job.                                                                                                                                                                                              |
| `EndTime`                  | `Nullable<DateTimeOffset>`     | End date of the job. This is `null` if the job is not in an end state yet.                                                                                                                                                                     |
| `ErrorCode`                | `String`                       | The error code provided for a failed job.                                                                                                                                                                                                      |
| `ErrorMessage`             | `String`                       | The error message that provides additional context for a failed job.                                                                                                                                                                           |
| `HasFailedWithRetriesLeft` | `Boolean`                      | Indicates whether the job has failed with retries left.                                                                                                                                                                                        |
| `IsDenied`                 | `Nullable<Boolean>`            | Indicates whether the user task listener denies the work.                                                                                                                                                                                      |
| `JobKey`                   | `JobKey`                       | The key, a unique identifier for the job.                                                                                                                                                                                                      |
| `Kind`                     | `JobKindEnum`                  | The job kind.                                                                                                                                                                                                                                  |
| `ListenerEventType`        | `JobListenerEventTypeEnum`     | The listener event type of the job.                                                                                                                                                                                                            |
| `ProcessDefinitionId`      | `ProcessDefinitionId`          | The process definition ID associated with the job.                                                                                                                                                                                             |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey`         | The process definition key associated with the job.                                                                                                                                                                                            |
| `ProcessInstanceKey`       | `ProcessInstanceKey`           | The process instance key associated with the job.                                                                                                                                                                                              |
| `RootProcessInstanceKey`   | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.    |
| `BusinessId`               | `Nullable<BusinessId>`         | The business ID of the owning process instance, inherited when the job was created. This is `null` for jobs created before version 8.10 and for jobs whose owning process instance has no business ID.                                         |
| `Retries`                  | `Int32`                        | The amount of retries left to this job.                                                                                                                                                                                                        |
| `State`                    | `JobStateEnum`                 | The state of the job.                                                                                                                                                                                                                          |
| `TenantId`                 | `TenantId`                     | The unique identifier of the tenant.                                                                                                                                                                                                           |
| `Type`                     | `String`                       | The type of the job.                                                                                                                                                                                                                           |
| `Worker`                   | `String`                       | The name of the worker of this job.                                                                                                                                                                                                            |
| `CreationTime`             | `Nullable<DateTimeOffset>`     | When the job was created. Field is present for jobs created after 8.9.                                                                                                                                                                         |
| `LastUpdateTime`           | `Nullable<DateTimeOffset>`     | When the job was last updated. Field is present for jobs created after 8.9.                                                                                                                                                                    |
| `Priority`                 | `Int32`                        | The priority of the job. Higher values indicate higher priority. Jobs created before 8.10 have no stored priority; they appear last when sorting by this field and are excluded when filtering by this field. The API returns 0 for such jobs. |

## JobStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct JobStateExactMatch : ICamundaKey, IEquatable<JobStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## JobStateFilterProperty

JobStateEnum property with full advanced search capabilities.

```csharp
public sealed class JobStateFilterProperty
```

| Property     | Type                     | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<JobStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<JobStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<JobStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`      | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<JobStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`   | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## JobTimeSeriesStatisticsFilter

Job time-series statistics search filter.

```csharp
public sealed class JobTimeSeriesStatisticsFilter
```

| Property     | Type             | Description                                                                                                                                             |
| ------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `From`       | `DateTimeOffset` | Start of the time window to filter metrics. ISO 8601 date-time format.                                                                                  |
| `To`         | `DateTimeOffset` | End of the time window to filter metrics. ISO 8601 date-time format.                                                                                    |
| `JobType`    | `String`         | Job type to return time-series metrics for.                                                                                                             |
| `Resolution` | `String`         | Time bucket resolution as an ISO 8601 duration (for example `PT1M` for 1 minute, `PT1H` for 1 hour). If omitted, the server chooses a sensible default. |

## JobTimeSeriesStatisticsItem

Aggregated job metrics for a single time bucket.

```csharp
public sealed class JobTimeSeriesStatisticsItem
```

| Property    | Type             | Description                                                    |
| ----------- | ---------------- | -------------------------------------------------------------- |
| `Time`      | `DateTimeOffset` | ISO 8601 timestamp representing the start of this time bucket. |
| `Created`   | `StatusMetric`   | Metric for a single job status.                                |
| `Completed` | `StatusMetric`   | Metric for a single job status.                                |
| `Failed`    | `StatusMetric`   | Metric for a single job status.                                |

## JobTimeSeriesStatisticsQuery

Job time-series statistics query.

```csharp
public sealed class JobTimeSeriesStatisticsQuery
```

| Property | Type                            | Description                               |
| -------- | ------------------------------- | ----------------------------------------- |
| `Filter` | `JobTimeSeriesStatisticsFilter` | Job time-series statistics search filter. |
| `Page`   | `CursorForwardPagination`       | Search cursor pagination.                 |

## JobTimeSeriesStatisticsQueryResult

Job time-series statistics query result.

```csharp
public sealed class JobTimeSeriesStatisticsQueryResult
```

| Property | Type                                | Description                                                            |
| -------- | ----------------------------------- | ---------------------------------------------------------------------- |
| `Items`  | `List<JobTimeSeriesStatisticsItem>` | The list of time-bucketed statistics items, ordered ascending by time. |
| `Page`   | `SearchQueryPageResponse`           | Pagination information about the search results.                       |

## JobTypeStatisticsFilter

Job type statistics search filter.

```csharp
public sealed class JobTypeStatisticsFilter
```

| Property  | Type                   | Description                                                                                                              |
| --------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `From`    | `DateTimeOffset`       | Start of the time window to filter metrics. ISO 8601 date-time format.                                                   |
| `To`      | `DateTimeOffset`       | End of the time window to filter metrics. ISO 8601 date-time format.                                                     |
| `JobType` | `StringFilterProperty` | Optional job type filter with advanced search capabilities. Supports exact match, pattern matching, and other operators. |

## JobTypeStatisticsItem

Statistics for a single job type.

```csharp
public sealed class JobTypeStatisticsItem
```

| Property    | Type           | Description                                            |
| ----------- | -------------- | ------------------------------------------------------ |
| `JobType`   | `String`       | The job type identifier.                               |
| `Created`   | `StatusMetric` | Metric for a single job status.                        |
| `Completed` | `StatusMetric` | Metric for a single job status.                        |
| `Failed`    | `StatusMetric` | Metric for a single job status.                        |
| `Workers`   | `Int32`        | Number of distinct workers observed for this job type. |

## JobTypeStatisticsQuery

Job type statistics query.

```csharp
public sealed class JobTypeStatisticsQuery
```

| Property | Type                      | Description                        |
| -------- | ------------------------- | ---------------------------------- |
| `Filter` | `JobTypeStatisticsFilter` | Job type statistics search filter. |
| `Page`   | `CursorForwardPagination` | Search cursor pagination.          |

## JobTypeStatisticsQueryResult

Job type statistics query result.

```csharp
public sealed class JobTypeStatisticsQueryResult
```

| Property | Type                          | Description                                      |
| -------- | ----------------------------- | ------------------------------------------------ |
| `Items`  | `List<JobTypeStatisticsItem>` | The list of job type statistics items.           |
| `Page`   | `SearchQueryPageResponse`     | Pagination information about the search results. |

## JobUpdateRequest

```csharp
public sealed class JobUpdateRequest
```

| Property             | Type                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Changeset`          | `JobChangeset`                 | JSON object with changed job attribute values. The job cannot be completed or failed with this endpoint, use the complete job or fail job endpoints instead.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `LeaseToken`         | `String`                       | The token identifying a leased job's activation, obtained from `ActivatedJobResult.leaseToken`. For a leased job, a supplied token is validated to prove the command comes from the worker that holds the current lease; a command carrying a stale token is rejected, fencing the job against a superseded activation (for example, after the job timed out or failed and was re-activated by another worker). An update without a token always applies to support operator and bulk updates of leased jobs. Note that this is different from lifecycle requests like complete, fail, and throw-error that always require a token for leased jobs. A job that was activated without a lease requires no token. |

## JobWaitStateDetails

```csharp
public sealed class JobWaitStateDetails : WaitStateDetails
```

| Property            | Type                                 | Description                                                                                  |
| ------------------- | ------------------------------------ | -------------------------------------------------------------------------------------------- |
| `JobKey`            | `JobKey`                             | The key of the job.                                                                          |
| `JobType`           | `String`                             | The job type (worker subscription identifier).                                               |
| `JobKind`           | `JobKindEnum`                        | The kind of job.                                                                             |
| `ListenerEventType` | `Nullable<JobListenerEventTypeEnum>` | The listener event type of the job (only set for execution listener and task listener jobs). |
| `Retries`           | `Nullable<Int32>`                    | The number of retries remaining for the job.                                                 |

## JobWorker

A long-running worker that polls the Camunda broker for jobs of a specific type, dispatches them to a handler, and auto-completes or auto-fails based on the outcome.

Concurrency model: jobs are dispatched as concurrent `Tasks.Task`s on the .NET thread pool. `JobWorkerConfig.MaxConcurrentJobs` controls how many jobs may be in-flight simultaneously. For async handlers (the typical case), the thread pool thread is released during `await` points, so many jobs can be handled by a small number of OS threads. For CPU-bound handlers, set `MaxConcurrentJobs` to `Environment.ProcessorCount` to match available cores.

```csharp
public sealed class JobWorker : IAsyncDisposable, IDisposable
```

| Property     | Type      | Description                                        |
| ------------ | --------- | -------------------------------------------------- |
| `ActiveJobs` | `Int32`   | Number of jobs currently being processed.          |
| `IsRunning`  | `Boolean` | Whether the poll loop is currently running.        |
| `Name`       | `String`  | The worker's name (auto-generated or from config). |

## JobWorkerStatisticsFilter

Job worker statistics search filter.

```csharp
public sealed class JobWorkerStatisticsFilter
```

| Property  | Type             | Description                                                            |
| --------- | ---------------- | ---------------------------------------------------------------------- |
| `From`    | `DateTimeOffset` | Start of the time window to filter metrics. ISO 8601 date-time format. |
| `To`      | `DateTimeOffset` | End of the time window to filter metrics. ISO 8601 date-time format.   |
| `JobType` | `String`         | Job type to return worker metrics for.                                 |

## JobWorkerStatisticsItem

Statistics for a single worker within a job type.

```csharp
public sealed class JobWorkerStatisticsItem
```

| Property    | Type           | Description                                                                   |
| ----------- | -------------- | ----------------------------------------------------------------------------- |
| `Worker`    | `String`       | The name of the worker activating the jobs, mostly used for logging purposes. |
| `Created`   | `StatusMetric` | Metric for a single job status.                                               |
| `Completed` | `StatusMetric` | Metric for a single job status.                                               |
| `Failed`    | `StatusMetric` | Metric for a single job status.                                               |

## JobWorkerStatisticsQuery

Job worker statistics query.

```csharp
public sealed class JobWorkerStatisticsQuery
```

| Property | Type                        | Description                          |
| -------- | --------------------------- | ------------------------------------ |
| `Filter` | `JobWorkerStatisticsFilter` | Job worker statistics search filter. |
| `Page`   | `CursorForwardPagination`   | Search cursor pagination.            |

## JobWorkerStatisticsQueryResult

Job worker statistics query result.

```csharp
public sealed class JobWorkerStatisticsQueryResult
```

| Property | Type                            | Description                                      |
| -------- | ------------------------------- | ------------------------------------------------ |
| `Items`  | `List<JobWorkerStatisticsItem>` | The list of per-worker statistics items.         |
| `Page`   | `SearchQueryPageResponse`       | Pagination information about the search results. |

## LicenseResponse

The response of a license request.

```csharp
public sealed class LicenseResponse
```

| Property       | Type                       | Description                                                          |
| -------------- | -------------------------- | -------------------------------------------------------------------- |
| `ValidLicense` | `Boolean`                  | True if the Camunda license is valid, false if otherwise             |
| `LicenseType`  | `String`                   | Will return the license type property of the Camunda license         |
| `IsCommercial` | `Boolean`                  | Will be false when a license contains a non-commerical=true property |
| `ExpiresAt`    | `Nullable<DateTimeOffset>` | The date when the Camunda license expires                            |

## LikeFilter

Checks if the property matches the provided like value.

Supported wildcard characters are:

- `*`: matches zero, one, or multiple characters.
- `?`: matches one, single character.

Wildcard characters can be escaped with backslash, for instance: `\*`.

```csharp
public readonly record struct LikeFilter : ICamundaKey, IEquatable<LikeFilter>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## LimitPagination

```csharp
public sealed class LimitPagination : SearchQueryPageRequest
```

| Property | Type              | Description                                           |
| -------- | ----------------- | ----------------------------------------------------- |
| `Limit`  | `Nullable<Int32>` | The maximum number of items to return in one request. |

## LoopIterationId

A client-provided sequential integer identifying one pass through the agent feedback loop: one LLM call, its tool dispatches, and their results. Must be a positive integer, increasing with each loopIteration. Established by the connector when appending the first history item of a loopIteration.

```csharp
public readonly record struct LoopIterationId : ICamundaLongKey, IEquatable<LoopIterationId>
```

| Property | Type    | Description                |
| -------- | ------- | -------------------------- |
| `Value`  | `Int64` | The underlying long value. |

## MappingRuleCreateRequest

```csharp
public sealed class MappingRuleCreateRequest
```

| Property        | Type            | Description                        |
| --------------- | --------------- | ---------------------------------- |
| `MappingRuleId` | `MappingRuleId` | The unique ID of the mapping rule. |
| `ClaimName`     | `String`        | The name of the claim to map.      |
| `ClaimValue`    | `String`        | The value of the claim to map.     |
| `Name`          | `String`        | The name of the mapping rule.      |

## MappingRuleCreateResult

```csharp
public sealed class MappingRuleCreateResult
```

| Property        | Type            | Description                        |
| --------------- | --------------- | ---------------------------------- |
| `ClaimName`     | `String`        | The name of the claim to map.      |
| `ClaimValue`    | `String`        | The value of the claim to map.     |
| `Name`          | `String`        | The name of the mapping rule.      |
| `MappingRuleId` | `MappingRuleId` | The unique ID of the mapping rule. |

## MappingRuleCreateUpdateRequest

```csharp
public sealed class MappingRuleCreateUpdateRequest
```

| Property     | Type     | Description                    |
| ------------ | -------- | ------------------------------ |
| `ClaimName`  | `String` | The name of the claim to map.  |
| `ClaimValue` | `String` | The value of the claim to map. |
| `Name`       | `String` | The name of the mapping rule.  |

## MappingRuleCreateUpdateResult

```csharp
public sealed class MappingRuleCreateUpdateResult
```

| Property        | Type            | Description                        |
| --------------- | --------------- | ---------------------------------- |
| `ClaimName`     | `String`        | The name of the claim to map.      |
| `ClaimValue`    | `String`        | The value of the claim to map.     |
| `Name`          | `String`        | The name of the mapping rule.      |
| `MappingRuleId` | `MappingRuleId` | The unique ID of the mapping rule. |

## MappingRuleFilter

Mapping rule search filter.

```csharp
public sealed class MappingRuleFilter
```

| Property        | Type                      | Description                              |
| --------------- | ------------------------- | ---------------------------------------- |
| `ClaimName`     | `String`                  | The claim name to match against a token. |
| `ClaimValue`    | `String`                  | The value of the claim to match.         |
| `Name`          | `String`                  | The name of the mapping rule.            |
| `MappingRuleId` | `Nullable<MappingRuleId>` | The ID of the mapping rule.              |

## MappingRuleId

The unique identifier of a mapping rule.

```csharp
public readonly record struct MappingRuleId : ICamundaKey, IEquatable<MappingRuleId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## MappingRuleResult

```csharp
public sealed class MappingRuleResult
```

| Property        | Type            | Description                    |
| --------------- | --------------- | ------------------------------ |
| `ClaimName`     | `String`        | The name of the claim to map.  |
| `ClaimValue`    | `String`        | The value of the claim to map. |
| `Name`          | `String`        | The name of the mapping rule.  |
| `MappingRuleId` | `MappingRuleId` | The ID of the mapping rule.    |

## MappingRuleSearchQueryRequest

```csharp
public sealed class MappingRuleSearchQueryRequest
```

| Property | Type                                      | Description                      |
| -------- | ----------------------------------------- | -------------------------------- |
| `Sort`   | `List<MappingRuleSearchQuerySortRequest>` | Sort field criteria.             |
| `Filter` | `MappingRuleFilter`                       | The mapping rule search filters. |
| `Page`   | `SearchQueryPageRequest`                  | Pagination criteria.             |

## MappingRuleSearchQueryResult

```csharp
public sealed class MappingRuleSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<MappingRuleResult>` | The matching mapping rules.                      |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## MappingRuleSearchQuerySortRequest

```csharp
public sealed class MappingRuleSearchQuerySortRequest
```

| Property | Type                                     | Description                                   |
| -------- | ---------------------------------------- | --------------------------------------------- |
| `Field`  | `MappingRuleSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                | The order in which to sort the related field. |

## MappingRuleUpdateRequest

```csharp
public sealed class MappingRuleUpdateRequest
```

| Property     | Type     | Description                    |
| ------------ | -------- | ------------------------------ |
| `ClaimName`  | `String` | The name of the claim to map.  |
| `ClaimValue` | `String` | The value of the claim to map. |
| `Name`       | `String` | The name of the mapping rule.  |

## MappingRuleUpdateResult

```csharp
public sealed class MappingRuleUpdateResult
```

| Property        | Type            | Description                        |
| --------------- | --------------- | ---------------------------------- |
| `ClaimName`     | `String`        | The name of the claim to map.      |
| `ClaimValue`    | `String`        | The value of the claim to map.     |
| `Name`          | `String`        | The name of the mapping rule.      |
| `MappingRuleId` | `MappingRuleId` | The unique ID of the mapping rule. |

## MatchedDecisionRuleItem

A decision rule that matched within this decision evaluation.

```csharp
public sealed class MatchedDecisionRuleItem
```

| Property           | Type                                | Description                     |
| ------------------ | ----------------------------------- | ------------------------------- |
| `RuleId`           | `String`                            | The ID of the matched rule.     |
| `RuleIndex`        | `Int32`                             | The index of the matched rule.  |
| `EvaluatedOutputs` | `List<EvaluatedDecisionOutputItem>` | The evaluated decision outputs. |

## MessageCorrelationRequest

```csharp
public sealed class MessageCorrelationRequest : ITenantIdSettable
```

| Property         | Type                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ---------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`           | `String`               | The message name as defined in the BPMN process                                                                                                                                                                                                                                                                                                                                                                                     |
| `CorrelationKey` | `String`               | The correlation key of the message.                                                                                                                                                                                                                                                                                                                                                                                                 |
| `Variables`      | `Object`               | The message variables as JSON document                                                                                                                                                                                                                                                                                                                                                                                              |
| `TenantId`       | `Nullable<TenantId>`   | the tenant for which the message is published                                                                                                                                                                                                                                                                                                                                                                                       |
| `BusinessId`     | `Nullable<BusinessId>` | An optional business id used to enforce uniqueness of the process instance that a message start event would create. If provided and uniqueness enforcement is enabled, the engine rejects starting a new process instance when another root process instance with the same business id is already active for the same process definition. It has no effect when the message correlates to a catch, boundary, or intermediate event. |

## MessageCorrelationResult

The message key of the correlated message, as well as the first process instance key it correlated with.

```csharp
public sealed class MessageCorrelationResult
```

| Property             | Type                 | Description                                                       |
| -------------------- | -------------------- | ----------------------------------------------------------------- |
| `TenantId`           | `TenantId`           | The tenant ID of the correlated message                           |
| `MessageKey`         | `MessageKey`         | The key of the correlated message.                                |
| `ProcessInstanceKey` | `ProcessInstanceKey` | The key of the first process instance the message correlated with |

## MessagePublicationRequest

```csharp
public sealed class MessagePublicationRequest : ITenantIdSettable
```

| Property         | Type                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ---------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`           | `String`               | The name of the message.                                                                                                                                                                                                                                                                                                                                                                                                            |
| `CorrelationKey` | `String`               | The correlation key of the message.                                                                                                                                                                                                                                                                                                                                                                                                 |
| `TimeToLive`     | `Nullable<Int64>`      | Timespan (in ms) to buffer the message on the broker.                                                                                                                                                                                                                                                                                                                                                                               |
| `MessageId`      | `String`               | The unique ID of the message. This is used to ensure only one message with the given ID will be published during the lifetime of the message (if `timeToLive` is set).                                                                                                                                                                                                                                                              |
| `Variables`      | `Object`               | The message variables as JSON document.                                                                                                                                                                                                                                                                                                                                                                                             |
| `TenantId`       | `Nullable<TenantId>`   | The tenant of the message sender.                                                                                                                                                                                                                                                                                                                                                                                                   |
| `BusinessId`     | `Nullable<BusinessId>` | An optional business id used to enforce uniqueness of the process instance that a message start event would create. If provided and uniqueness enforcement is enabled, the engine rejects starting a new process instance when another root process instance with the same business id is already active for the same process definition. It has no effect when the message correlates to a catch, boundary, or intermediate event. |

## MessagePublicationResult

The message key of the published message.

```csharp
public sealed class MessagePublicationResult
```

| Property     | Type         | Description                       |
| ------------ | ------------ | --------------------------------- |
| `TenantId`   | `TenantId`   | The tenant ID of the message.     |
| `MessageKey` | `MessageKey` | The key of the published message. |

## MessageSubscriptionFilter

Message subscription search filter.

```csharp
public sealed class MessageSubscriptionFilter
```

| Property                   | Type                                     | Description                                                                                                                                                                   |
| -------------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `MessageSubscriptionKey`   | `MessageSubscriptionKeyFilterProperty`   | The message subscription key associated with this message subscription.                                                                                                       |
| `ProcessDefinitionKey`     | `ProcessDefinitionKeyFilterProperty`     | The process definition key associated with this correlated message subscription. This only works for data created with 8.9 and later.                                         |
| `ProcessDefinitionId`      | `StringFilterProperty`                   | The process definition ID associated with this message subscription.                                                                                                          |
| `ProcessInstanceKey`       | `ProcessInstanceKeyFilterProperty`       | The process instance key associated with this message subscription.                                                                                                           |
| `ElementId`                | `StringFilterProperty`                   | The element ID associated with this message subscription.                                                                                                                     |
| `ElementInstanceKey`       | `ElementInstanceKeyFilterProperty`       | The element instance key associated with this message subscription.                                                                                                           |
| `MessageSubscriptionState` | `MessageSubscriptionStateFilterProperty` | The message subscription state.                                                                                                                                               |
| `LastUpdatedDate`          | `DateTimeFilterProperty`                 | The last updated date of the message subscription.                                                                                                                            |
| `MessageName`              | `StringFilterProperty`                   | The name of the message associated with the message subscription.                                                                                                             |
| `CorrelationKey`           | `StringFilterProperty`                   | The correlation key of the message subscription.                                                                                                                              |
| `TenantId`                 | `StringFilterProperty`                   | The unique external tenant ID.                                                                                                                                                |
| `MessageSubscriptionType`  | `MessageSubscriptionTypeFilterProperty`  | The type of message subscription to filter by. When omitted, both `START_EVENT` and `PROCESS_EVENT` are returned. Only available for data created with Camunda 8.10 or later. |
| `ProcessDefinitionName`    | `StringFilterProperty`                   | The name of the process definition associated with this message subscription.                                                                                                 |
| `ProcessDefinitionVersion` | `IntegerFilterProperty`                  | The version of the process definition associated with this message subscription.                                                                                              |
| `ToolName`                 | `StringFilterProperty`                   | Filter by tool name extracted from the `io.camunda.tool:name` zeebe:property.                                                                                                 |
| `InboundConnectorType`     | `StringFilterProperty`                   | Filter by inbound connector type extracted from the `inbound.type` zeebe:property.                                                                                            |

## MessageSubscriptionKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct MessageSubscriptionKeyExactMatch : ICamundaKey, IEquatable<MessageSubscriptionKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## MessageSubscriptionKeyFilterProperty

MessageSubscriptionKey property with full advanced search capabilities.

```csharp
public sealed class MessageSubscriptionKeyFilterProperty
```

| Property     | Type                               | Description                                                                                                                      |
| ------------ | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<MessageSubscriptionKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<MessageSubscriptionKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<MessageSubscriptionKey>` | Checks for equality with the provided value.                                                                                     |
| `Exists`     | `Nullable<Boolean>`                | Checks if the current property exists.                                                                                           |
| `In`         | `List<MessageSubscriptionKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<MessageSubscriptionKey>`     | Checks if the property matches none of the provided values.                                                                      |

## MessageSubscriptionResult

```csharp
public sealed class MessageSubscriptionResult
```

| Property                   | Type                             | Description                                                                                                                                                                                                                                                                                                                      |
| -------------------------- | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `MessageSubscriptionKey`   | `MessageSubscriptionKey`         | The message subscription key associated with this message subscription.                                                                                                                                                                                                                                                          |
| `ProcessDefinitionId`      | `ProcessDefinitionId`            | The process definition ID associated with this message subscription.                                                                                                                                                                                                                                                             |
| `ProcessDefinitionKey`     | `Nullable<ProcessDefinitionKey>` | The process definition key associated with this message subscription.                                                                                                                                                                                                                                                            |
| `ProcessInstanceKey`       | `Nullable<ProcessInstanceKey>`   | The process instance key associated with this message subscription. Only populated for intermediate event entities.                                                                                                                                                                                                              |
| `RootProcessInstanceKey`   | `Nullable<ProcessInstanceKey>`   | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                                                                      |
| `ElementId`                | `ElementId`                      | The element ID associated with this message subscription.                                                                                                                                                                                                                                                                        |
| `ElementInstanceKey`       | `Nullable<ElementInstanceKey>`   | The element instance key associated with this message subscription. Only populated for intermediate event entities.                                                                                                                                                                                                              |
| `MessageSubscriptionState` | `MessageSubscriptionStateEnum`   | The state of message subscription. **Note for `START_EVENT` subscriptions:** The `CORRELATED` and `MIGRATED` states are not tracked for these subscriptions. To query correlation history for process start events, use the `/correlated-message-subscriptions/search` endpoint.                                                 |
| `LastUpdatedDate`          | `DateTimeOffset`                 | The last updated date of the message subscription.                                                                                                                                                                                                                                                                               |
| `MessageName`              | `String`                         | The name of the message associated with the message subscription.                                                                                                                                                                                                                                                                |
| `CorrelationKey`           | `String`                         | The correlation key of the message subscription.                                                                                                                                                                                                                                                                                 |
| `MessageSubscriptionType`  | `MessageSubscriptionTypeEnum`    | The type of message subscription. `START_EVENT` is definition-scoped (process start events). Always has a value; only captured from Camunda 8.10 onwards. `PROCESS_EVENT` is instance-scoped (intermediate catch events). Pre-8.10 entries have no value stored; the API returns `PROCESS_EVENT` as a default for those entries. |
| `ToolProperties`           | `Dictionary<String, String>`     | The subset of `zeebe:properties` extension properties whose keys start with the `io.camunda.tool:` prefix, extracted from the BPMN element associated with this subscription. Empty object when no matching properties are defined.                                                                                              |
| `ProcessDefinitionName`    | `String`                         | The name of the process definition associated with this message subscription.                                                                                                                                                                                                                                                    |
| `ProcessDefinitionVersion` | `Nullable<Int32>`                | The version of the process definition associated with this message subscription.                                                                                                                                                                                                                                                 |
| `ToolName`                 | `String`                         | Tool name extracted from the `io.camunda.tool:name` zeebe:property. Null when the property is absent.                                                                                                                                                                                                                            |
| `InboundConnectorType`     | `String`                         | Inbound connector type extracted from the `inbound.type` zeebe:property. Null when the property is absent.                                                                                                                                                                                                                       |
| `TenantId`                 | `TenantId`                       | The unique identifier of the tenant.                                                                                                                                                                                                                                                                                             |

## MessageSubscriptionSearchQuery

```csharp
public sealed class MessageSubscriptionSearchQuery
```

| Property | Type                                              | Description                  |
| -------- | ------------------------------------------------- | ---------------------------- |
| `Sort`   | `List<MessageSubscriptionSearchQuerySortRequest>` | Sort field criteria.         |
| `Filter` | `MessageSubscriptionFilter`                       | The incident search filters. |
| `Page`   | `SearchQueryPageRequest`                          | Pagination criteria.         |

## MessageSubscriptionSearchQueryResult

```csharp
public sealed class MessageSubscriptionSearchQueryResult
```

| Property | Type                              | Description                                      |
| -------- | --------------------------------- | ------------------------------------------------ |
| `Items`  | `List<MessageSubscriptionResult>` | The matching message subscriptions.              |
| `Page`   | `SearchQueryPageResponse`         | Pagination information about the search results. |

## MessageSubscriptionSearchQuerySortRequest

```csharp
public sealed class MessageSubscriptionSearchQuerySortRequest
```

| Property | Type                                             | Description                                   |
| -------- | ------------------------------------------------ | --------------------------------------------- |
| `Field`  | `MessageSubscriptionSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                        | The order in which to sort the related field. |

## MessageSubscriptionStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct MessageSubscriptionStateExactMatch : ICamundaKey, IEquatable<MessageSubscriptionStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## MessageSubscriptionStateFilterProperty

MessageSubscriptionStateEnum with full advanced search capabilities.

```csharp
public sealed class MessageSubscriptionStateFilterProperty
```

| Property     | Type                                     | Description                                                                                                                                                                                                                                               |
| ------------ | ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<MessageSubscriptionStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<MessageSubscriptionStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<MessageSubscriptionStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                      | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<MessageSubscriptionStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`                   | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## MessageSubscriptionTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct MessageSubscriptionTypeExactMatch : ICamundaKey, IEquatable<MessageSubscriptionTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## MessageSubscriptionTypeFilterProperty

MessageSubscriptionTypeEnum with full advanced search capabilities.

```csharp
public sealed class MessageSubscriptionTypeFilterProperty
```

| Property     | Type                                    | Description                                                                                                                                                                                                                                               |
| ------------ | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<MessageSubscriptionTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<MessageSubscriptionTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<MessageSubscriptionTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                     | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<MessageSubscriptionTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`                  | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## MessageWaitStateDetails

```csharp
public sealed class MessageWaitStateDetails : WaitStateDetails
```

| Property         | Type     | Description                                                               |
| ---------------- | -------- | ------------------------------------------------------------------------- |
| `MessageName`    | `String` | The name of the message being awaited.                                    |
| `CorrelationKey` | `String` | The correlation key for the message subscription (null for start events). |

## MigrateProcessInstanceMappingInstruction

The mapping instructions describe how to map elements from the source process definition to the target process definition.

```csharp
public sealed class MigrateProcessInstanceMappingInstruction
```

| Property          | Type        | Description                     |
| ----------------- | ----------- | ------------------------------- |
| `SourceElementId` | `ElementId` | The element id to migrate from. |
| `TargetElementId` | `ElementId` | The element id to migrate into. |

## ModifyProcessInstanceVariableInstruction

Instruction describing which variables to create or update.

```csharp
public sealed class ModifyProcessInstanceVariableInstruction
```

| Property    | Type     | Description                                                                                                                                                          |
| ----------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Variables` | `Object` | JSON document that will instantiate the variables at the scope defined by the scopeId. It must be a JSON object, as variables will be mapped in a key-value fashion. |
| `ScopeId`   | `String` | The id of the element in which scope the variables should be created. Leave empty to create the variables in the global scope of the process instance.               |

## OffsetPagination

```csharp
public sealed class OffsetPagination : SearchQueryPageRequest
```

| Property | Type              | Description                                           |
| -------- | ----------------- | ----------------------------------------------------- |
| `From`   | `Nullable<Int32>` | The index of items to start searching from.           |
| `Limit`  | `Nullable<Int32>` | The maximum number of items to return in one request. |

## OperationReference

A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided.

```csharp
public readonly record struct OperationReference : ICamundaLongKey, IEquatable<OperationReference>
```

| Property | Type    | Description                |
| -------- | ------- | -------------------------- |
| `Value`  | `Int64` | The underlying long value. |

## OperationTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct OperationTypeExactMatch : ICamundaKey, IEquatable<OperationTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## OperationTypeFilterProperty

AuditLogOperationTypeEnum property with full advanced search capabilities.

```csharp
public sealed class OperationTypeFilterProperty
```

| Property     | Type                                  | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<AuditLogOperationTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<AuditLogOperationTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<AuditLogOperationTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                   | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<AuditLogOperationTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`                | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## Partition

Provides information on a partition within a broker node.

```csharp
public sealed class Partition
```

| Property      | Type              | Description                                                                                |
| ------------- | ----------------- | ------------------------------------------------------------------------------------------ |
| `PartitionId` | `Int32`           | The unique ID of this partition.                                                           |
| `Role`        | `PartitionRole`   | Describes the Raft role of the broker for a given partition.                               |
| `Health`      | `PartitionHealth` | Describes the current health of the partition.                                             |
| `State`       | `PartitionState`  | Describes the current operational state of the partition within the cluster configuration. |

## ProblemDetail

A Problem detail object as described in [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457). There may be additional properties specific to the problem type.

```csharp
public sealed class ProblemDetail
```

| Property   | Type     | Description                                       |
| ---------- | -------- | ------------------------------------------------- |
| `Type`     | `String` | A URI identifying the problem type.               |
| `Title`    | `String` | A summary of the problem type.                    |
| `Status`   | `Int32`  | The HTTP status code for this problem.            |
| `Detail`   | `String` | An explanation of the problem in more detail.     |
| `Instance` | `String` | A URI path identifying the origin of the problem. |

## ProcessDefinitionElementStatisticsQuery

Process definition element statistics request.

```csharp
public sealed class ProcessDefinitionElementStatisticsQuery
```

| Property | Type                                | Description                                       |
| -------- | ----------------------------------- | ------------------------------------------------- |
| `Filter` | `ProcessDefinitionStatisticsFilter` | The process definition statistics search filters. |

## ProcessDefinitionElementStatisticsQueryResult

Process definition element statistics query response.

```csharp
public sealed class ProcessDefinitionElementStatisticsQueryResult
```

| Property | Type                                   | Description             |
| -------- | -------------------------------------- | ----------------------- |
| `Items`  | `List<ProcessElementStatisticsResult>` | The element statistics. |

## ProcessDefinitionFilter

Process definition search filter.

```csharp
public sealed class ProcessDefinitionFilter
```

| Property               | Type                             | Description                                                                                                                                                                                                                                                                                                                                                                                                  |
| ---------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Name`                 | `StringFilterProperty`           | Name of this process definition.                                                                                                                                                                                                                                                                                                                                                                             |
| `IsLatestVersion`      | `Nullable<Boolean>`              | Whether to only return the latest version of each process definition. When using this filter, pagination functionality is limited, you can only paginate forward using `after` and `limit`. The response contains no `startCursor` in the `page`, and requests ignore the `from` and `before` in the `page`. When using this filter, sorting is limited to `processDefinitionId` and `tenantId` fields only. |
| `ResourceName`         | `String`                         | Resource name of this process definition.                                                                                                                                                                                                                                                                                                                                                                    |
| `Version`              | `Nullable<Int32>`                | Version of this process definition.                                                                                                                                                                                                                                                                                                                                                                          |
| `VersionTag`           | `String`                         | Version tag of this process definition.                                                                                                                                                                                                                                                                                                                                                                      |
| `ProcessDefinitionId`  | `StringFilterProperty`           | Process definition ID of this process definition.                                                                                                                                                                                                                                                                                                                                                            |
| `TenantId`             | `Nullable<TenantId>`             | Tenant ID of this process definition.                                                                                                                                                                                                                                                                                                                                                                        |
| `ProcessDefinitionKey` | `Nullable<ProcessDefinitionKey>` | The key for this process definition.                                                                                                                                                                                                                                                                                                                                                                         |
| `HasStartForm`         | `Nullable<Boolean>`              | Indicates whether the start event of the process has an associated Form Key.                                                                                                                                                                                                                                                                                                                                 |
| `IsDeleted`            | `Nullable<Boolean>`              | Filter by whether the process definition has been deleted. When not set, both deleted and non-deleted process definitions are returned. Set to `false` to exclude deleted definitions (recommended for most use cases). Set to `true` to return only deleted definitions that are still retained in secondary storage.                                                                                       |

## ProcessDefinitionId

Id of a process definition, from the model. Only ids of process definitions that are deployed are useful.

```csharp
public readonly record struct ProcessDefinitionId : ICamundaKey, IEquatable<ProcessDefinitionId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ProcessDefinitionIdExactMatch

Matches the value exactly.

```csharp
public readonly record struct ProcessDefinitionIdExactMatch : ICamundaKey, IEquatable<ProcessDefinitionIdExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ProcessDefinitionIdFilterProperty

ProcessDefinitionId property with full advanced search capabilities.

```csharp
public sealed class ProcessDefinitionIdFilterProperty
```

| Property     | Type                            | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ProcessDefinitionId>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<ProcessDefinitionId>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<ProcessDefinitionId>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`             | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<ProcessDefinitionId>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`      | `List<ProcessDefinitionId>`     | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`       | `Nullable<LikeFilter>`          | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## ProcessDefinitionInstanceStatisticsQuery

```csharp
public sealed class ProcessDefinitionInstanceStatisticsQuery
```

| Property | Type                                                        | Description               |
| -------- | ----------------------------------------------------------- | ------------------------- |
| `Page`   | `OffsetPagination`                                          | Search cursor pagination. |
| `Sort`   | `List<ProcessDefinitionInstanceStatisticsQuerySortRequest>` | Sort field criteria.      |

## ProcessDefinitionInstanceStatisticsQueryResult

```csharp
public sealed class ProcessDefinitionInstanceStatisticsQueryResult
```

| Property | Type                                              | Description                                        |
| -------- | ------------------------------------------------- | -------------------------------------------------- |
| `Items`  | `List<ProcessDefinitionInstanceStatisticsResult>` | The process definition instance statistics result. |
| `Page`   | `SearchQueryPageResponse`                         | Pagination information about the search results.   |

## ProcessDefinitionInstanceStatisticsQuerySortRequest

```csharp
public sealed class ProcessDefinitionInstanceStatisticsQuerySortRequest
```

| Property | Type                                                       | Description                                   |
| -------- | ---------------------------------------------------------- | --------------------------------------------- |
| `Field`  | `ProcessDefinitionInstanceStatisticsQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                                  | The order in which to sort the related field. |

## ProcessDefinitionInstanceStatisticsResult

Process definition instance statistics response.

```csharp
public sealed class ProcessDefinitionInstanceStatisticsResult
```

| Property                              | Type                  | Description                                                                                               |
| ------------------------------------- | --------------------- | --------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`                 | `ProcessDefinitionId` | Id of a process definition, from the model. Only ids of process definitions that are deployed are useful. |
| `TenantId`                            | `TenantId`            | The unique identifier of the tenant.                                                                      |
| `LatestProcessDefinitionName`         | `String`              | Name of the latest deployed process definition instance version.                                          |
| `HasMultipleVersions`                 | `Boolean`             | Indicates whether multiple versions of this process definition instance are deployed.                     |
| `ActiveInstancesWithoutIncidentCount` | `Int64`               | Total number of currently active process instances of this definition that do not have incidents.         |
| `ActiveInstancesWithIncidentCount`    | `Int64`               | Total number of currently active process instances of this definition that have at least one incident.    |

## ProcessDefinitionInstanceVersionStatisticsFilter

Process definition instance version statistics search filter.

```csharp
public sealed class ProcessDefinitionInstanceVersionStatisticsFilter
```

| Property              | Type                  | Description                                                          |
| --------------------- | --------------------- | -------------------------------------------------------------------- |
| `ProcessDefinitionId` | `ProcessDefinitionId` | The ID of the process definition to retrieve version statistics for. |
| `TenantId`            | `Nullable<TenantId>`  | Tenant ID of this process definition.                                |

## ProcessDefinitionInstanceVersionStatisticsQuery

```csharp
public sealed class ProcessDefinitionInstanceVersionStatisticsQuery
```

| Property | Type                                                               | Description                                                        |
| -------- | ------------------------------------------------------------------ | ------------------------------------------------------------------ |
| `Page`   | `OffsetPagination`                                                 | Pagination criteria.                                               |
| `Sort`   | `List<ProcessDefinitionInstanceVersionStatisticsQuerySortRequest>` | Sort field criteria.                                               |
| `Filter` | `ProcessDefinitionInstanceVersionStatisticsFilter`                 | The process definition instance version statistics search filters. |

## ProcessDefinitionInstanceVersionStatisticsQueryResult

```csharp
public sealed class ProcessDefinitionInstanceVersionStatisticsQueryResult
```

| Property | Type                                                     | Description                                                |
| -------- | -------------------------------------------------------- | ---------------------------------------------------------- |
| `Items`  | `List<ProcessDefinitionInstanceVersionStatisticsResult>` | The process definition instance version statistics result. |
| `Page`   | `SearchQueryPageResponse`                                | Pagination information about the search results.           |

## ProcessDefinitionInstanceVersionStatisticsQuerySortRequest

```csharp
public sealed class ProcessDefinitionInstanceVersionStatisticsQuerySortRequest
```

| Property | Type                                                              | Description                                   |
| -------- | ----------------------------------------------------------------- | --------------------------------------------- |
| `Field`  | `ProcessDefinitionInstanceVersionStatisticsQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                                         | The order in which to sort the related field. |

## ProcessDefinitionInstanceVersionStatisticsResult

Process definition instance version statistics response.

```csharp
public sealed class ProcessDefinitionInstanceVersionStatisticsResult
```

| Property                              | Type                   | Description                                                                             |
| ------------------------------------- | ---------------------- | --------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`                 | `ProcessDefinitionId`  | The ID associated with the process definition.                                          |
| `ProcessDefinitionKey`                | `ProcessDefinitionKey` | The unique key of the process definition.                                               |
| `ProcessDefinitionName`               | `String`               | The name of the process definition.                                                     |
| `TenantId`                            | `TenantId`             | The tenant ID associated with the process definition.                                   |
| `ProcessDefinitionVersion`            | `Int32`                | The version number of the process definition.                                           |
| `ActiveInstancesWithIncidentCount`    | `Int64`                | The number of active process instances for this version that currently have incidents.  |
| `ActiveInstancesWithoutIncidentCount` | `Int64`                | The number of active process instances for this version that do not have any incidents. |

## ProcessDefinitionKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct ProcessDefinitionKeyExactMatch : ICamundaKey, IEquatable<ProcessDefinitionKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ProcessDefinitionKeyFilterProperty

ProcessDefinitionKey property with full advanced search capabilities.

```csharp
public sealed class ProcessDefinitionKeyFilterProperty
```

| Property     | Type                             | Description                                                                                                                      |
| ------------ | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ProcessDefinitionKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<ProcessDefinitionKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<ProcessDefinitionKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`              | Checks if the current property exists.                                                                                           |
| `In`         | `List<ProcessDefinitionKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<ProcessDefinitionKey>`     | Checks if the property matches none of the provided values.                                                                      |

## ProcessDefinitionMessageSubscriptionStatisticsQuery

```csharp
public sealed class ProcessDefinitionMessageSubscriptionStatisticsQuery
```

| Property | Type                        | Description                       |
| -------- | --------------------------- | --------------------------------- |
| `Page`   | `CursorForwardPagination`   | Search cursor pagination.         |
| `Filter` | `MessageSubscriptionFilter` | The message subscription filters. |

## ProcessDefinitionMessageSubscriptionStatisticsQueryResult

```csharp
public sealed class ProcessDefinitionMessageSubscriptionStatisticsQueryResult
```

| Property | Type                                                         | Description                                                      |
| -------- | ------------------------------------------------------------ | ---------------------------------------------------------------- |
| `Items`  | `List<ProcessDefinitionMessageSubscriptionStatisticsResult>` | The matching process definition message subscription statistics. |
| `Page`   | `SearchQueryPageResponse`                                    | Pagination information about the search results.                 |

## ProcessDefinitionMessageSubscriptionStatisticsResult

```csharp
public sealed class ProcessDefinitionMessageSubscriptionStatisticsResult
```

| Property                                  | Type                   | Description                                                                       |
| ----------------------------------------- | ---------------------- | --------------------------------------------------------------------------------- |
| `ProcessDefinitionId`                     | `ProcessDefinitionId`  | The process definition ID associated with this message subscription.              |
| `TenantId`                                | `TenantId`             | The tenant ID associated with this message subscription.                          |
| `ProcessDefinitionKey`                    | `ProcessDefinitionKey` | The process definition key associated with this message subscription.             |
| `ProcessInstancesWithActiveSubscriptions` | `Int64`                | The number of process instances with active message subscriptions.                |
| `ActiveSubscriptions`                     | `Int64`                | The total number of active message subscriptions for this process definition key. |

## ProcessDefinitionResult

```csharp
public sealed class ProcessDefinitionResult
```

| Property               | Type                   | Description                                                                                  |
| ---------------------- | ---------------------- | -------------------------------------------------------------------------------------------- |
| `Name`                 | `String`               | Name of this process definition.                                                             |
| `ResourceName`         | `String`               | Resource name for this process definition.                                                   |
| `Version`              | `Int32`                | Version of this process definition.                                                          |
| `VersionTag`           | `String`               | Version tag of this process definition.                                                      |
| `ProcessDefinitionId`  | `ProcessDefinitionId`  | Process definition ID of this process definition.                                            |
| `TenantId`             | `TenantId`             | Tenant ID of this process definition.                                                        |
| `ProcessDefinitionKey` | `ProcessDefinitionKey` | The key for this process definition.                                                         |
| `HasStartForm`         | `Boolean`              | Indicates whether the start event of the process has an associated Form Key.                 |
| `IsDeleted`            | `Boolean`              | Whether this process definition has been deleted but is still retained in secondary storage. |

## ProcessDefinitionSearchQuery

```csharp
public sealed class ProcessDefinitionSearchQuery
```

| Property | Type                                            | Description                            |
| -------- | ----------------------------------------------- | -------------------------------------- |
| `Sort`   | `List<ProcessDefinitionSearchQuerySortRequest>` | Sort field criteria.                   |
| `Filter` | `ProcessDefinitionFilter`                       | The process definition search filters. |
| `Page`   | `SearchQueryPageRequest`                        | Pagination criteria.                   |

## ProcessDefinitionSearchQueryResult

```csharp
public sealed class ProcessDefinitionSearchQueryResult
```

| Property | Type                            | Description                                      |
| -------- | ------------------------------- | ------------------------------------------------ |
| `Items`  | `List<ProcessDefinitionResult>` | The matching process definitions.                |
| `Page`   | `SearchQueryPageResponse`       | Pagination information about the search results. |

## ProcessDefinitionSearchQuerySortRequest

```csharp
public sealed class ProcessDefinitionSearchQuerySortRequest
```

| Property | Type                                           | Description                                   |
| -------- | ---------------------------------------------- | --------------------------------------------- |
| `Field`  | `ProcessDefinitionSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                      | The order in which to sort the related field. |

## ProcessDefinitionStatisticsFilter

Process definition statistics search filter.

```csharp
public sealed class ProcessDefinitionStatisticsFilter
```

| Property                     | Type                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ---------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `StartDate`                  | `DateTimeFilterProperty`                | The start date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `EndDate`                    | `DateTimeFilterProperty`                | The end date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `State`                      | `ProcessInstanceStateFilterProperty`    | The process instance state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `HasIncident`                | `Nullable<Boolean>`                     | Whether this process instance has a related incident or not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `TenantId`                   | `StringFilterProperty`                  | The tenant id.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `Variables`                  | `List<VariableValueFilterProperty>`     | The process instance variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ProcessInstanceKey`         | `ProcessInstanceKeyFilterProperty`      | The key of this process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `ParentProcessInstanceKey`   | `ProcessInstanceKeyFilterProperty`      | The parent process instance key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ParentElementInstanceKey`   | `ElementInstanceKeyFilterProperty`      | The parent element instance key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `BatchOperationId`           | `StringFilterProperty`                  | The batch operation id. **Deprecated**: Use `batchOperationKey` instead. This field will be removed in a future release. If both `batchOperationId` and `batchOperationKey` are provided, the request will be rejected with a 400 error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `BatchOperationKey`          | `StringFilterProperty`                  | The batch operation key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `ErrorMessage`               | `StringFilterProperty`                  | The error message related to the process.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `HasRetriesLeft`             | `Nullable<Boolean>`                     | Whether the process has failed jobs with retries left.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ElementInstanceState`       | `ElementInstanceStateFilterProperty`    | The state of the element instances associated with the process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `ElementId`                  | `StringFilterProperty`                  | The element id associated with the process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `HasElementInstanceIncident` | `Nullable<Boolean>`                     | Whether the element instance has an incident or not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `IncidentErrorHashCode`      | `IntegerFilterProperty`                 | The incident error hash code, associated with this process.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Tags`                       | `List<Tag>`                             | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `BusinessId`                 | `StringFilterProperty`                  | The business id associated with the process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `Or`                         | `List<BaseProcessInstanceFilterFields>` | Defines a list of alternative filter groups combined using OR logic. Each object in the array is evaluated independently, and the filter matches if any one of them is satisfied. Top-level fields and the `$or` clause are combined using AND logic — meaning: (top-level filters) AND (any of the `$or` filters) must match.  Example: `json {   "state": "ACTIVE",   "tenantId": 123,   "$or": [     { "processDefinitionId": "process_v1" },     { "processDefinitionId": "process_v2", "hasIncident": true }   ] } ` This matches process instances that:  are in ACTIVE state have tenant id equal to 123 and match either:  <code>processDefinitionId</code> is process_v1, or <code>processDefinitionId</code> is process_v2 and <code>hasIncident</code> is true     Note: Using complex <code>$or</code> conditions may impact performance, use with caution in high-volume environments. |

## ProcessDefinitionVariableNameFilter

Process definition variable name filter request.

```csharp
public sealed class ProcessDefinitionVariableNameFilter
```

| Property | Type                   | Description                      |
| -------- | ---------------------- | -------------------------------- |
| `Name`   | `StringFilterProperty` | The variable name search filter. |

## ProcessDefinitionVariableNameSearchQuery

Process definition variable name search query request.

```csharp
public sealed class ProcessDefinitionVariableNameSearchQuery
```

| Property | Type                                  | Description                                          |
| -------- | ------------------------------------- | ---------------------------------------------------- |
| `Filter` | `ProcessDefinitionVariableNameFilter` | The process definition variable name search filters. |
| `Page`   | `SearchQueryPageRequest`              | Pagination criteria.                                 |

## ProcessDefinitionVariableNameSearchQueryResult

Process definition variable name search query response.

```csharp
public sealed class ProcessDefinitionVariableNameSearchQueryResult
```

| Property | Type                                              | Description                                      |
| -------- | ------------------------------------------------- | ------------------------------------------------ |
| `Items`  | `List<ProcessDefinitionVariableNameSearchResult>` | The matching variable names.                     |
| `Page`   | `SearchQueryPageResponse`                         | Pagination information about the search results. |

## ProcessDefinitionVariableNameSearchResult

Process definition variable name search response item.

```csharp
public sealed class ProcessDefinitionVariableNameSearchResult
```

| Property | Type     | Description        |
| -------- | -------- | ------------------ |
| `Name`   | `String` | The variable name. |

## ProcessElementStatisticsResult

Process element statistics response.

```csharp
public sealed class ProcessElementStatisticsResult
```

| Property    | Type        | Description                                             |
| ----------- | ----------- | ------------------------------------------------------- |
| `ElementId` | `ElementId` | The element ID for which the results are aggregated.    |
| `Active`    | `Int64`     | The total number of active instances of the element.    |
| `Canceled`  | `Int64`     | The total number of canceled instances of the element.  |
| `Incidents` | `Int64`     | The total number of incidents for the element.          |
| `Completed` | `Int64`     | The total number of completed instances of the element. |

## ProcessInstanceBusinessIdAssignmentInstruction

The instruction describing the business id to assign to a running process instance.

```csharp
public sealed class ProcessInstanceBusinessIdAssignmentInstruction
```

| Property     | Type         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ------------ | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `BusinessId` | `BusinessId` | An optional, user-defined string identifier that identifies the process instance within the scope of a process definition (scoped by tenant). If provided and uniqueness enforcement is enabled, the engine will reject creation if another root process instance with the same business id is already active for the same process definition. Note that any active child process instances with the same business id are not taken into account. |

## ProcessInstanceCallHierarchyEntry

```csharp
public sealed class ProcessInstanceCallHierarchyEntry
```

| Property                | Type                   | Description                                                                                    |
| ----------------------- | ---------------------- | ---------------------------------------------------------------------------------------------- |
| `ProcessInstanceKey`    | `ProcessInstanceKey`   | The key of the process instance.                                                               |
| `ProcessDefinitionKey`  | `ProcessDefinitionKey` | The key of the process definition.                                                             |
| `ProcessDefinitionName` | `String`               | The name of the process definition (fall backs to the process definition id if not available). |

## ProcessInstanceCancellationBatchOperationRequest

The process instance filter that defines which process instances should be canceled.

```csharp
public sealed class ProcessInstanceCancellationBatchOperationRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`        | The process instance filter.                                                                                                |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceCreationInstruction

Instructions for creating a process instance. The process definition can be specified either by id or by key.

```csharp
public abstract class ProcessInstanceCreationInstruction
```

## ProcessInstanceCreationInstructionById

```csharp
public sealed class ProcessInstanceCreationInstructionById : ProcessInstanceCreationInstruction, ITenantIdSettable
```

| Property                   | Type                                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| -------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`      | `ProcessDefinitionId`                             | The BPMN process id of the process definition to start an instance of.                                                                                                                                                                                                                                                                                                                                                                            |
| `ProcessDefinitionVersion` | `Nullable<Int32>`                                 | The version of the process. By default, the latest version of the process is used.                                                                                                                                                                                                                                                                                                                                                                |
| `Variables`                | `Object`                                          | JSON object that will instantiate the variables for the root variable scope of the process instance.                                                                                                                                                                                                                                                                                                                                              |
| `TenantId`                 | `Nullable<TenantId>`                              | The tenant id of the process definition. If multi-tenancy is enabled, provide the tenant id of the process definition to start a process instance of. If multi-tenancy is disabled, don't provide this parameter.                                                                                                                                                                                                                                 |
| `OperationReference`       | `Nullable<OperationReference>`                    | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided.                                                                                                                                                                                                                                                                                                                       |
| `StartInstructions`        | `List<ProcessInstanceCreationStartInstruction>`   | List of start instructions. By default, the process instance will start at the start event. If provided, the process instance will apply start instructions after it has been created.                                                                                                                                                                                                                                                            |
| `RuntimeInstructions`      | `List<ProcessInstanceCreationRuntimeInstruction>` | Runtime instructions (alpha). List of instructions that affect the runtime behavior of the process instance. Refer to specific instruction types for more details. This parameter is an alpha feature and may be subject to change in future releases.                                                                                                                                                                                            |
| `AwaitCompletion`          | `Nullable<Boolean>`                               | Wait for the process instance to complete. If the process instance does not complete within the request timeout limit, a 504 response status will be returned. The process instance will continue to run in the background regardless of the timeout. Disabled by default.                                                                                                                                                                        |
| `FetchVariables`           | `List<String>`                                    | List of variables by name to be included in the response when awaitCompletion is set to true. If empty, all visible variables in the root scope will be returned.                                                                                                                                                                                                                                                                                 |
| `RequestTimeout`           | `Nullable<Int64>`                                 | Timeout (in ms) the request waits for the process to complete. By default or when set to 0, the generic request timeout configured in the cluster is applied.                                                                                                                                                                                                                                                                                     |
| `Tags`                     | `List<Tag>`                                       | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                                                                                                                                                                                                                          |
| `BusinessId`               | `Nullable<BusinessId>`                            | An optional, user-defined string identifier that identifies the process instance within the scope of a process definition (scoped by tenant). If provided and uniqueness enforcement is enabled, the engine will reject creation if another root process instance with the same business id is already active for the same process definition. Note that any active child process instances with the same business id are not taken into account. |

## ProcessInstanceCreationInstructionByKey

```csharp
public sealed class ProcessInstanceCreationInstructionByKey : ProcessInstanceCreationInstruction, ITenantIdSettable
```

| Property                   | Type                                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| -------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey`                            | The unique key identifying the process definition, for example, returned for a process in the deploy resources endpoint.                                                                                                                                                                                                                                                                                                                          |
| `ProcessDefinitionVersion` | `Nullable<Int32>`                                 | As the version is already identified by the `processDefinitionKey`, the value of this field is ignored. It's here for backwards-compatibility only as previous releases accepted it in request bodies.                                                                                                                                                                                                                                            |
| `Variables`                | `Object`                                          | Set of variables as JSON object to instantiate in the root variable scope of the process instance. Can include nested complex objects.                                                                                                                                                                                                                                                                                                            |
| `StartInstructions`        | `List<ProcessInstanceCreationStartInstruction>`   | List of start instructions. By default, the process instance will start at the start event. If provided, the process instance will apply start instructions after it has been created.                                                                                                                                                                                                                                                            |
| `RuntimeInstructions`      | `List<ProcessInstanceCreationRuntimeInstruction>` | Runtime instructions (alpha). List of instructions that affect the runtime behavior of the process instance. Refer to specific instruction types for more details. This parameter is an alpha feature and may be subject to change in future releases.                                                                                                                                                                                            |
| `TenantId`                 | `Nullable<TenantId>`                              | The tenant id of the process definition. If multi-tenancy is enabled, provide the tenant id of the process definition to start a process instance of. If multi-tenancy is disabled, don't provide this parameter.                                                                                                                                                                                                                                 |
| `OperationReference`       | `Nullable<OperationReference>`                    | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided.                                                                                                                                                                                                                                                                                                                       |
| `AwaitCompletion`          | `Nullable<Boolean>`                               | Wait for the process instance to complete. If the process instance does not complete within the request timeout limit, a 504 response status will be returned. The process instance will continue to run in the background regardless of the timeout. Disabled by default.                                                                                                                                                                        |
| `RequestTimeout`           | `Nullable<Int64>`                                 | Timeout (in ms) the request waits for the process to complete. By default or when set to 0, the generic request timeout configured in the cluster is applied.                                                                                                                                                                                                                                                                                     |
| `FetchVariables`           | `List<String>`                                    | List of variables by name to be included in the response when awaitCompletion is set to true. If empty, all visible variables in the root scope will be returned.                                                                                                                                                                                                                                                                                 |
| `Tags`                     | `List<Tag>`                                       | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                                                                                                                                                                                                                          |
| `BusinessId`               | `Nullable<BusinessId>`                            | An optional, user-defined string identifier that identifies the process instance within the scope of a process definition (scoped by tenant). If provided and uniqueness enforcement is enabled, the engine will reject creation if another root process instance with the same business id is already active for the same process definition. Note that any active child process instances with the same business id are not taken into account. |

## ProcessInstanceCreationRuntimeInstruction

```csharp
public abstract class ProcessInstanceCreationRuntimeInstruction
```

## ProcessInstanceCreationStartInstruction

```csharp
public sealed class ProcessInstanceCreationStartInstruction
```

| Property    | Type        | Description                                                                                                                                                                                                                  |
| ----------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ElementId` | `ElementId` | Future extensions might include: - different types of start instructions - ability to set local variables for different flow scopes For now, however, the start instruction is implicitly a "startBeforeElement" instruction |

## ProcessInstanceCreationTerminateInstruction

Terminates the process instance after a specific BPMN element is completed or terminated.

```csharp
public sealed class ProcessInstanceCreationTerminateInstruction : ProcessInstanceCreationRuntimeInstruction
```

| Property         | Type        | Description                                                                                        |
| ---------------- | ----------- | -------------------------------------------------------------------------------------------------- |
| `AfterElementId` | `ElementId` | The id of the element that, once completed or terminated, will cause the process to be terminated. |

## ProcessInstanceDeletionBatchOperationRequest

The process instance filter that defines which process instances should be deleted.

```csharp
public sealed class ProcessInstanceDeletionBatchOperationRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`        | The process instance filter.                                                                                                |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceElementStatisticsQueryResult

Process instance element statistics query response.

```csharp
public sealed class ProcessInstanceElementStatisticsQueryResult
```

| Property | Type                                   | Description             |
| -------- | -------------------------------------- | ----------------------- |
| `Items`  | `List<ProcessElementStatisticsResult>` | The element statistics. |

## ProcessInstanceFilter

Process instance search filter.

```csharp
public sealed class ProcessInstanceFilter
```

| Property                      | Type                                 | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ProcessDefinitionId`         | `StringFilterProperty`               | The process definition id.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `ProcessDefinitionName`       | `StringFilterProperty`               | The process definition name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `ProcessDefinitionVersion`    | `IntegerFilterProperty`              | The process definition version.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ProcessDefinitionVersionTag` | `StringFilterProperty`               | The process definition version tag.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `ProcessDefinitionKey`        | `ProcessDefinitionKeyFilterProperty` | The process definition key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `StartDate`                   | `DateTimeFilterProperty`             | The start date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `EndDate`                     | `DateTimeFilterProperty`             | The end date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `State`                       | `ProcessInstanceStateFilterProperty` | The process instance state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `HasIncident`                 | `Nullable<Boolean>`                  | Whether this process instance has a related incident or not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `TenantId`                    | `StringFilterProperty`               | The tenant id.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `Variables`                   | `List<VariableValueFilterProperty>`  | The process instance variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `ProcessInstanceKey`          | `ProcessInstanceKeyFilterProperty`   | The key of this process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `ParentProcessInstanceKey`    | `ProcessInstanceKeyFilterProperty`   | The parent process instance key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ParentElementInstanceKey`    | `ElementInstanceKeyFilterProperty`   | The parent element instance key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `BatchOperationId`            | `StringFilterProperty`               | The batch operation id. **Deprecated**: Use `batchOperationKey` instead. This field will be removed in a future release. If both `batchOperationId` and `batchOperationKey` are provided, the request will be rejected with a 400 error.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `BatchOperationKey`           | `StringFilterProperty`               | The batch operation key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `ErrorMessage`                | `StringFilterProperty`               | The error message related to the process.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `HasRetriesLeft`              | `Nullable<Boolean>`                  | Whether the process has failed jobs with retries left.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ElementInstanceState`        | `ElementInstanceStateFilterProperty` | The state of the element instances associated with the process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `ElementId`                   | `StringFilterProperty`               | The element id associated with the process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `HasElementInstanceIncident`  | `Nullable<Boolean>`                  | Whether the element instance has an incident or not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `IncidentErrorHashCode`       | `IntegerFilterProperty`              | The incident error hash code, associated with this process.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Tags`                        | `List<Tag>`                          | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `BusinessId`                  | `StringFilterProperty`               | The business id associated with the process instance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `Or`                          | `List<ProcessInstanceFilterFields>`  | Defines a list of alternative filter groups combined using OR logic. Each object in the array is evaluated independently, and the filter matches if any one of them is satisfied. Top-level fields and the `$or` clause are combined using AND logic — meaning: (top-level filters) AND (any of the `$or` filters) must match.  Example: `json {   "state": "ACTIVE",   "tenantId": 123,   "$or": [     { "processDefinitionId": "process_v1" },     { "processDefinitionId": "process_v2", "hasIncident": true }   ] } ` This matches process instances that:  are in ACTIVE state have tenant id equal to 123 and match either:  <code>processDefinitionId</code> is process_v1, or <code>processDefinitionId</code> is process_v2 and <code>hasIncident</code> is true     Note: Using complex <code>$or</code> conditions may impact performance, use with caution in high-volume environments. |

## ProcessInstanceFilterFields

Process instance search filter.

```csharp
public sealed class ProcessInstanceFilterFields
```

| Property                      | Type                                 | Description                                                                                                                                                                                                                              |
| ----------------------------- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`         | `StringFilterProperty`               | The process definition id.                                                                                                                                                                                                               |
| `ProcessDefinitionName`       | `StringFilterProperty`               | The process definition name.                                                                                                                                                                                                             |
| `ProcessDefinitionVersion`    | `IntegerFilterProperty`              | The process definition version.                                                                                                                                                                                                          |
| `ProcessDefinitionVersionTag` | `StringFilterProperty`               | The process definition version tag.                                                                                                                                                                                                      |
| `ProcessDefinitionKey`        | `ProcessDefinitionKeyFilterProperty` | The process definition key.                                                                                                                                                                                                              |
| `StartDate`                   | `DateTimeFilterProperty`             | The start date.                                                                                                                                                                                                                          |
| `EndDate`                     | `DateTimeFilterProperty`             | The end date.                                                                                                                                                                                                                            |
| `State`                       | `ProcessInstanceStateFilterProperty` | The process instance state.                                                                                                                                                                                                              |
| `HasIncident`                 | `Nullable<Boolean>`                  | Whether this process instance has a related incident or not.                                                                                                                                                                             |
| `TenantId`                    | `StringFilterProperty`               | The tenant id.                                                                                                                                                                                                                           |
| `Variables`                   | `List<VariableValueFilterProperty>`  | The process instance variables.                                                                                                                                                                                                          |
| `ProcessInstanceKey`          | `ProcessInstanceKeyFilterProperty`   | The key of this process instance.                                                                                                                                                                                                        |
| `ParentProcessInstanceKey`    | `ProcessInstanceKeyFilterProperty`   | The parent process instance key.                                                                                                                                                                                                         |
| `ParentElementInstanceKey`    | `ElementInstanceKeyFilterProperty`   | The parent element instance key.                                                                                                                                                                                                         |
| `BatchOperationId`            | `StringFilterProperty`               | The batch operation id. **Deprecated**: Use `batchOperationKey` instead. This field will be removed in a future release. If both `batchOperationId` and `batchOperationKey` are provided, the request will be rejected with a 400 error. |
| `BatchOperationKey`           | `StringFilterProperty`               | The batch operation key.                                                                                                                                                                                                                 |
| `ErrorMessage`                | `StringFilterProperty`               | The error message related to the process.                                                                                                                                                                                                |
| `HasRetriesLeft`              | `Nullable<Boolean>`                  | Whether the process has failed jobs with retries left.                                                                                                                                                                                   |
| `ElementInstanceState`        | `ElementInstanceStateFilterProperty` | The state of the element instances associated with the process instance.                                                                                                                                                                 |
| `ElementId`                   | `StringFilterProperty`               | The element id associated with the process instance.                                                                                                                                                                                     |
| `HasElementInstanceIncident`  | `Nullable<Boolean>`                  | Whether the element instance has an incident or not.                                                                                                                                                                                     |
| `IncidentErrorHashCode`       | `IntegerFilterProperty`              | The incident error hash code, associated with this process.                                                                                                                                                                              |
| `Tags`                        | `List<Tag>`                          | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                 |
| `BusinessId`                  | `StringFilterProperty`               | The business id associated with the process instance.                                                                                                                                                                                    |

## ProcessInstanceIncidentResolutionBatchOperationRequest

The process instance filter that defines which process instances should have their incidents resolved.

```csharp
public sealed class ProcessInstanceIncidentResolutionBatchOperationRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`        | The process instance filter.                                                                                                |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct ProcessInstanceKeyExactMatch : ICamundaKey, IEquatable<ProcessInstanceKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ProcessInstanceKeyFilterProperty

ProcessInstanceKey property with full advanced search capabilities.

```csharp
public sealed class ProcessInstanceKeyFilterProperty
```

| Property     | Type                           | Description                                                                                                                      |
| ------------ | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ProcessInstanceKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<ProcessInstanceKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<ProcessInstanceKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`            | Checks if the current property exists.                                                                                           |
| `In`         | `List<ProcessInstanceKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<ProcessInstanceKey>`     | Checks if the property matches none of the provided values.                                                                      |

## ProcessInstanceMigrationBatchOperationPlan

The migration instructions describe how to migrate a process instance from one process definition to another.

```csharp
public sealed class ProcessInstanceMigrationBatchOperationPlan
```

| Property                     | Type                                             | Description                        |
| ---------------------------- | ------------------------------------------------ | ---------------------------------- |
| `TargetProcessDefinitionKey` | `ProcessDefinitionKey`                           | The target process definition key. |
| `MappingInstructions`        | `List<MigrateProcessInstanceMappingInstruction>` | The mapping instructions.          |

## ProcessInstanceMigrationBatchOperationRequest

```csharp
public sealed class ProcessInstanceMigrationBatchOperationRequest
```

| Property             | Type                                         | Description                                                                                                                 |
| -------------------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`                      | The process instance filter.                                                                                                |
| `MigrationPlan`      | `ProcessInstanceMigrationBatchOperationPlan` | The migration plan.                                                                                                         |
| `OperationReference` | `Nullable<OperationReference>`               | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceMigrationInstruction

The migration instructions describe how to migrate a process instance from one process definition to another.

```csharp
public sealed class ProcessInstanceMigrationInstruction
```

| Property                     | Type                                             | Description                                                                                                                 |
| ---------------------------- | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `TargetProcessDefinitionKey` | `ProcessDefinitionKey`                           | The key of process definition to migrate the process instance to.                                                           |
| `MappingInstructions`        | `List<MigrateProcessInstanceMappingInstruction>` | Element mappings from the source process instance to the target process instance.                                           |
| `OperationReference`         | `Nullable<OperationReference>`                   | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceModificationActivateInstruction

Instruction describing an element to activate.

```csharp
public sealed class ProcessInstanceModificationActivateInstruction
```

| Property                     | Type                                             | Description                                                                                                                                                                                                                                                                                                   |
| ---------------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ElementId`                  | `ElementId`                                      | The id of the element to activate.                                                                                                                                                                                                                                                                            |
| `VariableInstructions`       | `List<ModifyProcessInstanceVariableInstruction>` | Instructions describing which variables to create or update.                                                                                                                                                                                                                                                  |
| `AncestorElementInstanceKey` | `Nullable<ElementInstanceKey>`                   | The key of the ancestor scope the element instance should be created in. Set to -1 to create the new element instance within an existing element instance of the flow scope. If multiple instances of the target element's flow scope exist, choose one specifically with this property by providing its key. |

## ProcessInstanceModificationBatchOperationRequest

The process instance filter to define on which process instances tokens should be moved, and new element instances should be activated or terminated.

```csharp
public sealed class ProcessInstanceModificationBatchOperationRequest
```

| Property             | Type                                                             | Description                                                                                                                 |
| -------------------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`                                          | The process instance filter.                                                                                                |
| `MoveInstructions`   | `List<ProcessInstanceModificationMoveBatchOperationInstruction>` | Instructions for moving tokens between elements.                                                                            |
| `OperationReference` | `Nullable<OperationReference>`                                   | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceModificationInstruction

```csharp
public sealed class ProcessInstanceModificationInstruction
```

| Property                | Type                                                    | Description                                                                                                                 |
| ----------------------- | ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference`    | `Nullable<OperationReference>`                          | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |
| `ActivateInstructions`  | `List<ProcessInstanceModificationActivateInstruction>`  | Instructions describing which elements to activate in which scopes and which variables to create or update.                 |
| `MoveInstructions`      | `List<ProcessInstanceModificationMoveInstruction>`      | Instructions describing which elements to move from one scope to another.                                                   |
| `TerminateInstructions` | `List<ProcessInstanceModificationTerminateInstruction>` | Instructions describing which elements to terminate.                                                                        |

## ProcessInstanceModificationMoveBatchOperationInstruction

Instructions describing a move operation. This instruction will terminate all active element instances at `sourceElementId` and activate a new element instance for each terminated one at `targetElementId`. The new element instances are created in the parent scope of the source element instances.

```csharp
public sealed class ProcessInstanceModificationMoveBatchOperationInstruction
```

| Property          | Type        | Description            |
| ----------------- | ----------- | ---------------------- |
| `SourceElementId` | `ElementId` | The source element ID. |
| `TargetElementId` | `ElementId` | The target element ID. |

## ProcessInstanceModificationMoveInstruction

Instruction describing a move operation. This instruction will terminate active element instances based on the sourceElementInstruction and activate a new element instance for each terminated one at targetElementId. Note that, for multi-instance activities, only the multi-instance body instances will activate new element instances at the target id.

```csharp
public sealed class ProcessInstanceModificationMoveInstruction
```

| Property                   | Type                                             | Description                                                                                                                                                               |
| -------------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SourceElementInstruction` | `SourceElementInstruction`                       | Defines the source element identifier for the move instruction. It can either be a sourceElementId, or sourceElementInstanceKey.                                          |
| `TargetElementId`          | `ElementId`                                      | The target element id.                                                                                                                                                    |
| `AncestorScopeInstruction` | `AncestorScopeInstruction`                       | Defines the ancestor scope for the created element instances. The default behavior resembles a "direct" scope instruction with an `ancestorElementInstanceKey` of `"-1"`. |
| `VariableInstructions`     | `List<ModifyProcessInstanceVariableInstruction>` | Instructions describing which variables to create or update.                                                                                                              |

## ProcessInstanceModificationTerminateByIdInstruction

Instruction describing which elements to terminate. The element instances are determined at runtime by the given id.

```csharp
public sealed class ProcessInstanceModificationTerminateByIdInstruction : ProcessInstanceModificationTerminateInstruction
```

| Property    | Type        | Description                                                                           |
| ----------- | ----------- | ------------------------------------------------------------------------------------- |
| `ElementId` | `ElementId` | The id of the elements to terminate. The element instances are determined at runtime. |

## ProcessInstanceModificationTerminateByKeyInstruction

Instruction providing the key of the element instance to terminate.

```csharp
public sealed class ProcessInstanceModificationTerminateByKeyInstruction : ProcessInstanceModificationTerminateInstruction
```

| Property             | Type                 | Description                                   |
| -------------------- | -------------------- | --------------------------------------------- |
| `ElementInstanceKey` | `ElementInstanceKey` | The key of the element instance to terminate. |

## ProcessInstanceModificationTerminateInstruction

Instruction describing which elements to terminate.

```csharp
public abstract class ProcessInstanceModificationTerminateInstruction
```

## ProcessInstanceReference

```csharp
public sealed class ProcessInstanceReference
```

| Property               | Type                   | Description                              |
| ---------------------- | ---------------------- | ---------------------------------------- |
| `ProcessDefinitionKey` | `ProcessDefinitionKey` | The key of the process definition.       |
| `ProcessInstanceKey`   | `ProcessInstanceKey`   | The key of the created process instance. |

## ProcessInstanceResult

Process instance search response item.

```csharp
public sealed class ProcessInstanceResult
```

| Property                      | Type                           | Description                                                                                                                                                                                                                                 |
| ----------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ProcessDefinitionId`         | `ProcessDefinitionId`          | Id of a process definition, from the model. Only ids of process definitions that are deployed are useful.                                                                                                                                   |
| `ProcessDefinitionName`       | `String`                       | The process definition name.                                                                                                                                                                                                                |
| `ProcessDefinitionVersion`    | `Int32`                        | The process definition version.                                                                                                                                                                                                             |
| `ProcessDefinitionVersionTag` | `String`                       | The process definition version tag.                                                                                                                                                                                                         |
| `StartDate`                   | `DateTimeOffset`               | The start time of the process instance.                                                                                                                                                                                                     |
| `EndDate`                     | `Nullable<DateTimeOffset>`     | The completion or termination time of the process instance.                                                                                                                                                                                 |
| `State`                       | `ProcessInstanceStateEnum`     | Process instance states                                                                                                                                                                                                                     |
| `HasIncident`                 | `Boolean`                      | Whether this process instance has a related incident or not.                                                                                                                                                                                |
| `TenantId`                    | `TenantId`                     | The unique identifier of the tenant.                                                                                                                                                                                                        |
| `ProcessInstanceKey`          | `ProcessInstanceKey`           | The key of this process instance.                                                                                                                                                                                                           |
| `ProcessDefinitionKey`        | `ProcessDefinitionKey`         | The process definition key.                                                                                                                                                                                                                 |
| `ParentProcessInstanceKey`    | `Nullable<ProcessInstanceKey>` | The parent process instance key.                                                                                                                                                                                                            |
| `ParentElementInstanceKey`    | `Nullable<ElementInstanceKey>` | The parent element instance key.                                                                                                                                                                                                            |
| `RootProcessInstanceKey`      | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `Tags`                        | `List<Tag>`                    | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                    |
| `BusinessId`                  | `Nullable<BusinessId>`         | The business id associated with this process instance.                                                                                                                                                                                      |

## ProcessInstanceResumptionBatchOperationRequest

The process instance filter that defines which process instances should be resumed.

```csharp
public sealed class ProcessInstanceResumptionBatchOperationRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`        | The process instance filter.                                                                                                |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceSearchQuery

Process instance search request.

```csharp
public sealed class ProcessInstanceSearchQuery
```

| Property | Type                                          | Description                          |
| -------- | --------------------------------------------- | ------------------------------------ |
| `Sort`   | `List<ProcessInstanceSearchQuerySortRequest>` | Sort field criteria.                 |
| `Filter` | `ProcessInstanceFilter`                       | The process instance search filters. |
| `Page`   | `SearchQueryPageRequest`                      | Pagination criteria.                 |

## ProcessInstanceSearchQueryResult

Process instance search response.

```csharp
public sealed class ProcessInstanceSearchQueryResult
```

| Property | Type                          | Description                                      |
| -------- | ----------------------------- | ------------------------------------------------ |
| `Items`  | `List<ProcessInstanceResult>` | The matching process instances.                  |
| `Page`   | `SearchQueryPageResponse`     | Pagination information about the search results. |

## ProcessInstanceSearchQuerySortRequest

```csharp
public sealed class ProcessInstanceSearchQuerySortRequest
```

| Property | Type                                         | Description                                   |
| -------- | -------------------------------------------- | --------------------------------------------- |
| `Field`  | `ProcessInstanceSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                    | The order in which to sort the related field. |

## ProcessInstanceSequenceFlowResult

Process instance sequence flow result.

```csharp
public sealed class ProcessInstanceSequenceFlowResult
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                 |
| ------------------------ | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SequenceFlowId`         | `String`                       | The sequence flow id.                                                                                                                                                                                                                       |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The key of this process instance.                                                                                                                                                                                                           |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `ProcessDefinitionKey`   | `ProcessDefinitionKey`         | The process definition key.                                                                                                                                                                                                                 |
| `ProcessDefinitionId`    | `ProcessDefinitionId`          | The process definition id.                                                                                                                                                                                                                  |
| `ElementId`              | `ElementId`                    | The element id for this sequence flow, as provided in the BPMN process.                                                                                                                                                                     |
| `TenantId`               | `TenantId`                     | The unique identifier of the tenant.                                                                                                                                                                                                        |

## ProcessInstanceSequenceFlowsQueryResult

Process instance sequence flows query response.

```csharp
public sealed class ProcessInstanceSequenceFlowsQueryResult
```

| Property | Type                                      | Description         |
| -------- | ----------------------------------------- | ------------------- |
| `Items`  | `List<ProcessInstanceSequenceFlowResult>` | The sequence flows. |

## ProcessInstanceStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct ProcessInstanceStateExactMatch : ICamundaKey, IEquatable<ProcessInstanceStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ProcessInstanceStateFilterProperty

ProcessInstanceStateEnum property with full advanced search capabilities.

```csharp
public sealed class ProcessInstanceStateFilterProperty
```

| Property     | Type                                 | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ProcessInstanceStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<ProcessInstanceStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<ProcessInstanceStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<ProcessInstanceStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## ProcessInstanceSuspensionBatchOperationRequest

The process instance filter that defines which process instances should be suspended.

```csharp
public sealed class ProcessInstanceSuspensionBatchOperationRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `Filter`             | `ProcessInstanceFilter`        | The process instance filter.                                                                                                |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## ProcessInstanceWaitStateStatisticsQueryResult

Process instance wait state statistics query response.

```csharp
public sealed class ProcessInstanceWaitStateStatisticsQueryResult
```

| Property | Type                                             | Description                |
| -------- | ------------------------------------------------ | -------------------------- |
| `Items`  | `List<ProcessInstanceWaitStateStatisticsResult>` | The wait state statistics. |

## ProcessInstanceWaitStateStatisticsResult

Process instance wait state statistics response item.

```csharp
public sealed class ProcessInstanceWaitStateStatisticsResult
```

| Property       | Type        | Description                                              |
| -------------- | ----------- | -------------------------------------------------------- |
| `ElementId`    | `ElementId` | The element id for which the wait states are aggregated. |
| `WaitingCount` | `Int64`     | The total number of waiting instances of the element.    |

## ResolvedSecret

```csharp
public sealed class ResolvedSecret
```

| Property    | Type     | Description                                                   |
| ----------- | -------- | ------------------------------------------------------------- |
| `Reference` | `String` | The resolved secret reference of the form `camunda.secrets.`. |
| `Value`     | `String` | The resolved secret value.                                    |

## ResourceFilter

Resource search filter.

```csharp
public sealed class ResourceFilter
```

| Property        | Type                          | Description                      |
| --------------- | ----------------------------- | -------------------------------- |
| `ResourceKey`   | `ResourceKeyFilterProperty`   | The key for this resource.       |
| `ResourceName`  | `StringFilterProperty`        | Resource name of this resource.  |
| `ResourceId`    | `StringFilterProperty`        | Resource ID of this resource.    |
| `Version`       | `IntegerFilterProperty`       | Version of this resource.        |
| `VersionTag`    | `StringFilterProperty`        | Version tag of this resource.    |
| `DeploymentKey` | `DeploymentKeyFilterProperty` | Deployment key of this resource. |
| `TenantId`      | `Nullable<TenantId>`          | Tenant ID of this resource.      |

## ResourceKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct ResourceKeyExactMatch : ICamundaKey, IEquatable<ResourceKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ResourceKeyFilterProperty

ResourceKey property with full advanced search capabilities.

```csharp
public sealed class ResourceKeyFilterProperty
```

| Property     | Type                    | Description                                                                                                                      |
| ------------ | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ResourceKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<ResourceKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<ResourceKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`     | Checks if the current property exists.                                                                                           |
| `In`         | `List<ResourceKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<ResourceKey>`     | Checks if the property matches none of the provided values.                                                                      |

## ResourceResult

```csharp
public sealed class ResourceResult
```

| Property       | Type          | Description                                            |
| -------------- | ------------- | ------------------------------------------------------ |
| `ResourceName` | `String`      | The resource name from which this resource was parsed. |
| `Version`      | `Int32`       | The assigned resource version.                         |
| `VersionTag`   | `String`      | The version tag of this resource.                      |
| `ResourceId`   | `String`      | The resource ID of this resource.                      |
| `TenantId`     | `TenantId`    | The tenant ID of this resource.                        |
| `ResourceKey`  | `ResourceKey` | The unique key of this resource.                       |

## ResourceSearchQuery

```csharp
public sealed class ResourceSearchQuery
```

| Property | Type                                   | Description                  |
| -------- | -------------------------------------- | ---------------------------- |
| `Sort`   | `List<ResourceSearchQuerySortRequest>` | Sort field criteria.         |
| `Filter` | `ResourceFilter`                       | The resource search filters. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria.         |

## ResourceSearchQueryResult

```csharp
public sealed class ResourceSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<ResourceResult>`    | The matching resources.                          |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## ResourceSearchQuerySortRequest

```csharp
public sealed class ResourceSearchQuerySortRequest
```

| Property | Type                                  | Description                                   |
| -------- | ------------------------------------- | --------------------------------------------- |
| `Field`  | `ResourceSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`             | The order in which to sort the related field. |

## RestoreRequest

Describes a restore request. Provide either a list of backup IDs or a time range (`from`/`to`) that selects the backups to restore; the two are mutually exclusive.

```csharp
public sealed class RestoreRequest
```

| Property    | Type                       | Description                                                            |
| ----------- | -------------------------- | ---------------------------------------------------------------------- |
| `From`      | `Nullable<DateTimeOffset>` | The start of the time range to restore from, as an ISO 8601 timestamp. |
| `To`        | `Nullable<DateTimeOffset>` | The end of the time range to restore from, as an ISO 8601 timestamp.   |
| `BackupIds` | `List<Int64>`              | The IDs of the backups to restore from, one per partition.             |

## ResumeProcessInstanceRequest

```csharp
public sealed class ResumeProcessInstanceRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## RetryDecision

```csharp
public readonly record struct RetryDecision : IEquatable<RetryDecision>
```

| Property    | Type      | Description |
| ----------- | --------- | ----------- |
| `Retryable` | `Boolean` |             |
| `Reason`    | `String`  |             |

## RoleClientResult

```csharp
public sealed class RoleClientResult
```

| Property   | Type       | Description           |
| ---------- | ---------- | --------------------- |
| `ClientId` | `ClientId` | The ID of the client. |

## RoleClientSearchQueryRequest

```csharp
public sealed class RoleClientSearchQueryRequest
```

| Property | Type                                     | Description          |
| -------- | ---------------------------------------- | -------------------- |
| `Sort`   | `List<RoleClientSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                 | Pagination criteria. |

## RoleClientSearchQuerySortRequest

```csharp
public sealed class RoleClientSearchQuerySortRequest
```

| Property | Type                                    | Description                                   |
| -------- | --------------------------------------- | --------------------------------------------- |
| `Field`  | `RoleClientSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`               | The order in which to sort the related field. |

## RoleClientSearchResult

```csharp
public sealed class RoleClientSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<RoleClientResult>`  | The matching clients.                            |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## RoleCreateRequest

```csharp
public sealed class RoleCreateRequest
```

| Property      | Type     | Description                       |
| ------------- | -------- | --------------------------------- |
| `RoleId`      | `RoleId` | The ID of the new role.           |
| `Name`        | `String` | The display name of the new role. |
| `Description` | `String` | The description of the new role.  |

## RoleCreateResult

```csharp
public sealed class RoleCreateResult
```

| Property      | Type     | Description                           |
| ------------- | -------- | ------------------------------------- |
| `RoleId`      | `RoleId` | The ID of the created role.           |
| `Name`        | `String` | The display name of the created role. |
| `Description` | `String` | The description of the created role.  |

## RoleFilter

Role filter request

```csharp
public sealed class RoleFilter
```

| Property | Type               | Description                   |
| -------- | ------------------ | ----------------------------- |
| `RoleId` | `Nullable<RoleId>` | The role ID search filters.   |
| `Name`   | `String`           | The role name search filters. |

## RoleGroupResult

```csharp
public sealed class RoleGroupResult
```

| Property  | Type      | Description          |
| --------- | --------- | -------------------- |
| `GroupId` | `GroupId` | The id of the group. |

## RoleGroupSearchQueryRequest

```csharp
public sealed class RoleGroupSearchQueryRequest
```

| Property | Type                                    | Description          |
| -------- | --------------------------------------- | -------------------- |
| `Sort`   | `List<RoleGroupSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                | Pagination criteria. |

## RoleGroupSearchQuerySortRequest

```csharp
public sealed class RoleGroupSearchQuerySortRequest
```

| Property | Type                                   | Description                                   |
| -------- | -------------------------------------- | --------------------------------------------- |
| `Field`  | `RoleGroupSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`              | The order in which to sort the related field. |

## RoleGroupSearchResult

```csharp
public sealed class RoleGroupSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<RoleGroupResult>`   | The matching groups.                             |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## RoleId

The unique identifier of a role.

```csharp
public readonly record struct RoleId : ICamundaKey, IEquatable<RoleId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## RoleMappingRuleSearchResult

```csharp
public sealed class RoleMappingRuleSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<MappingRuleResult>` | The matching mapping rules.                      |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## RoleResult

Role search response item.

```csharp
public sealed class RoleResult
```

| Property      | Type     | Description                  |
| ------------- | -------- | ---------------------------- |
| `Name`        | `String` | The role name.               |
| `RoleId`      | `RoleId` | The role id.                 |
| `Description` | `String` | The description of the role. |

## RoleSearchQueryRequest

Role search request.

```csharp
public sealed class RoleSearchQueryRequest
```

| Property | Type                               | Description              |
| -------- | ---------------------------------- | ------------------------ |
| `Sort`   | `List<RoleSearchQuerySortRequest>` | Sort field criteria.     |
| `Filter` | `RoleFilter`                       | The role search filters. |
| `Page`   | `SearchQueryPageRequest`           | Pagination criteria.     |

## RoleSearchQueryResult

Role search response.

```csharp
public sealed class RoleSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<RoleResult>`        | The matching roles.                              |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## RoleSearchQuerySortRequest

```csharp
public sealed class RoleSearchQuerySortRequest
```

| Property | Type                              | Description                                   |
| -------- | --------------------------------- | --------------------------------------------- |
| `Field`  | `RoleSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`         | The order in which to sort the related field. |

## RoleUpdateRequest

```csharp
public sealed class RoleUpdateRequest
```

| Property      | Type     | Description                       |
| ------------- | -------- | --------------------------------- |
| `Name`        | `String` | The display name of the new role. |
| `Description` | `String` | The description of the new role.  |

## RoleUpdateResult

```csharp
public sealed class RoleUpdateResult
```

| Property      | Type     | Description                           |
| ------------- | -------- | ------------------------------------- |
| `Name`        | `String` | The display name of the updated role. |
| `Description` | `String` | The description of the updated role.  |
| `RoleId`      | `RoleId` | The ID of the updated role.           |

## RoleUserResult

```csharp
public sealed class RoleUserResult
```

| Property   | Type       | Description                |
| ---------- | ---------- | -------------------------- |
| `Username` | `Username` | The unique name of a user. |

## RoleUserSearchQueryRequest

```csharp
public sealed class RoleUserSearchQueryRequest
```

| Property | Type                                   | Description          |
| -------- | -------------------------------------- | -------------------- |
| `Sort`   | `List<RoleUserSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria. |

## RoleUserSearchQuerySortRequest

```csharp
public sealed class RoleUserSearchQuerySortRequest
```

| Property | Type                                  | Description                                   |
| -------- | ------------------------------------- | --------------------------------------------- |
| `Field`  | `RoleUserSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`             | The order in which to sort the related field. |

## RoleUserSearchResult

```csharp
public sealed class RoleUserSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<RoleUserResult>`    | The matching users.                              |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## ScopeKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct ScopeKeyExactMatch : ICamundaKey, IEquatable<ScopeKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## ScopeKeyFilterProperty

ScopeKey property with full advanced search capabilities. Filter by the key of the element instance or process instance that defines the scope of a variable.

```csharp
public sealed class ScopeKeyFilterProperty
```

| Property     | Type                 | Description                                                                                                                      |
| ------------ | -------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<ScopeKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<ScopeKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<ScopeKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`  | Checks if the current property exists.                                                                                           |
| `In`         | `List<ScopeKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<ScopeKey>`     | Checks if the property matches none of the provided values.                                                                      |

## SearchQueryPageRequest

Pagination criteria. Can use offset-based pagination (from/limit) OR cursor-based pagination (after/before + limit), but not both.

```csharp
public abstract class SearchQueryPageRequest
```

## SearchQueryPageResponse

Pagination information about the search results.

```csharp
public sealed class SearchQueryPageResponse
```

| Property            | Type                    | Description                                                                                                                                                                                         |
| ------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `TotalItems`        | `Int64`                 | Total items matching the criteria.                                                                                                                                                                  |
| `HasMoreTotalItems` | `Boolean`               | Indicates whether the `totalItems` value has been capped due to system limits. When true, `totalItems` is a lower bound and the actual number of matching items is greater than the reported value. |
| `StartCursor`       | `Nullable<StartCursor>` | The cursor value for getting the previous page of results. Use this in the `before` field of an ensuing request.                                                                                    |
| `EndCursor`         | `Nullable<EndCursor>`   | The cursor value for getting the next page of results. Use this in the `after` field of an ensuing request.                                                                                         |

## SearchQueryRequest

```csharp
public sealed class SearchQueryRequest
```

| Property | Type                     | Description          |
| -------- | ------------------------ | -------------------- |
| `Page`   | `SearchQueryPageRequest` | Pagination criteria. |

## SearchQueryResponse

```csharp
public sealed class SearchQueryResponse
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## SecretResolutionError

```csharp
public sealed class SecretResolutionError
```

| Property    | Type              | Description                                                                                                                                                                                                                     |
| ----------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Reference` | `String`          | The secret reference that could not be resolved.                                                                                                                                                                                |
| `Code`      | `SecretErrorCode` | The typed reason a reference could not be resolved. - `NOT_FOUND`: no secret exists for the reference. - `ACCESS_DENIED`: the caller lacks `SECRET:REVEAL` on the reference. - `INVALID_REFERENCE`: the reference is malformed. |
| `Message`   | `String`          | A human-readable description of the failure. Never contains the secret value; only error metadata (codes, names) is included.                                                                                                   |

## SecretResolveRequest

```csharp
public sealed class SecretResolveRequest
```

| Property     | Type           | Description                                                                                                                                                                                             |
| ------------ | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `References` | `List<String>` | The secret references to resolve, each of the form `camunda.secrets.`. Duplicate references are deduplicated by the server and resolved once. At most 20 references may be requested in a single batch. |

## SecretResolveResult

The per-reference outcome of a resolve request.

```csharp
public sealed class SecretResolveResult
```

| Property   | Type                          | Description                                                              |
| ---------- | ----------------------------- | ------------------------------------------------------------------------ |
| `Resolved` | `List<ResolvedSecret>`        | The references that were successfully resolved.                          |
| `Errors`   | `List<SecretResolutionError>` | The references that could not be resolved, each with a typed error code. |

## SetVariableRequest

```csharp
public sealed class SetVariableRequest
```

| Property             | Type                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| -------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Variables`          | `Object`                       | JSON object representing the variables to set in the element’s scope.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `Local`              | `Nullable<Boolean>`            | If set to `true`, the variables are merged strictly into the local scope (as specified by the `elementInstanceKey`). Otherwise, the variables are propagated to upper scopes and set at the outermost one. Let's consider the following example: There are two scopes '1' and '2'. Scope '1' is the parent scope of '2'. The effective variables of the scopes are: 1 => { "foo" : 2 } 2 => { "bar" : 1 } An update request with elementInstanceKey as '2', variables { "foo": 5 }, and local set to `true` leaves scope '1' unchanged and adjusts scope '2' to { "bar": 1, "foo": 5 }. By default, with local set to `false`, scope '1' will be { "foo": 5 } and scope '2' will be { "bar": 1 }. |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |

## SignalBroadcastRequest

```csharp
public sealed class SignalBroadcastRequest : ITenantIdSettable
```

| Property     | Type                 | Description                                |
| ------------ | -------------------- | ------------------------------------------ |
| `SignalName` | `String`             | The name of the signal to broadcast.       |
| `Variables`  | `Object`             | The signal variables as a JSON object.     |
| `TenantId`   | `Nullable<TenantId>` | The ID of the tenant that owns the signal. |

## SignalBroadcastResult

```csharp
public sealed class SignalBroadcastResult
```

| Property    | Type        | Description                                     |
| ----------- | ----------- | ----------------------------------------------- |
| `TenantId`  | `TenantId`  | The tenant ID of the signal that was broadcast. |
| `SignalKey` | `SignalKey` | The key of the broadcasted signal.              |

## SignalWaitStateDetails

```csharp
public sealed class SignalWaitStateDetails : WaitStateDetails
```

| Property     | Type     | Description                           |
| ------------ | -------- | ------------------------------------- |
| `SignalName` | `String` | The name of the signal being awaited. |

## SourceElementIdInstruction

Defines an instruction with a sourceElementId. The move instruction with this sourceType will terminate all active element instances with the sourceElementId and activate a new element instance for each terminated one at targetElementId.

```csharp
public sealed class SourceElementIdInstruction : SourceElementInstruction
```

| Property          | Type        | Description                                            |
| ----------------- | ----------- | ------------------------------------------------------ |
| `SourceElementId` | `ElementId` | The id of the source element for the move instruction. |

## SourceElementInstanceKeyInstruction

Defines an instruction with a sourceElementInstanceKey. The move instruction with this sourceType will terminate one active element instance with the sourceElementInstanceKey and activate a new element instance at targetElementId.

```csharp
public sealed class SourceElementInstanceKeyInstruction : SourceElementInstruction
```

| Property                   | Type                 | Description                                               |
| -------------------------- | -------------------- | --------------------------------------------------------- |
| `SourceElementInstanceKey` | `ElementInstanceKey` | The source element instance key for the move instruction. |

## SourceElementInstruction

Defines the source element identifier for the move instruction. It can either be a sourceElementId, or sourceElementInstanceKey.

```csharp
public abstract class SourceElementInstruction
```

## StartCursor

The start cursor in a search query result set.

```csharp
public readonly record struct StartCursor : ICamundaKey, IEquatable<StartCursor>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## StatusMetric

Metric for a single job status.

```csharp
public sealed class StatusMetric
```

| Property        | Type                       | Description                                            |
| --------------- | -------------------------- | ------------------------------------------------------ |
| `Count`         | `Int64`                    | Number of jobs in this status.                         |
| `LastUpdatedAt` | `Nullable<DateTimeOffset>` | ISO 8601 timestamp of the last update for this status. |

## StopResult

Result of a `JobWorker.StopAsync` call.

```csharp
public readonly record struct StopResult : IEquatable<StopResult>
```

| Property        | Type      | Description                                                   |
| --------------- | --------- | ------------------------------------------------------------- |
| `RemainingJobs` | `Int32`   | Number of jobs still in-flight when stop completed.           |
| `TimedOut`      | `Boolean` | Whether the grace period was exceeded with jobs still active. |

## StringFilterProperty

String property with full advanced search capabilities.

```csharp
public sealed class StringFilterProperty
```

| Property     | Type                   | Description                                                                                                                                                                                                                                               |
| ------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `String`               | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `String`               | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `String`               | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`    | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<String>`         | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `NotIn`      | `List<String>`         | Checks if the property matches none of the provided values.                                                                                                                                                                                               |
| `Like`       | `Nullable<LikeFilter>` | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## SuspendProcessInstanceRequest

```csharp
public sealed class SuspendProcessInstanceRequest
```

| Property             | Type                           | Description                                                                                                                 |
| -------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| `OperationReference` | `Nullable<OperationReference>` | A reference key chosen by the user that will be part of all records resulting from this operation. Must be > 0 if provided. |

## SystemConfigurationResponse

Envelope for all system configuration sections. Each property represents a feature area.

```csharp
public sealed class SystemConfigurationResponse
```

| Property         | Type                                  | Description                                                    |
| ---------------- | ------------------------------------- | -------------------------------------------------------------- |
| `JobMetrics`     | `JobMetricsConfigurationResponse`     | Configuration for job metrics collection and export.           |
| `Components`     | `ComponentsConfigurationResponse`     | Configuration for active Camunda components in the deployment. |
| `Deployment`     | `DeploymentConfigurationResponse`     | Configuration for deployment characteristics.                  |
| `Authentication` | `AuthenticationConfigurationResponse` | Configuration for authentication and session management.       |
| `Cloud`          | `CloudConfigurationResponse`          | Configuration for SaaS/cloud-specific settings.                |

## Tag

A tag. Needs to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.

```csharp
public readonly record struct Tag : ICamundaKey, IEquatable<Tag>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## TenantClientResult

```csharp
public sealed class TenantClientResult
```

| Property   | Type       | Description           |
| ---------- | ---------- | --------------------- |
| `ClientId` | `ClientId` | The ID of the client. |

## TenantClientSearchQueryRequest

```csharp
public sealed class TenantClientSearchQueryRequest
```

| Property | Type                                       | Description          |
| -------- | ------------------------------------------ | -------------------- |
| `Sort`   | `List<TenantClientSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                   | Pagination criteria. |

## TenantClientSearchQuerySortRequest

```csharp
public sealed class TenantClientSearchQuerySortRequest
```

| Property | Type                                      | Description                                   |
| -------- | ----------------------------------------- | --------------------------------------------- |
| `Field`  | `TenantClientSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                 | The order in which to sort the related field. |

## TenantClientSearchResult

```csharp
public sealed class TenantClientSearchResult
```

| Property | Type                       | Description                                      |
| -------- | -------------------------- | ------------------------------------------------ |
| `Items`  | `List<TenantClientResult>` | The matching clients.                            |
| `Page`   | `SearchQueryPageResponse`  | Pagination information about the search results. |

## TenantCreateRequest

```csharp
public sealed class TenantCreateRequest
```

| Property      | Type       | Description                                                                                                                                                                      |
| ------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `TenantId`    | `TenantId` | The unique ID for the tenant. Must be 31 characters or less and match `^[\w.-]{1,31}$` (word characters, `.`, `-`). The literal `` is also accepted as the default-tenant alias. |
| `Name`        | `String`   | The name of the tenant.                                                                                                                                                          |
| `Description` | `String`   | The description of the tenant.                                                                                                                                                   |

## TenantCreateResult

```csharp
public sealed class TenantCreateResult
```

| Property      | Type       | Description                                  |
| ------------- | ---------- | -------------------------------------------- |
| `TenantId`    | `TenantId` | The unique identifier of the created tenant. |
| `Name`        | `String`   | The name of the tenant.                      |
| `Description` | `String`   | The description of the tenant.               |

## TenantFilter

Tenant filter request

```csharp
public sealed class TenantFilter
```

| Property   | Type                 | Description                          |
| ---------- | -------------------- | ------------------------------------ |
| `TenantId` | `Nullable<TenantId>` | The unique identifier of the tenant. |
| `Name`     | `String`             | The name of the tenant.              |

## TenantGroupResult

```csharp
public sealed class TenantGroupResult
```

| Property  | Type      | Description   |
| --------- | --------- | ------------- |
| `GroupId` | `GroupId` | The group ID. |

## TenantGroupSearchQueryRequest

```csharp
public sealed class TenantGroupSearchQueryRequest
```

| Property | Type                                      | Description          |
| -------- | ----------------------------------------- | -------------------- |
| `Sort`   | `List<TenantGroupSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                  | Pagination criteria. |

## TenantGroupSearchQuerySortRequest

```csharp
public sealed class TenantGroupSearchQuerySortRequest
```

| Property | Type                                     | Description                                   |
| -------- | ---------------------------------------- | --------------------------------------------- |
| `Field`  | `TenantGroupSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                | The order in which to sort the related field. |

## TenantGroupSearchResult

```csharp
public sealed class TenantGroupSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<TenantGroupResult>` | The matching groups.                             |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## TenantId

The unique identifier of the tenant.

```csharp
public readonly record struct TenantId : ICamundaKey, IEquatable<TenantId>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## TenantMappingRuleSearchResult

```csharp
public sealed class TenantMappingRuleSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<MappingRuleResult>` | The matching mapping rules.                      |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## TenantResult

Tenant search response item.

```csharp
public sealed class TenantResult
```

| Property      | Type       | Description                          |
| ------------- | ---------- | ------------------------------------ |
| `Name`        | `String`   | The tenant name.                     |
| `TenantId`    | `TenantId` | The unique identifier of the tenant. |
| `Description` | `String`   | The tenant description.              |

## TenantRoleSearchResult

```csharp
public sealed class TenantRoleSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<RoleResult>`        | The matching roles.                              |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## TenantSearchQueryRequest

Tenant search request

```csharp
public sealed class TenantSearchQueryRequest
```

| Property | Type                                 | Description                |
| -------- | ------------------------------------ | -------------------------- |
| `Sort`   | `List<TenantSearchQuerySortRequest>` | Sort field criteria.       |
| `Filter` | `TenantFilter`                       | The tenant search filters. |
| `Page`   | `SearchQueryPageRequest`             | Pagination criteria.       |

## TenantSearchQueryResult

Tenant search response.

```csharp
public sealed class TenantSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<TenantResult>`      | The matching tenants.                            |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## TenantSearchQuerySortRequest

```csharp
public sealed class TenantSearchQuerySortRequest
```

| Property | Type                                | Description                                   |
| -------- | ----------------------------------- | --------------------------------------------- |
| `Field`  | `TenantSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`           | The order in which to sort the related field. |

## TenantUpdateRequest

```csharp
public sealed class TenantUpdateRequest
```

| Property      | Type     | Description                        |
| ------------- | -------- | ---------------------------------- |
| `Name`        | `String` | The new name of the tenant.        |
| `Description` | `String` | The new description of the tenant. |

## TenantUpdateResult

```csharp
public sealed class TenantUpdateResult
```

| Property      | Type       | Description                                  |
| ------------- | ---------- | -------------------------------------------- |
| `TenantId`    | `TenantId` | The unique identifier of the updated tenant. |
| `Name`        | `String`   | The name of the tenant.                      |
| `Description` | `String`   | The description of the tenant.               |

## TenantUserResult

```csharp
public sealed class TenantUserResult
```

| Property   | Type       | Description                |
| ---------- | ---------- | -------------------------- |
| `Username` | `Username` | The unique name of a user. |

## TenantUserSearchQueryRequest

```csharp
public sealed class TenantUserSearchQueryRequest
```

| Property | Type                                     | Description          |
| -------- | ---------------------------------------- | -------------------- |
| `Sort`   | `List<TenantUserSearchQuerySortRequest>` | Sort field criteria. |
| `Page`   | `SearchQueryPageRequest`                 | Pagination criteria. |

## TenantUserSearchQuerySortRequest

```csharp
public sealed class TenantUserSearchQuerySortRequest
```

| Property | Type                                    | Description                                   |
| -------- | --------------------------------------- | --------------------------------------------- |
| `Field`  | `TenantUserSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`               | The order in which to sort the related field. |

## TenantUserSearchResult

```csharp
public sealed class TenantUserSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<TenantUserResult>`  | The matching users.                              |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## TimerWaitStateDetails

```csharp
public sealed class TimerWaitStateDetails : WaitStateDetails
```

| Property      | Type              | Description                                                                       |
| ------------- | ----------------- | --------------------------------------------------------------------------------- |
| `DueDate`     | `Nullable<Int64>` | When the timer is due, as a UNIX epoch timestamp in milliseconds.                 |
| `Repetitions` | `Nullable<Int32>` | The number of remaining timer repetitions (-1 for infinite, 0 for non-repeating). |

## TlsConfig

TLS / mTLS configuration for custom certificates.

```csharp
public sealed class TlsConfig
```

| Property        | Type     | Description                                         |
| --------------- | -------- | --------------------------------------------------- |
| `Cert`          | `String` | Inline PEM client certificate (overrides CertPath). |
| `CertPath`      | `String` | Path to PEM client certificate file.                |
| `Key`           | `String` | Inline PEM client private key (overrides KeyPath).  |
| `KeyPath`       | `String` | Path to PEM client private key file.                |
| `Ca`            | `String` | Inline PEM CA bundle (overrides CaPath).            |
| `CaPath`        | `String` | Path to PEM CA certificate bundle file.             |
| `KeyPassphrase` | `String` | Passphrase for an encrypted private key.            |

## TopologyResponse

The response of a topology request.

```csharp
public sealed class TopologyResponse
```

| Property                | Type               | Description                                             |
| ----------------------- | ------------------ | ------------------------------------------------------- |
| `Brokers`               | `List<BrokerInfo>` | A list of brokers that are part of this cluster.        |
| `ClusterId`             | `String`           | The cluster Id.                                         |
| `ClusterSize`           | `Int32`            | The number of brokers in the cluster.                   |
| `PartitionsCount`       | `Int32`            | The number of partitions are spread across the cluster. |
| `ReplicationFactor`     | `Int32`            | The configured replication factor for this cluster.     |
| `GatewayVersion`        | `String`           | The version of the Zeebe Gateway.                       |
| `LastCompletedChangeId` | `String`           | ID of the last completed change                         |

## TypedVariables

Extension methods for deserializing Camunda variable and custom header payloads from untyped `object` properties into strongly-typed DTOs.

Camunda API responses return `variables` and `customHeaders` as `object` properties which, at runtime, are `Json.JsonElement` values. These extensions let you opt in to typed deserialization:

```csharp
// Define your domain DTO
public record OrderVars(string OrderId, decimal Amount);

// Deserialize variables from a process instance result
var result = await client.CreateProcessInstanceAsync(
    new ProcessInstanceCreationInstructionById
    {
        ProcessDefinitionId = ProcessDefinitionId.AssumeExists("order-process"),
        Variables = new OrderVars("ord-123", 99.99m),  // input: just assign your DTO
    });

var vars = result.Variables.DeserializeAs<OrderVars>();  // output: typed extraction
```

For input (sending variables), simply assign your DTO to the `Variables` property — `System.Text.Json` serializes the runtime type automatically.

For output (receiving variables), call `TypedVariables.DeserializeAs` on the `Variables` or `CustomHeaders` property to deserialize the underlying `Json.JsonElement` into your DTO type.

```csharp
public static class TypedVariables
```

## TypedVariablesException

Base class for all errors raised by the DTO-driven typed variable map feature (`CamundaClient.SearchVariablesAsDtoAsync`).

```csharp
public class TypedVariablesException : Exception, ISerializable
```

## UpdateClusterVariableRequest

```csharp
public sealed class UpdateClusterVariableRequest
```

| Property   | Type                         | Description                                                                                                                                                                                                                                                                                             |
| ---------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Value`    | `Object`                     | The new value of the cluster variable. Can be any JSON object or primitive value. Will be serialized as a JSON string in responses.                                                                                                                                                                     |
| `Metadata` | `Dictionary<String, Object>` | A generic key-value metadata bag attached to the cluster variable. Values must be strings or numbers. Limited to 100 entries and a configurable maximum serialized size (default: 100 entries at max key length of a cluster variable name (256 chars) plus the maximum value length, 8192 characters). |

## UpdateGlobalTaskListenerRequest

```csharp
public sealed class UpdateGlobalTaskListenerRequest
```

| Property         | Type                                    | Description                                                                                                     |
| ---------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `EventTypes`     | `List<GlobalTaskListenerEventTypeEnum>` | List of user task event types that trigger the listener.                                                        |
| `Type`           | `String`                                | The name of the job type, used as a reference to specify which job workers request the respective listener job. |
| `Retries`        | `Nullable<Int32>`                       | Number of retries for the listener job.                                                                         |
| `AfterNonGlobal` | `Nullable<Boolean>`                     | Whether the listener should run after model-level listeners.                                                    |
| `Priority`       | `Nullable<Int32>`                       | The priority of the listener. Higher priority listeners are executed before lower priority ones.                |

## UsageMetricsResponse

```csharp
public sealed class UsageMetricsResponse
```

| Property            | Type                         | Description                                                                                       |
| ------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------- |
| `ActiveTenants`     | `Int64`                      | The amount of active tenants.                                                                     |
| `Tenants`           | `Dictionary<String, Object>` | The usage metrics by tenants. Only available if request `withTenants` query parameter was `true`. |
| `ProcessInstances`  | `Int64`                      | The amount of created root process instances.                                                     |
| `DecisionInstances` | `Int64`                      | The amount of executed decision instances.                                                        |
| `Assignees`         | `Int64`                      | The amount of unique active task users.                                                           |

## UsageMetricsResponseItem

```csharp
public sealed class UsageMetricsResponseItem
```

| Property            | Type    | Description                                   |
| ------------------- | ------- | --------------------------------------------- |
| `ProcessInstances`  | `Int64` | The amount of created root process instances. |
| `DecisionInstances` | `Int64` | The amount of executed decision instances.    |
| `Assignees`         | `Int64` | The amount of unique active task users.       |

## UseSourceParentKeyInstruction

Instructs the engine to use the source's direct parent key as the ancestor scope key for the target element. This is a simpler alternative to `inferred` that skips hierarchy traversal and directly uses the source's parent key. This is useful when the source and target elements are siblings within the same flow scope.

```csharp
public sealed class UseSourceParentKeyInstruction : AncestorScopeInstruction
```

## UserCreateResult

```csharp
public sealed class UserCreateResult
```

| Property   | Type       | Description                       |
| ---------- | ---------- | --------------------------------- |
| `Username` | `Username` | The username of the created user. |
| `Name`     | `String`   | The name of the user.             |
| `Email`    | `String`   | The email of the user.            |

## UserFilter

User search filter.

```csharp
public sealed class UserFilter
```

| Property   | Type                   | Description               |
| ---------- | ---------------------- | ------------------------- |
| `Username` | `StringFilterProperty` | The username of the user. |
| `Name`     | `StringFilterProperty` | The name of the user.     |
| `Email`    | `StringFilterProperty` | The email of the user.    |

## UserRequest

```csharp
public sealed class UserRequest
```

| Property   | Type       | Description                   |
| ---------- | ---------- | ----------------------------- |
| `Password` | `String`   | The password of the user.     |
| `Username` | `Username` | The username of the new user. |
| `Name`     | `String`   | The name of the user.         |
| `Email`    | `String`   | The email of the user.        |

## UserResult

```csharp
public sealed class UserResult
```

| Property   | Type       | Description               |
| ---------- | ---------- | ------------------------- |
| `Username` | `Username` | The username of the user. |
| `Name`     | `String`   | The name of the user.     |
| `Email`    | `String`   | The email of the user.    |

## UserSearchQueryRequest

```csharp
public sealed class UserSearchQueryRequest
```

| Property | Type                               | Description              |
| -------- | ---------------------------------- | ------------------------ |
| `Sort`   | `List<UserSearchQuerySortRequest>` | Sort field criteria.     |
| `Filter` | `UserFilter`                       | The user search filters. |
| `Page`   | `SearchQueryPageRequest`           | Pagination criteria.     |

## UserSearchQuerySortRequest

```csharp
public sealed class UserSearchQuerySortRequest
```

| Property | Type                              | Description                                   |
| -------- | --------------------------------- | --------------------------------------------- |
| `Field`  | `UserSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`         | The order in which to sort the related field. |

## UserSearchResult

```csharp
public sealed class UserSearchResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<UserResult>`        | The matching users.                              |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## UserTaskAssignmentRequest

```csharp
public sealed class UserTaskAssignmentRequest
```

| Property        | Type                | Description                                                                                                                                                                                                                                                               |
| --------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Assignee`      | `String`            | The assignee for the user task. The assignee must not be empty or `null`.                                                                                                                                                                                                 |
| `AllowOverride` | `Nullable<Boolean>` | By default, the task is reassigned if it was already assigned. Set this to `false` to return an error in such cases. The task must then first be unassigned to be assigned again. Use this when you have users picking from group task queues to prevent race conditions. |
| `Action`        | `String`            | A custom action value that will be accessible from user task events resulting from this endpoint invocation. If not provided, it will default to "assign".                                                                                                                |

## UserTaskAuditLogFilter

The user task audit log search filters.

```csharp
public sealed class UserTaskAuditLogFilter
```

| Property        | Type                              | Description                                 |
| --------------- | --------------------------------- | ------------------------------------------- |
| `OperationType` | `OperationTypeFilterProperty`     | The audit log operation type search filter. |
| `Result`        | `AuditLogResultFilterProperty`    | The audit log result search filter.         |
| `Timestamp`     | `DateTimeFilterProperty`          | The audit log timestamp filter.             |
| `ActorType`     | `AuditLogActorTypeFilterProperty` | The actor type search filter.               |
| `ActorId`       | `StringFilterProperty`            | The actor ID search filter.                 |

## UserTaskAuditLogSearchQueryRequest

User task search query request.

```csharp
public sealed class UserTaskAuditLogSearchQueryRequest
```

| Property | Type                                   | Description                             |
| -------- | -------------------------------------- | --------------------------------------- |
| `Sort`   | `List<AuditLogSearchQuerySortRequest>` | Sort field criteria.                    |
| `Filter` | `UserTaskAuditLogFilter`               | The user task audit log search filters. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria.                    |

## UserTaskCompletionRequest

```csharp
public sealed class UserTaskCompletionRequest
```

| Property    | Type     | Description                                                                                                                                                  |
| ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Variables` | `Object` | The variables to complete the user task with.                                                                                                                |
| `Action`    | `String` | A custom action value that will be accessible from user task events resulting from this endpoint invocation. If not provided, it will default to "complete". |

## UserTaskEffectiveVariableSearchQueryRequest

User task effective variable search query request. Uses offset-based pagination only.

```csharp
public sealed class UserTaskEffectiveVariableSearchQueryRequest
```

| Property | Type                                           | Description                            |
| -------- | ---------------------------------------------- | -------------------------------------- |
| `Page`   | `OffsetPagination`                             | Pagination parameters.                 |
| `Sort`   | `List<UserTaskVariableSearchQuerySortRequest>` | Sort field criteria.                   |
| `Filter` | `UserTaskVariableFilter`                       | The user task variable search filters. |

## UserTaskFilter

User task filter request.

```csharp
public sealed class UserTaskFilter
```

| Property                   | Type                                 | Description                                                                                                                                                                                                   |
| -------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `State`                    | `UserTaskStateFilterProperty`        | The user task state.                                                                                                                                                                                          |
| `Assignee`                 | `StringFilterProperty`               | The assignee of the user task.                                                                                                                                                                                |
| `BusinessId`               | `StringFilterProperty`               | The business ID of the owning process instance the user task belongs to. This only works for user tasks created with 8.10 and onwards. Tasks from prior versions don't contain this data and cannot be found. |
| `Priority`                 | `IntegerFilterProperty`              | The priority of the user task.                                                                                                                                                                                |
| `ElementId`                | `Nullable<ElementId>`                | The element ID of the user task.                                                                                                                                                                              |
| `Name`                     | `StringFilterProperty`               | The task name. This only works for data created with 8.8 and onwards. Instances from prior versions don't contain this data and cannot be found.                                                              |
| `CandidateGroup`           | `StringFilterProperty`               | The candidate group for this user task.                                                                                                                                                                       |
| `CandidateUser`            | `StringFilterProperty`               | The candidate user for this user task.                                                                                                                                                                        |
| `TenantId`                 | `StringFilterProperty`               | Tenant ID of this user task.                                                                                                                                                                                  |
| `ProcessDefinitionId`      | `ProcessDefinitionIdFilterProperty`  | The ID of the process definition.                                                                                                                                                                             |
| `CreationDate`             | `DateTimeFilterProperty`             | The user task creation date.                                                                                                                                                                                  |
| `CompletionDate`           | `DateTimeFilterProperty`             | The user task completion date.                                                                                                                                                                                |
| `FollowUpDate`             | `DateTimeFilterProperty`             | The user task follow-up date.                                                                                                                                                                                 |
| `DueDate`                  | `DateTimeFilterProperty`             | The user task due date.                                                                                                                                                                                       |
| `ProcessInstanceVariables` | `List<VariableValueFilterProperty>`  | The variables of the process instance.                                                                                                                                                                        |
| `LocalVariables`           | `List<VariableValueFilterProperty>`  | The local variables of the user task.                                                                                                                                                                         |
| `UserTaskKey`              | `Nullable<UserTaskKey>`              | The key for this user task.                                                                                                                                                                                   |
| `ProcessDefinitionKey`     | `ProcessDefinitionKeyFilterProperty` | The key of the process definition.                                                                                                                                                                            |
| `ProcessInstanceKey`       | `ProcessInstanceKeyFilterProperty`   | The key of the process instance.                                                                                                                                                                              |
| `ElementInstanceKey`       | `Nullable<ElementInstanceKey>`       | The key of the element instance.                                                                                                                                                                              |
| `Tags`                     | `List<Tag>`                          | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                      |

## UserTaskProperties

Contains properties of a user task.

```csharp
public sealed class UserTaskProperties
```

| Property            | Type                    | Description                                             |
| ------------------- | ----------------------- | ------------------------------------------------------- |
| `Action`            | `String`                | The action performed on the user task.                  |
| `Assignee`          | `String`                | The user assigned to the task.                          |
| `CandidateGroups`   | `List<String>`          | The groups eligible to claim the task.                  |
| `CandidateUsers`    | `List<String>`          | The users eligible to claim the task.                   |
| `ChangedAttributes` | `List<String>`          | The attributes that were changed in the task.           |
| `DueDate`           | `String`                | The due date of the user task in ISO 8601 format.       |
| `FollowUpDate`      | `String`                | The follow-up date of the user task in ISO 8601 format. |
| `FormKey`           | `Nullable<FormKey>`     | The key of the form associated with the user task.      |
| `Priority`          | `Nullable<Int32>`       | The priority of the user task.                          |
| `UserTaskKey`       | `Nullable<UserTaskKey>` | The unique key identifying the user task.               |

## UserTaskResult

```csharp
public sealed class UserTaskResult
```

| Property                   | Type                           | Description                                                                                                                                                                                                                                 |
| -------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`                     | `String`                       | The name for this user task.                                                                                                                                                                                                                |
| `State`                    | `UserTaskStateEnum`            | The state of the user task. Note: FAILED state is only for legacy job-worker-based tasks.                                                                                                                                                   |
| `Assignee`                 | `String`                       | The assignee of the user task.                                                                                                                                                                                                              |
| `ElementId`                | `ElementId`                    | The element ID of the user task.                                                                                                                                                                                                            |
| `CandidateGroups`          | `List<String>`                 | The candidate groups for this user task.                                                                                                                                                                                                    |
| `CandidateUsers`           | `List<String>`                 | The candidate users for this user task.                                                                                                                                                                                                     |
| `ProcessDefinitionId`      | `ProcessDefinitionId`          | The ID of the process definition.                                                                                                                                                                                                           |
| `CreationDate`             | `DateTimeOffset`               | The creation date of a user task.                                                                                                                                                                                                           |
| `CompletionDate`           | `Nullable<DateTimeOffset>`     | The completion date of a user task.                                                                                                                                                                                                         |
| `FollowUpDate`             | `Nullable<DateTimeOffset>`     | The follow date of a user task.                                                                                                                                                                                                             |
| `DueDate`                  | `Nullable<DateTimeOffset>`     | The due date of a user task.                                                                                                                                                                                                                |
| `TenantId`                 | `TenantId`                     | The unique identifier of the tenant.                                                                                                                                                                                                        |
| `ExternalFormReference`    | `String`                       | The external form reference.                                                                                                                                                                                                                |
| `ProcessDefinitionVersion` | `Int32`                        | The version of the process definition.                                                                                                                                                                                                      |
| `CustomHeaders`            | `Dictionary<String, String>`   | Custom headers for the user task.                                                                                                                                                                                                           |
| `Priority`                 | `Int32`                        | The priority of a user task. The higher the value the higher the priority.                                                                                                                                                                  |
| `UserTaskKey`              | `UserTaskKey`                  | The key of the user task.                                                                                                                                                                                                                   |
| `ElementInstanceKey`       | `ElementInstanceKey`           | The key of the element instance.                                                                                                                                                                                                            |
| `ProcessName`              | `String`                       | The name of the process definition. This is `null` if the process has no name defined.                                                                                                                                                      |
| `ProcessDefinitionKey`     | `ProcessDefinitionKey`         | The key of the process definition.                                                                                                                                                                                                          |
| `ProcessInstanceKey`       | `ProcessInstanceKey`           | The key of the process instance.                                                                                                                                                                                                            |
| `RootProcessInstanceKey`   | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later. |
| `BusinessId`               | `Nullable<BusinessId>`         | The business ID of the owning process instance, inherited when the user task was created. This is `null` for user tasks created before version 8.10, and for user tasks whose owning process instance has no business ID.                   |
| `FormKey`                  | `Nullable<FormKey>`            | The key of the form.                                                                                                                                                                                                                        |
| `Tags`                     | `List<Tag>`                    | List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.                                                                                                                                    |

## UserTaskSearchQuery

User task search query request.

```csharp
public sealed class UserTaskSearchQuery
```

| Property | Type                                   | Description                   |
| -------- | -------------------------------------- | ----------------------------- |
| `Sort`   | `List<UserTaskSearchQuerySortRequest>` | Sort field criteria.          |
| `Filter` | `UserTaskFilter`                       | The user task search filters. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria.          |

## UserTaskSearchQueryResult

User task search query response.

```csharp
public sealed class UserTaskSearchQueryResult
```

| Property | Type                      | Description                                      |
| -------- | ------------------------- | ------------------------------------------------ |
| `Items`  | `List<UserTaskResult>`    | The matching user tasks.                         |
| `Page`   | `SearchQueryPageResponse` | Pagination information about the search results. |

## UserTaskSearchQuerySortRequest

```csharp
public sealed class UserTaskSearchQuerySortRequest
```

| Property | Type                                  | Description                                   |
| -------- | ------------------------------------- | --------------------------------------------- |
| `Field`  | `UserTaskSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`             | The order in which to sort the related field. |

## UserTaskStateExactMatch

Matches the value exactly.

```csharp
public readonly record struct UserTaskStateExactMatch : ICamundaKey, IEquatable<UserTaskStateExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## UserTaskStateFilterProperty

UserTaskStateEnum property with full advanced search capabilities.

```csharp
public sealed class UserTaskStateFilterProperty
```

| Property     | Type                          | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<UserTaskStateEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<UserTaskStateEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<UserTaskStateEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<UserTaskStateEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`        | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## UserTaskUpdateRequest

```csharp
public sealed class UserTaskUpdateRequest
```

| Property    | Type        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ----------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Changeset` | `Changeset` | JSON object with changed task attribute values. The following attributes can be adjusted with this endpoint, additional attributes will be ignored: * `candidateGroups` - reset by providing an empty list * `candidateUsers` - reset by providing an empty list * `dueDate` - reset by providing an empty String * `followUpDate` - reset by providing an empty String * `priority` - minimum 0, maximum 100, default 50 Providing any of those attributes with a `null` value or omitting it preserves the persisted attribute's value. The assignee cannot be adjusted with this endpoint, use the Assign task endpoint. This ensures correct event emission for assignee changes. |
| `Action`    | `String`    | A custom action value that will be accessible from user task events resulting from this endpoint invocation. If not provided, it will default to "update".                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

## UserTaskVariableFilter

The user task variable search filters.

```csharp
public sealed class UserTaskVariableFilter
```

| Property | Type                   | Description           |
| -------- | ---------------------- | --------------------- |
| `Name`   | `StringFilterProperty` | Name of the variable. |

## UserTaskVariableSearchQueryRequest

User task search query request.

```csharp
public sealed class UserTaskVariableSearchQueryRequest
```

| Property | Type                                           | Description                            |
| -------- | ---------------------------------------------- | -------------------------------------- |
| `Sort`   | `List<UserTaskVariableSearchQuerySortRequest>` | Sort field criteria.                   |
| `Filter` | `UserTaskVariableFilter`                       | The user task variable search filters. |
| `Page`   | `SearchQueryPageRequest`                       | Pagination criteria.                   |

## UserTaskVariableSearchQuerySortRequest

```csharp
public sealed class UserTaskVariableSearchQuerySortRequest
```

| Property | Type                                          | Description                                   |
| -------- | --------------------------------------------- | --------------------------------------------- |
| `Field`  | `UserTaskVariableSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`                     | The order in which to sort the related field. |

## UserTaskWaitStateDetails

```csharp
public sealed class UserTaskWaitStateDetails : WaitStateDetails
```

| Property  | Type                       | Description                            |
| --------- | -------------------------- | -------------------------------------- |
| `TaskKey` | `UserTaskKey`              | The key of the user task.              |
| `DueDate` | `Nullable<DateTimeOffset>` | The due date of the user task, if set. |

## UserUpdateRequest

```csharp
public sealed class UserUpdateRequest
```

| Property   | Type     | Description                                                    |
| ---------- | -------- | -------------------------------------------------------------- |
| `Password` | `String` | The password of the user. If blank, the password is unchanged. |
| `Name`     | `String` | The name of the user.                                          |
| `Email`    | `String` | The email of the user.                                         |

## UserUpdateResult

```csharp
public sealed class UserUpdateResult
```

| Property   | Type       | Description                       |
| ---------- | ---------- | --------------------------------- |
| `Username` | `Username` | The username of the updated user. |
| `Name`     | `String`   | The name of the user.             |
| `Email`    | `String`   | The email of the user.            |

## Username

The unique name of a user.

```csharp
public readonly record struct Username : ICamundaKey, IEquatable<Username>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## VariableDeserializationException

Raised when a present variable value cannot be deserialized.

This covers both a value that is not parseable as JSON and a syntactically valid value that cannot be bound to the requested CLR type. A missing variable is not an error (it simply does not appear in the map); a present but undeserializable value is, and is surfaced here rather than silently dropped.

```csharp
public sealed class VariableDeserializationException : TypedVariablesException, ISerializable
```

| Property       | Type     | Description                                        |
| -------------- | -------- | -------------------------------------------------- |
| `VariableName` | `String` | The variable name whose value could not be parsed. |

## VariableFilter

Variable filter request.

```csharp
public sealed class VariableFilter
```

| Property             | Type                               | Description                                                                                                                                                                                                                                                                                                                                                                                                                                |
| -------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Name`               | `StringFilterProperty`             | Name of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Value`              | `StringFilterProperty`             | The value of the variable. Variable values in filters need to be in serialized JSON format. For example, a variable with string value `myValue` can be found with the filter value `"myValue"`. Consider appropriate escaping for special characters in JSON strings when constructing filter values.                                                                                                                                      |
| `TenantId`           | `Nullable<TenantId>`               | Tenant ID of this variable.                                                                                                                                                                                                                                                                                                                                                                                                                |
| `IsTruncated`        | `Nullable<Boolean>`                | Whether the value is truncated or not.                                                                                                                                                                                                                                                                                                                                                                                                     |
| `VariableKey`        | `VariableKeyFilterProperty`        | The key for this variable.                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `ScopeKey`           | `ScopeKeyFilterProperty`           | The key of the scope that defines where this variable is directly defined. This can be a process instance key (for process-level variables) or an element instance key (for local variables scoped to tasks, subprocesses, gateways, events, etc.). Use this filter to find variables directly defined in specific scopes. Note that this does not include variables from parent scopes that would be visible through the scope hierarchy. |
| `ProcessInstanceKey` | `ProcessInstanceKeyFilterProperty` | The key of the process instance of this variable.                                                                                                                                                                                                                                                                                                                                                                                          |

## VariableKeyExactMatch

Matches the value exactly.

```csharp
public readonly record struct VariableKeyExactMatch : ICamundaKey, IEquatable<VariableKeyExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## VariableKeyFilterProperty

VariableKey property with full advanced search capabilities.

```csharp
public sealed class VariableKeyFilterProperty
```

| Property     | Type                    | Description                                                                                                                      |
| ------------ | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<VariableKey>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept. |
| `Eq`         | `Nullable<VariableKey>` | Checks for equality with the provided value.                                                                                     |
| `Neq`        | `Nullable<VariableKey>` | Checks for inequality with the provided value.                                                                                   |
| `Exists`     | `Nullable<Boolean>`     | Checks if the current property exists.                                                                                           |
| `In`         | `List<VariableKey>`     | Checks if the property matches any of the provided values.                                                                       |
| `NotIn`      | `List<VariableKey>`     | Checks if the property matches none of the provided values.                                                                      |

## VariableMap<T>

Result of a DTO-driven variable search (`CamundaClient.SearchVariablesAsDtoAsync`).

Holds the parsed variable values keyed by their query name (the DTO member's `[JsonPropertyName]` value, or the member name transformed by the serializer's naming policy). Provides lenient, defensive access via `VariableMap.Get` / `VariableMap.Get` and a strict `VariableMap.Validate` that constructs the declared DTO and enforces required members.

```csharp
public sealed class VariableMap<T> where T : class
```

| Property | Type                                       | Description                                         |
| -------- | ------------------------------------------ | --------------------------------------------------- |
| `Raw`    | `IReadOnlyDictionary<String, JsonElement>` | The parsed variable values, keyed by variable name. |

## VariableResult

Variable search response item.

```csharp
public sealed class VariableResult
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                                                         |
| ------------------------ | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Value`                  | `String`                       | Full value of this variable.                                                                                                                                                                                                                                                        |
| `Name`                   | `String`                       | Name of this variable.                                                                                                                                                                                                                                                              |
| `TenantId`               | `TenantId`                     | Tenant ID of this variable.                                                                                                                                                                                                                                                         |
| `VariableKey`            | `VariableKey`                  | The key for this variable.                                                                                                                                                                                                                                                          |
| `ScopeKey`               | `ScopeKey`                     | The key of the scope where this variable is directly defined. For process-level variables, this is the process instance key. For local variables, this is the key of the specific element instance (task, subprocess, gateway, event, etc.) where the variable is directly defined. |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The key of the process instance of this variable.                                                                                                                                                                                                                                   |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                         |

## VariableResultBase

Variable response item.

```csharp
public sealed class VariableResultBase
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                                                         |
| ------------------------ | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`                   | `String`                       | Name of this variable.                                                                                                                                                                                                                                                              |
| `TenantId`               | `TenantId`                     | Tenant ID of this variable.                                                                                                                                                                                                                                                         |
| `VariableKey`            | `VariableKey`                  | The key for this variable.                                                                                                                                                                                                                                                          |
| `ScopeKey`               | `ScopeKey`                     | The key of the scope where this variable is directly defined. For process-level variables, this is the process instance key. For local variables, this is the key of the specific element instance (task, subprocess, gateway, event, etc.) where the variable is directly defined. |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The key of the process instance of this variable.                                                                                                                                                                                                                                   |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                         |

## VariableScopeCollisionException

Raised when a declared variable name is returned at more than one scope.

The DTO is a flat name-to-value map, but BPMN variables are scoped (process-level vs. local element scopes). When a declared variable resolves to multiple scopes the SDK cannot deterministically choose one, so it raises rather than guessing. Pass `scopeKey` to the search call to disambiguate.

```csharp
public sealed class VariableScopeCollisionException : TypedVariablesException, ISerializable
```

| Property       | Type                    | Description                                                             |
| -------------- | ----------------------- | ----------------------------------------------------------------------- |
| `VariableName` | `String`                | The variable name that was found at multiple scopes.                    |
| `ScopeKeys`    | `IReadOnlyList<String>` | The distinct scope keys the variable was observed at, sorted ascending. |

## VariableSearchQuery

Variable search query request.

```csharp
public sealed class VariableSearchQuery
```

| Property | Type                                   | Description                  |
| -------- | -------------------------------------- | ---------------------------- |
| `Sort`   | `List<VariableSearchQuerySortRequest>` | Sort field criteria.         |
| `Filter` | `VariableFilter`                       | The variable search filters. |
| `Page`   | `SearchQueryPageRequest`               | Pagination criteria.         |

## VariableSearchQueryResult

Variable search query response.

```csharp
public sealed class VariableSearchQueryResult
```

| Property | Type                         | Description                                      |
| -------- | ---------------------------- | ------------------------------------------------ |
| `Items`  | `List<VariableSearchResult>` | The matching variables.                          |
| `Page`   | `SearchQueryPageResponse`    | Pagination information about the search results. |

## VariableSearchQuerySortRequest

```csharp
public sealed class VariableSearchQuerySortRequest
```

| Property | Type                                  | Description                                   |
| -------- | ------------------------------------- | --------------------------------------------- |
| `Field`  | `VariableSearchQuerySortRequestField` | The field to sort by.                         |
| `Order`  | `Nullable<SortOrderEnum>`             | The order in which to sort the related field. |

## VariableSearchResult

Variable search response item.

```csharp
public sealed class VariableSearchResult
```

| Property                 | Type                           | Description                                                                                                                                                                                                                                                                         |
| ------------------------ | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Value`                  | `String`                       | Value of this variable. Can be truncated.                                                                                                                                                                                                                                           |
| `IsTruncated`            | `Boolean`                      | Whether the value is truncated or not.                                                                                                                                                                                                                                              |
| `Name`                   | `String`                       | Name of this variable.                                                                                                                                                                                                                                                              |
| `TenantId`               | `TenantId`                     | Tenant ID of this variable.                                                                                                                                                                                                                                                         |
| `VariableKey`            | `VariableKey`                  | The key for this variable.                                                                                                                                                                                                                                                          |
| `ScopeKey`               | `ScopeKey`                     | The key of the scope where this variable is directly defined. For process-level variables, this is the process instance key. For local variables, this is the key of the specific element instance (task, subprocess, gateway, event, etc.) where the variable is directly defined. |
| `ProcessInstanceKey`     | `ProcessInstanceKey`           | The key of the process instance of this variable.                                                                                                                                                                                                                                   |
| `RootProcessInstanceKey` | `Nullable<ProcessInstanceKey>` | The key of the root process instance. The root process instance is the top-level ancestor in the process instance hierarchy. This field is only present for data belonging to process instance hierarchies created in version 8.9 or later.                                         |

## VariableValidationException

Raised by `VariableMap.Validate` when one or more required DTO members (non-nullable members, or members marked with the `required` modifier) are absent from the search result.

```csharp
public sealed class VariableValidationException : TypedVariablesException, ISerializable
```

| Property               | Type                    | Description                                                   |
| ---------------------- | ----------------------- | ------------------------------------------------------------- |
| `DtoType`              | `Type`                  | The DTO type that failed validation.                          |
| `MissingVariableNames` | `IReadOnlyList<String>` | The variable names of the required members that were missing. |

## VariableValueFilterProperty

```csharp
public sealed class VariableValueFilterProperty
```

| Property | Type                   | Description                                                                                                                                                                                                                                                                                           |
| -------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`   | `String`               | Name of the variable.                                                                                                                                                                                                                                                                                 |
| `Value`  | `StringFilterProperty` | The value of the variable. Variable values in filters need to be in serialized JSON format. For example, a variable with string value `myValue` can be found with the filter value `"myValue"`. Consider appropriate escaping for special characters in JSON strings when constructing filter values. |

## WaitStateDetails

Wait-state-specific details of an element instance.

```csharp
public abstract class WaitStateDetails
```

## WaitStateElementTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct WaitStateElementTypeExactMatch : ICamundaKey, IEquatable<WaitStateElementTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## WaitStateElementTypeFilterProperty

Element type property with full advanced search capabilities.

```csharp
public sealed class WaitStateElementTypeFilterProperty
```

| Property     | Type                                 | Description                                                                                                                                                                                                                                               |
| ------------ | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<WaitStateElementTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<WaitStateElementTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<WaitStateElementTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`                  | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<WaitStateElementTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`               | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## WaitStateTypeExactMatch

Matches the value exactly.

```csharp
public readonly record struct WaitStateTypeExactMatch : ICamundaKey, IEquatable<WaitStateTypeExactMatch>
```

| Property | Type     | Description                  |
| -------- | -------- | ---------------------------- |
| `Value`  | `String` | The underlying string value. |

## WaitStateTypeFilterProperty

Wait state type property with full advanced search capabilities.

```csharp
public sealed class WaitStateTypeFilterProperty
```

| Property     | Type                          | Description                                                                                                                                                                                                                                               |
| ------------ | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ExactMatch` | `Nullable<WaitStateTypeEnum>` | Matches the value exactly. Serialized as the bare value — the form servers that predate advanced filtering on this field accept.                                                                                                                          |
| `Eq`         | `Nullable<WaitStateTypeEnum>` | Checks for equality with the provided value.                                                                                                                                                                                                              |
| `Neq`        | `Nullable<WaitStateTypeEnum>` | Checks for inequality with the provided value.                                                                                                                                                                                                            |
| `Exists`     | `Nullable<Boolean>`           | Checks if the current property exists.                                                                                                                                                                                                                    |
| `In`         | `List<WaitStateTypeEnum>`     | Checks if the property matches any of the provided values.                                                                                                                                                                                                |
| `Like`       | `Nullable<LikeFilter>`        | Checks if the property matches the provided like value. Supported wildcard characters are: * `*`: matches zero, one, or multiple characters. * `?`: matches one, single character. Wildcard characters can be escaped with backslash, for instance: `\*`. |

## WorkerDefaultsConfig

```csharp
public sealed class WorkerDefaultsConfig
```

| Property                  | Type               | Description |
| ------------------------- | ------------------ | ----------- |
| `JobTimeoutMs`            | `Nullable<Int64>`  |             |
| `MaxConcurrentJobs`       | `Nullable<Int32>`  |             |
| `PollTimeoutMs`           | `Nullable<Int64>`  |             |
| `WorkerName`              | `String`           |             |
| `StartupJitterMaxSeconds` | `Nullable<Double>` |             |

---

## Runtime


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Runtime infrastructure types: job workers, backpressure management, eventual consistency polling, error handling, and key serialization.

---

## Authentication(Csharp-sdk)


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

- **OAuth** — Automatic token management with singleflight refresh, caching, and retry
- **Basic** — HTTP Basic Authentication
- **None** — No authentication (local development)

Auth strategy is auto-detected from environment variables when not explicitly set.

---

## Configuration Reference


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

The SDK uses environment variables for configuration, matching the [JS SDK](https://github.com/camunda/orchestration-cluster-api-js) conventions:

| Variable                               | Description                                                     | Default              |
| -------------------------------------- | --------------------------------------------------------------- | -------------------- |
| `CAMUNDA_REST_ADDRESS`                 | Cluster REST API address                                        | —                    |
| `CAMUNDA_AUTH_STRATEGY`                | `NONE`, `OAUTH`, or `BASIC`                                     | Auto-detected        |
| `CAMUNDA_CLIENT_ID`                    | OAuth client ID                                                 | —                    |
| `CAMUNDA_CLIENT_SECRET`                | OAuth client secret                                             | —                    |
| `CAMUNDA_OAUTH_URL`                    | OAuth token endpoint                                            | —                    |
| `CAMUNDA_TOKEN_AUDIENCE`               | OAuth audience                                                  | —                    |
| `CAMUNDA_OAUTH_GRANT_TYPE`             | OAuth grant type                                                | `client_credentials` |
| `CAMUNDA_OAUTH_SCOPE`                  | OAuth scope                                                     | —                    |
| `CAMUNDA_OAUTH_TIMEOUT_MS`             | OAuth token request timeout (ms)                                | `5000`               |
| `CAMUNDA_OAUTH_RETRY_MAX`              | Max OAuth token fetch retries                                   | `5`                  |
| `CAMUNDA_OAUTH_RETRY_BASE_DELAY_MS`    | OAuth retry base delay (ms)                                     | `1000`               |
| `CAMUNDA_BASIC_AUTH_USERNAME`          | Basic auth username                                             | —                    |
| `CAMUNDA_BASIC_AUTH_PASSWORD`          | Basic auth password                                             | —                    |
| `CAMUNDA_DEFAULT_TENANT_ID`            | Default tenant ID                                               | `<default>`          |
| `CAMUNDA_SDK_LOG_LEVEL`                | Log level (`error`, `warn`, `info`, `debug`, `trace`, `silent`) | `error`              |
| `CAMUNDA_SDK_VALIDATION`               | Validation mode (see below)                                     | `req:none,res:none`  |
| `CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS`  | Total HTTP retry attempts (initial + retries)                   | `3`                  |
| `CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS` | HTTP retry base backoff (ms)                                    | `100`                |
| `CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS`  | HTTP retry max backoff cap (ms)                                 | `2000`               |
| `CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS` | Default eventual consistency poll interval (ms)                 | `500`                |
| `ZEEBE_REST_ADDRESS`                   | Alias for `CAMUNDA_REST_ADDRESS`                                | —                    |
| `CAMUNDA_MTLS_CERT`                    | Inline PEM client certificate                                   | —                    |
| `CAMUNDA_MTLS_KEY`                     | Inline PEM client private key                                   | —                    |
| `CAMUNDA_MTLS_CA`                      | Inline PEM CA bundle                                            | —                    |
| `CAMUNDA_MTLS_CERT_PATH`               | Path to client certificate (PEM)                                | —                    |
| `CAMUNDA_MTLS_KEY_PATH`                | Path to client private key (PEM)                                | —                    |
| `CAMUNDA_MTLS_CA_PATH`                 | Path to CA bundle (PEM)                                         | —                    |
| `CAMUNDA_MTLS_KEY_PASSPHRASE`          | Passphrase for encrypted private key                            | —                    |

For backpressure configuration variables, see [Global Backpressure](resilience.md#global-backpressure-adaptive-concurrency).

---

## Creating a Process Instance


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

The recommended pattern is to obtain keys from a prior API response (e.g. a deployment) and pass them directly — no manual conversion needed:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+ReadmeCreateProcessInstance -->

```csharp
using Camunda.Orchestration.Sdk;

using var client = CamundaClient.Create();

var deployment = await client.DeployResourcesFromFilesAsync(["process.bpmn"]);
var processKey = deployment.Processes[0].ProcessDefinitionKey;

var result = await client.CreateProcessInstanceAsync(
    new ProcessInstanceCreationInstructionByKey
    {
        ProcessDefinitionKey = processKey,
    });

Console.WriteLine($"Process instance key: {result.ProcessInstanceKey}");
```

If you need to restore a key from external storage (database, message queue, config file), wrap the raw value with the domain key constructor:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+CreateProcessFromStorage -->

```csharp
using Camunda.Orchestration.Sdk;

using var client = CamundaClient.Create();

var storedKey = "2251799813685249"; // from a DB row or config
var result = await client.CreateProcessInstanceAsync(
    new ProcessInstanceCreationInstructionByKey
    {
        ProcessDefinitionKey = ProcessDefinitionKey.AssumeExists(storedKey),
    });

Console.WriteLine($"Process instance key: {result.ProcessInstanceKey}");
```

You can also start a process instance by BPMN process ID (which uses the latest deployed version):

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: CreateProcessById -->

```csharp
var result = await client.CreateProcessInstanceAsync(
    new ProcessInstanceCreationInstructionById
    {
        ProcessDefinitionId = ProcessDefinitionId.AssumeExists("my-process-id"),
    });
```

---

## Deploying Resources


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Deploy BPMN, DMN, or Form files from disk:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+DeployResources -->

```csharp
using Camunda.Orchestration.Sdk;

using var client = CamundaClient.Create();

var result = await client.DeployResourcesFromFilesAsync(["process.bpmn", "decision.dmn"]);

Console.WriteLine($"Deployment key: {result.DeploymentKey}");
foreach (var process in result.Processes)
{
    Console.WriteLine($"  Process: {process.ProcessDefinitionId} (key: {process.ProcessDefinitionKey})");
}
```

---

## Installation


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

```bash
dotnet add package Camunda.Orchestration.Sdk
```

## Versioning

This SDK has a different release cadence from the Camunda server. Features and fixes land in the SDK during a server release.

The major version of the SDK signals a 1:1 type coherence with the server API for a Camunda minor release.

SDK version `n.y.z` -> server version `8.n`, so the type surface of SDK version 9.y.z matches the API surface of Camunda 8.9.

Using a later SDK version, for example: SDK version 10.y.z with Camunda 8.9, means that the SDK contains additive surfaces that are not guaranteed at runtime, and the compiler cannot warn of unsupported operations.

Using an earlier SDK version, for example: SDK version 9.y.z with Camunda 8.10, results in slightly degraded compiler reasoning: exhaustiveness checks cannot be guaranteed by the compiler for any extended surfaces (principally, enums with added members).

In the vast majority of use-cases, this will not be an issue; but you should be aware that using the matching SDK major version for the server minor version provides the strongest compiler guarantees about runtime reliability.

**Release lines** map to branches. Stable releases for a given server minor come from the `stable/<major>` branch — `stable/9` publishes the `9.x` line for Camunda 8.9. The `main` branch publishes alpha prereleases for the **next** server minor — currently the `10.0.0-alpha.N` line for Camunda 8.10. Pick the line that matches your server: the latest `9.x` for 8.9, or opt into `10.x-alpha` to preview 8.10.

**Recommended approach**:

- Check the [CHANGELOG](https://github.com/camunda/orchestration-cluster-api-csharp/releases).
- As a sanity check during server version upgrade, rebuild applications with the matching SDK major version to identify any affected runtime surfaces.

---

## Job Workers


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Job workers subscribe to a specific job type and process jobs as they become available. The worker handles polling, concurrent dispatch, auto-completion, and error handling.

## Basic Worker

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+BasicWorker+BasicWorkerBody -->

```csharp
using Camunda.Orchestration.Sdk;

// Define input/output DTOs
public record OrderOutput(bool Processed, string InvoiceNumber);

using var client = CamundaClient.Create();

client.CreateJobWorker(
    new JobWorkerConfig
    {
        JobType = "process-order",
        JobTimeoutMs = 30_000,
    },
    async (job, ct) =>
    {
        var input = job.GetVariables<OrderInput>();
        var invoice = await ProcessOrder(input!, ct);

        // Return value auto-completes the job with these output variables
        return new OrderOutput(true, invoice);
    });

// Block until Ctrl+C
using var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) => { e.Cancel = true; cts.Cancel(); };
await client.RunWorkersAsync(ct: cts.Token);
```

## Handler Contract

The handler return value determines the job outcome:

| Handler behavior              | Job outcome                                           |
| ----------------------------- | ----------------------------------------------------- |
| Return `object`               | Auto-complete with those variables                    |
| Return `null`                 | Auto-complete with no variables                       |
| Return `JobCompletionRequest` | Complete with structured result (corrections, denial) |
| Throw `BpmnErrorException`    | Trigger a BPMN error boundary event                   |
| Throw `JobFailureException`   | Fail with custom retries / back-off                   |
| Throw any other exception     | Auto-fail with `retries - 1`                          |

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: ErrorHandling+ErrorHandlingFailure -->

```csharp
// BPMN error — caught by error boundary events in the process model
throw new BpmnErrorException("INVALID_ORDER", "Order not found");

// Explicit failure with retry control
throw new JobFailureException("Service unavailable", retries: 2, retryBackOffMs: 5000);
```

## Job Corrections (User Task Listeners)

When handling jobs from [user task listeners](../../components/concepts/user-task-listeners.md), you can return a `JobCompletionRequest` to apply corrections to the task or deny the action. Return a `JobCompletionRequest` from the handler instead of a plain variables object:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: JobCorrections -->

```csharp
client.CreateJobWorker(config, async (job, ct) =>
{
    // Apply corrections to the user task
    return new JobCompletionRequest
    {
        Variables = new { reviewed = true },
        Result = new JobResultUserTask
        {
            Corrections = new JobResultCorrections
            {
                Assignee = "new-assignee",
                Priority = 75,
                CandidateGroups = new List<string> { "managers" },
            },
        },
    };
});
```

To deny the user task action (e.g. reject a completion):

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: JobCorrectionsDenied -->

```csharp
client.CreateJobWorker(config, async (job, ct) =>
{
    return new JobCompletionRequest
    {
        Result = new JobResultUserTask
        {
            Denied = true,
            DeniedReason = "Missing required fields",
        },
    };
});
```

## Void Handler (No Output Variables)

For handlers that don't return output variables, use the void overload:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: VoidHandler+VoidHandlerBody -->

```csharp
public record NotificationInput(string Message);

client.CreateJobWorker(config, async (job, ct) =>
{
    await SendNotification(job.GetVariables<NotificationInput>()!, ct);
    // Auto-completes with no variables
});
```

## Configuration

| Property                  | Default            | Description                                                                                                      |
| ------------------------- | ------------------ | ---------------------------------------------------------------------------------------------------------------- |
| `JobType`                 | _(required)_       | BPMN task type to subscribe to                                                                                   |
| `JobTimeoutMs`            | _(env / required)_ | Job lock duration (ms). Falls back to `CAMUNDA_WORKER_TIMEOUT` env var.                                          |
| `MaxConcurrentJobs`       | `10`               | Max in-flight jobs per worker. Falls back to `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS` env var, then `10`.            |
| `PollIntervalMs`          | `500`              | Delay between polls when idle                                                                                    |
| `PollTimeoutMs`           | `null`             | Long-poll timeout (null = broker default). Falls back to `CAMUNDA_WORKER_REQUEST_TIMEOUT` env var.               |
| `FetchVariables`          | `null`             | Variable names to fetch (null = all)                                                                             |
| `WorkerName`              | auto               | Worker name for logging. Falls back to `CAMUNDA_WORKER_NAME` env var.                                            |
| `AutoStart`               | `true`             | Start polling on creation                                                                                        |
| `StartupJitterMaxSeconds` | `0`                | Max random delay (seconds) before first poll. Falls back to `CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS` env var. |

## Heritable Worker Defaults

When running many workers with the same base configuration, you can set global defaults via environment variables. These apply to every worker created by the client unless the individual `JobWorkerConfig` explicitly overrides them.

| Environment Variable                        | Config Property           | Type   |
| ------------------------------------------- | ------------------------- | ------ |
| `CAMUNDA_WORKER_TIMEOUT`                    | `JobTimeoutMs`            | long   |
| `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS`        | `MaxConcurrentJobs`       | int    |
| `CAMUNDA_WORKER_REQUEST_TIMEOUT`            | `PollTimeoutMs`           | long   |
| `CAMUNDA_WORKER_NAME`                       | `WorkerName`              | string |
| `CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS` | `StartupJitterMaxSeconds` | int    |

**Precedence:** explicit `JobWorkerConfig` value > environment variable > hardcoded default.

```bash
export CAMUNDA_WORKER_TIMEOUT=30000
export CAMUNDA_WORKER_MAX_CONCURRENT_JOBS=8
export CAMUNDA_WORKER_NAME=order-service
```

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: WorkerDefaultsEnv -->

```csharp
// Workers inherit timeout, concurrency, and name from environment
client.CreateJobWorker(
    new JobWorkerConfig { JobType = "validate-order" },
    async (job, ct) => null);

client.CreateJobWorker(
    new JobWorkerConfig { JobType = "ship-order" },
    async (job, ct) => null);

// Per-worker override: this worker uses 32 concurrent jobs instead of the global 8
client.CreateJobWorker(
    new JobWorkerConfig { JobType = "bulk-import", MaxConcurrentJobs = 32 },
    async (job, ct) => null);
```

You can also pass defaults programmatically via the client constructor:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: WorkerDefaultsClient -->

```csharp
var client = CamundaClient.Create(new CamundaOptions
{
    Config = new Dictionary<string, string>
    {
        ["CAMUNDA_WORKER_TIMEOUT"] = "30000",
        ["CAMUNDA_WORKER_MAX_CONCURRENT_JOBS"] = "8",
    },
});
```

## Concurrency

Jobs are dispatched as concurrent `Task`s on the .NET thread pool. `MaxConcurrentJobs` controls how many jobs may be in-flight simultaneously.

- **I/O-bound handlers** (HTTP calls, database queries): higher values like 32–128 improve throughput because `async` handlers release threads during `await` points — many jobs, few OS threads.
- **CPU-bound handlers**: set `MaxConcurrentJobs` to `Environment.ProcessorCount` to match cores.
- **Sequential processing**: set `MaxConcurrentJobs = 1`.

## Lifecycle

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: WorkerLifecycle -->

```csharp
// Manual start/stop
var worker = client.CreateJobWorker(new JobWorkerConfig { JobType = "example", JobTimeoutMs = 30_000, AutoStart = false }, handler);
worker.Start();

// Graceful stop — waits up to 10s for in-flight jobs to finish
var result = await worker.StopAsync(gracePeriod: TimeSpan.FromSeconds(10));
// result.RemainingJobs, result.TimedOut

// Or stop all workers at once
await client.StopAllWorkersAsync(TimeSpan.FromSeconds(10));

// DisposeAsync stops workers automatically
await using var disposableClient = CamundaClient.Create();
```

---

## Logging


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

The SDK uses `Microsoft.Extensions.Logging` — the standard .NET logging abstraction. This means it integrates with any logging framework that supports `ILoggerFactory` (Serilog, NLog, the built-in console logger, etc.).

## Default Behavior

When no logger is injected, the SDK uses a built-in console logger filtered by `CAMUNDA_SDK_LOG_LEVEL`:

| `CAMUNDA_SDK_LOG_LEVEL` | What is logged                                                   |
| ----------------------- | ---------------------------------------------------------------- |
| `error` (default)       | Errors only                                                      |
| `warn`                  | Errors + warnings                                                |
| `info`                  | + OAuth token events, worker start/stop                          |
| `debug`                 | + HTTP requests/responses, retry decisions, backpressure changes |
| `trace`                 | + tenant injection, internal diagnostics                         |
| `silent`                | Nothing (same as `NullLoggerFactory`)                            |

Output uses a tagged format matching the JS SDK:

```
[camunda-sdk][info][CamundaClient] CamundaClient constructed with auth strategy OAuth
[camunda-sdk][debug][CamundaClient] HTTP POST process-instances/search -> 200
[camunda-sdk][info][JobWorker.worker-process-order-1] JobWorker 'worker-process-order-1' started for type 'process-order'
```

## Injecting Your Own Logger

Pass an `ILoggerFactory` via `CamundaOptions` to integrate with your application's logging:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+InjectLogger -->

```csharp
using Camunda.Orchestration.Sdk;

using var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddConsole()
        .SetMinimumLevel(LogLevel.Debug);
});

using var client = CamundaClient.Create(new CamundaOptions
{
    LoggerFactory = loggerFactory,
});
```

When an `ILoggerFactory` is provided, `CAMUNDA_SDK_LOG_LEVEL` is ignored — filtering is controlled entirely by the injected factory.

## ASP.NET Core / Dependency Injection

When using `AddCamundaClient()`, the SDK automatically resolves `ILoggerFactory` from the DI container — no manual wiring needed:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+DILogging -->

```csharp
using Camunda.Orchestration.Sdk;

var builder = WebApplication.CreateBuilder(args);

// Logging configuration
builder.Logging.SetMinimumLevel(LogLevel.Debug);

// SDK automatically uses the host's ILoggerFactory
builder.Services.AddCamundaClient(builder.Configuration.GetSection("Camunda"));
```

All SDK log entries appear alongside your application logs with proper category names (`Camunda.Orchestration.Sdk.CamundaClient`, `Camunda.Orchestration.Sdk.JobWorker.*`, etc.).

## Serilog Integration

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: SerilogIntegration -->

```csharp
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .CreateLogger();

using var loggerFactory = new SerilogLoggerFactory();
using var client = CamundaClient.Create(new CamundaOptions
{
    LoggerFactory = loggerFactory,
});
```

## What Gets Logged

| Component             | Level   | Events                                            |
| --------------------- | ------- | ------------------------------------------------- |
| `CamundaClient`       | Debug   | HTTP request method + path, response status codes |
| `CamundaClient`       | Warning | HTTP request failures (non-2xx)                   |
| `CamundaClient`       | Trace   | Default tenant ID injection                       |
| `OAuthManager`        | Debug   | Token request attempts                            |
| `OAuthManager`        | Info    | Token acquired (with effective expiry)            |
| `BackpressureManager` | Debug   | Permit reduction/recovery                         |
| `HttpRetryExecutor`   | Debug   | Retry attempts with delay and reason              |
| `JobWorker.*`         | Info    | Worker started, worker stopped                    |
| `JobWorker.*`         | Debug   | Job completed                                     |
| `JobWorker.*`         | Error   | Handler exceptions, poll failures                 |
| `EventualPoller`      | Debug   | Consistency polling progress                      |

---

## Migration Guide: v9 → v10


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

This section covers breaking changes and new features when upgrading from `Camunda.Orchestration.Sdk` v9 (Camunda 8.9) to v10 (Camunda 8.10).

> **Note:** v10 is currently in alpha (`10.0.0-alpha.N` on NuGet). The changes listed here may evolve before the stable v10.0.0 release.

## Package update

```xml
<!-- Before -->
<PackageReference Include="Camunda.Orchestration.Sdk" Version="9.*" />

<!-- After -->
<PackageReference Include="Camunda.Orchestration.Sdk" Version="10.*" />
```

Or via the CLI:

```bash
dotnet add package Camunda.Orchestration.Sdk --version "10.*-*"
```

## Breaking changes

### Type renames (bundler dedup)

The v10 generator uses an upgraded spec bundler that correctly preserves upstream schema names instead of inventing inline names. Several types that were previously generated as standalone classes are now replaced by their canonical upstream equivalents.

If your code references any of the old type names, update them to the new names:

| Removed type (v9)                         | Replacement (v10)                             |
| ----------------------------------------- | --------------------------------------------- |
| `CreateMappingRuleResponse`               | `MappingRuleCreateResult`                     |
| `GetUserResponse`                         | `UserResult`                                  |
| `SearchClientsForGroupRequest`            | `GroupClientSearchQueryRequest`               |
| `SearchClientsForGroupResponse`           | `GroupClientSearchResult`                     |
| `SearchClientsForRoleRequest`             | `RoleClientSearchQueryRequest`                |
| `SearchClientsForRoleResponse`            | `RoleClientSearchResult`                      |
| `SearchClientsForTenantRequest`           | `TenantClientSearchQueryRequest`              |
| `SearchClientsForTenantResponse`          | `TenantClientSearchResult`                    |
| `SearchMappingRuleResponse`               | `MappingRuleSearchQueryResult`                |
| `SearchMappingRulesForGroupResponse`      | `GroupMappingRuleSearchResult`                |
| `SearchMappingRulesForRoleResponse`       | `RoleMappingRuleSearchResult`                 |
| `SearchMappingRulesForTenantResponse`     | `TenantMappingRuleSearchResult`               |
| `SearchRolesForGroupResponse`             | `GroupRoleSearchResult`                       |
| `SearchRolesForTenantResponse`            | `TenantRoleSearchResult`                      |
| `SearchUsersForGroupRequest`              | `GroupUserSearchQueryRequest`                 |
| `SearchUsersForGroupResponse`             | `GroupUserSearchResult`                       |
| `SearchUsersForRoleRequest`               | `RoleUserSearchQueryRequest`                  |
| `SearchUsersForRoleResponse`              | `RoleUserSearchResult`                        |
| `SearchUsersForTenantRequest`             | `TenantUserSearchQueryRequest`                |
| `SearchUsersForTenantResponse`            | `TenantUserSearchResult`                      |
| `SearchUsersResponse`                     | `UserSearchResult`                            |
| `SearchUserTaskEffectiveVariablesRequest` | `UserTaskEffectiveVariableSearchQueryRequest` |
| `SearchUserTaskVariablesRequest`          | `UserTaskVariableSearchQueryRequest`          |
| `SearchVariablesRequest`                  | `VariableSearchQuery`                         |
| `UpdateMappingRuleResponse`               | `MappingRuleUpdateResult`                     |
| `UpdateUserResponse`                      | `UserUpdateResult`                            |

The replacement types are structurally identical — only the names change. A find-and-replace across your codebase is sufficient.

### Method signature changes

The following methods have updated parameter and/or return types to match the type renames above:

| Method                                  | Changed parameter / return type                                                                     |
| --------------------------------------- | --------------------------------------------------------------------------------------------------- |
| `CreateMappingRuleAsync`                | Returns `MappingRuleCreateResult` (was `CreateMappingRuleResponse`)                                 |
| `UpdateMappingRuleAsync`                | Returns `MappingRuleUpdateResult` (was `UpdateMappingRuleResponse`)                                 |
| `SearchMappingRuleAsync`                | Returns `MappingRuleSearchQueryResult` (was `SearchMappingRuleResponse`)                            |
| `SearchClientsForGroupAsync`            | Takes `GroupClientSearchQueryRequest`, returns `GroupClientSearchResult`                            |
| `SearchClientsForRoleAsync`             | Takes `RoleClientSearchQueryRequest`, returns `RoleClientSearchResult`                              |
| `SearchClientsForTenantAsync`           | Takes `TenantClientSearchQueryRequest`, returns `TenantClientSearchResult`                          |
| `SearchMappingRulesForGroupAsync`       | Returns `GroupMappingRuleSearchResult`                                                              |
| `SearchMappingRulesForRoleAsync`        | Returns `RoleMappingRuleSearchResult`                                                               |
| `SearchMappingRulesForTenantAsync`      | Returns `TenantMappingRuleSearchResult`                                                             |
| `SearchRolesForGroupAsync`              | Returns `GroupRoleSearchResult`                                                                     |
| `SearchRolesForTenantAsync`             | Returns `TenantRoleSearchResult`                                                                    |
| `SearchUsersForGroupAsync`              | Takes `GroupUserSearchQueryRequest`, returns `GroupUserSearchResult`                                |
| `SearchUsersForRoleAsync`               | Takes `RoleUserSearchQueryRequest`, returns `RoleUserSearchResult`                                  |
| `SearchUsersForTenantAsync`             | Takes `TenantUserSearchQueryRequest`, returns `TenantUserSearchResult`                              |
| `SearchUserTaskEffectiveVariablesAsync` | Takes `UserTaskEffectiveVariableSearchQueryRequest` (was `SearchUserTaskEffectiveVariablesRequest`) |
| `SearchUserTaskVariablesAsync`          | Takes `UserTaskVariableSearchQueryRequest` (was `SearchUserTaskVariablesRequest`)                   |
| `SearchVariablesAsync`                  | Takes `VariableSearchQuery` (was `SearchVariablesRequest`)                                          |
| `GetUserAsync`                          | Returns `UserResult` (was `GetUserResponse`)                                                        |
| `SearchUsersAsync`                      | Returns `UserSearchResult` (was `SearchUsersResponse`)                                              |
| `UpdateUserAsync`                       | Returns `UserUpdateResult` (was `UpdateUserResponse`)                                               |
| `GetDocumentAsync`                      | Returns `byte[]` (was `object`)                                                                     |
| `GetResourceContentBinaryAsync`         | Returns `byte[]` (new in v10)                                                                       |

### Binary response handling

Operations that return `application/octet-stream` content (such as `GetDocumentAsync`) now correctly return `byte[]` instead of `object`. In v9, these methods attempted to JSON-deserialize the binary response body, which threw `JsonException` for non-JSON content and returned an unusable `JsonElement` for JSON content. No migration action is needed unless your code caught the `JsonException` and worked around it.

### Inline string enums

45 properties that were previously typed as bare `string` are now typed C# enums. This gives compile-time validation, IntelliSense, and parity with the JS and Python SDKs.

The affected properties are mainly sort-request `Field` properties, plus a few `Type`, `State`, `Health`, and `Role` properties:

<!-- snippet-exempt: migration before/after comparison (v9 code won't compile against v10) -->

```csharp
// Before (v9) — bare string, no compile-time checking
var sort = new UserTaskSearchQuerySortRequest
{
    Field = "completionTime",
    Order = SortOrderEnum.Asc,
};

// After (v10) — typed enum with IntelliSense
var sort = new UserTaskSearchQuerySortRequest
{
    Field = UserTaskSearchQuerySortRequestField.CompletionTime,
    Order = SortOrderEnum.Asc,
};
```

Complete list of affected properties (45 total):

| Type                                                            | Property              | Enum                                                                 |
| --------------------------------------------------------------- | --------------------- | -------------------------------------------------------------------- |
| `AgentInstanceSearchQuerySortRequest`                           | `Field`               | `AgentInstanceSearchQuerySortRequestField`                           |
| `AuditLogSearchQuerySortRequest`                                | `Field`               | `AuditLogSearchQuerySortRequestField`                                |
| `AuthorizationSearchQuerySortRequest`                           | `Field`               | `AuthorizationSearchQuerySortRequestField`                           |
| `BatchOperationError`                                           | `Type`                | `BatchOperationErrorType`                                            |
| `BatchOperationItemResponse`                                    | `State`               | `BatchOperationItemResponseState`                                    |
| `BatchOperationItemSearchQuerySortRequest`                      | `Field`               | `BatchOperationItemSearchQuerySortRequestField`                      |
| `BatchOperationSearchQuerySortRequest`                          | `Field`               | `BatchOperationSearchQuerySortRequestField`                          |
| `ClusterVariableSearchQuerySortRequest`                         | `Field`               | `ClusterVariableSearchQuerySortRequestField`                         |
| `CorrelatedMessageSubscriptionSearchQuerySortRequest`           | `Field`               | `CorrelatedMessageSubscriptionSearchQuerySortRequestField`           |
| `DecisionDefinitionSearchQuerySortRequest`                      | `Field`               | `DecisionDefinitionSearchQuerySortRequestField`                      |
| `DecisionInstanceSearchQuerySortRequest`                        | `Field`               | `DecisionInstanceSearchQuerySortRequestField`                        |
| `DecisionRequirementsSearchQuerySortRequest`                    | `Field`               | `DecisionRequirementsSearchQuerySortRequestField`                    |
| `DocumentReference`                                             | `CamundaDocumentType` | `DocumentReferenceCamundaDocumentType`                               |
| `ElementInstanceFilter`                                         | `Type`                | `ElementInstanceFilterType`                                          |
| `ElementInstanceResult`                                         | `Type`                | `ElementInstanceResultType`                                          |
| `ElementInstanceSearchQuerySortRequest`                         | `Field`               | `ElementInstanceSearchQuerySortRequestField`                         |
| `GlobalTaskListenerSearchQuerySortRequest`                      | `Field`               | `GlobalTaskListenerSearchQuerySortRequestField`                      |
| `GroupClientSearchQuerySortRequest`                             | `Field`               | `GroupClientSearchQuerySortRequestField`                             |
| `GroupSearchQuerySortRequest`                                   | `Field`               | `GroupSearchQuerySortRequestField`                                   |
| `GroupUserSearchQuerySortRequest`                               | `Field`               | `GroupUserSearchQuerySortRequestField`                               |
| `IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest` | `Field`               | `IncidentProcessInstanceStatisticsByDefinitionQuerySortRequestField` |
| `IncidentProcessInstanceStatisticsByErrorQuerySortRequest`      | `Field`               | `IncidentProcessInstanceStatisticsByErrorQuerySortRequestField`      |
| `IncidentSearchQuerySortRequest`                                | `Field`               | `IncidentSearchQuerySortRequestField`                                |
| `JobSearchQuerySortRequest`                                     | `Field`               | `JobSearchQuerySortRequestField`                                     |
| `MappingRuleSearchQuerySortRequest`                             | `Field`               | `MappingRuleSearchQuerySortRequestField`                             |
| `MessageSubscriptionSearchQuerySortRequest`                     | `Field`               | `MessageSubscriptionSearchQuerySortRequestField`                     |
| `Partition`                                                     | `Health`              | `PartitionHealth`                                                    |
| `Partition`                                                     | `Role`                | `PartitionRole`                                                      |
| `ProcessDefinitionInstanceStatisticsQuerySortRequest`           | `Field`               | `ProcessDefinitionInstanceStatisticsQuerySortRequestField`           |
| `ProcessDefinitionInstanceVersionStatisticsQuerySortRequest`    | `Field`               | `ProcessDefinitionInstanceVersionStatisticsQuerySortRequestField`    |
| `ProcessDefinitionSearchQuerySortRequest`                       | `Field`               | `ProcessDefinitionSearchQuerySortRequestField`                       |
| `ProcessInstanceSearchQuerySortRequest`                         | `Field`               | `ProcessInstanceSearchQuerySortRequestField`                         |
| `ResourceSearchQuerySortRequest`                                | `Field`               | `ResourceSearchQuerySortRequestField`                                |
| `RoleClientSearchQuerySortRequest`                              | `Field`               | `RoleClientSearchQuerySortRequestField`                              |
| `RoleGroupSearchQuerySortRequest`                               | `Field`               | `RoleGroupSearchQuerySortRequestField`                               |
| `RoleSearchQuerySortRequest`                                    | `Field`               | `RoleSearchQuerySortRequestField`                                    |
| `RoleUserSearchQuerySortRequest`                                | `Field`               | `RoleUserSearchQuerySortRequestField`                                |
| `TenantClientSearchQuerySortRequest`                            | `Field`               | `TenantClientSearchQuerySortRequestField`                            |
| `TenantGroupSearchQuerySortRequest`                             | `Field`               | `TenantGroupSearchQuerySortRequestField`                             |
| `TenantSearchQuerySortRequest`                                  | `Field`               | `TenantSearchQuerySortRequestField`                                  |
| `TenantUserSearchQuerySortRequest`                              | `Field`               | `TenantUserSearchQuerySortRequestField`                              |
| `UserSearchQuerySortRequest`                                    | `Field`               | `UserSearchQuerySortRequestField`                                    |
| `UserTaskSearchQuerySortRequest`                                | `Field`               | `UserTaskSearchQuerySortRequestField`                                |
| `UserTaskVariableSearchQuerySortRequest`                        | `Field`               | `UserTaskVariableSearchQuerySortRequestField`                        |
| `VariableSearchQuerySortRequest`                                | `Field`               | `VariableSearchQuerySortRequestField`                                |

The naming convention is `{ParentClassName}{PascalCase(PropertyName)}` (e.g., `UserTaskSearchQuerySortRequestField`).

### Eventual consistency parameter types

`GetResourceAsync` and `GetResourceContentAsync` now accept an optional `ConsistencyOptions` parameter, matching the pattern used by all other eventually-consistent endpoints. If you pass these methods by reference or use them in delegates, you may need to update the signature:

<!-- snippet-exempt: migration before/after comparison (v9 code won't compile against v10) -->

```csharp
// Before (v9)
var resource = await client.GetResourceAsync(resourceKey);

// After (v10) — the call is unchanged, but the optional parameter exists
var resource = await client.GetResourceAsync(resourceKey);
// Or, with eventual consistency:
var resource = await client.GetResourceAsync(resourceKey,
    new ConsistencyOptions<ResourceResult> { WaitUpToMs = 5000 });
```

## New features in v10

### Resource search

v10 adds a `SearchResourcesAsync` method with full search, filter, and sort support:

<!-- snippet-exempt: illustrative usage with placeholder filter -->

```csharp
var result = await client.SearchResourcesAsync(new ResourceSearchQuery
{
    Filter = new ResourceFilter { /* ... */ },
    Sort = [new ResourceSearchQuerySortRequest
    {
        Field = ResourceSearchQuerySortRequestField.DeploymentKey,
    }],
});
```

Supporting types: `ResourceSearchQuery`, `ResourceFilter`, `ResourceSearchQueryResult`, `ResourceSearchQuerySortRequest`, `ResourceSearchQuerySortRequestField`.

### New filter properties

The following filter properties are now available on existing search filters:

- **`ElementIdFilterProperty`** — filter by element ID on flow node instance searches (`AdvancedElementIdFilter`, `ElementIdExactMatch`).
- **`ProcessDefinitionIdFilterProperty`** — filter by process definition ID (`AdvancedProcessDefinitionIdFilter`, `ProcessDefinitionIdExactMatch`).
- **`MessageSubscriptionTypeFilterProperty`** — filter message subscriptions by type (`AdvancedMessageSubscriptionTypeFilter`, `MessageSubscriptionTypeExactMatch`).

### New enum

- **`MessageSubscriptionTypeEnum`** — discriminates message subscription types.

## No changes between v9 and v10

The following areas are **unchanged** between v9 and v10:

- **Target framework**: .NET 8.0+
- **Runtime behavior**: Auth, retry, backpressure, job workers, eventual consistency polling
- **Configuration**: All `CAMUNDA_*` environment variables and `CamundaOptions` properties
- **Branded types**: All existing `ICamundaKey` types (`ProcessDefinitionKey`, `UserTaskKey`, etc.) retain the same API. v10 adds new branded types: `GroupId`, `RoleId`, `ClientId`, `MappingRuleId`, `AgentInstanceKey`, `ClusterVariableName`
- **Enum handling**: `TolerantEnumConverter` continues to handle unknown enum values gracefully

---

## Quick Start (Zero-Config — Recommended)


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Keep configuration out of application code. Let the factory read `CAMUNDA_*` variables from the environment (12-factor style). This makes rotation, secret management, and environment promotion safer and simpler.

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+QuickStart -->

```csharp
using Camunda.Orchestration.Sdk;

// Zero-config construction: reads CAMUNDA_* from environment variables.
// If no configuration is present, defaults to Camunda 8 Run on localhost.
using var client = CamundaClient.Create();

var topology = await client.GetTopologyAsync();
Console.WriteLine($"Brokers: {topology.Brokers?.Count ?? 0}");
```

Typical environment (example):

```bash
CAMUNDA_REST_ADDRESS=https://cluster.example   # SDK appends /v2 automatically
CAMUNDA_AUTH_STRATEGY=OAUTH
CAMUNDA_CLIENT_ID=***
CAMUNDA_CLIENT_SECRET=***
CAMUNDA_OAUTH_URL=https://login.cloud.camunda.io/oauth/token
CAMUNDA_DEFAULT_TENANT_ID=<default>            # optional: override default tenant
```

> **Why zero-config?**
>
> - **Separation of concerns**: business code depends on an interface, not on secrets/constants wiring.
> - **12-Factor alignment**: config lives in the environment → simpler promotion (dev → staging → prod).
> - **Secret rotation**: rotate credentials without a code change or redeploy.
> - **Immutable start**: single hydration pass prevents drift / mid-request mutations.
> - **Test ergonomics**: swap env vars per test without touching source; create multiple clients for multi-tenant tests.
> - **Security review**: fewer code paths handling secrets; scanners & vault tooling work at the boundary.
> - **Deploy portability**: same artifact runs everywhere; only the environment differs.
> - **Cross-SDK consistency**: identical variable names across JavaScript, C#, and Python SDKs.

## Programmatic Overrides (Advanced)

Use only when you must supply or mutate configuration dynamically (e.g. multi-tenant routing, tests, ephemeral preview environments). Keys mirror their `CAMUNDA_*` env names:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+ProgrammaticOverrides -->

```csharp
using Camunda.Orchestration.Sdk;

using var client = CamundaClient.Create(new CamundaOptions
{
    Config = new Dictionary<string, string>
    {
        ["CAMUNDA_REST_ADDRESS"] = "https://my-cluster.camunda.io",
        ["CAMUNDA_AUTH_STRATEGY"] = "OAUTH",
        ["CAMUNDA_CLIENT_ID"] = "my-client-id",
        ["CAMUNDA_CLIENT_SECRET"] = "my-secret",
        ["CAMUNDA_OAUTH_URL"] = "https://login.cloud.camunda.io/oauth/token",
        ["CAMUNDA_TOKEN_AUDIENCE"] = "zeebe.camunda.io",
    },
});
```

## Configuration via `appsettings.json`

The SDK can read configuration from any `IConfiguration` source (appsettings.json, user secrets, Azure Key Vault, etc.) using idiomatic .NET PascalCase section keys:

```json
{
  "Camunda": {
    "RestAddress": "https://cluster.example.com",
    "Auth": {
      "Strategy": "OAUTH",
      "ClientId": "my-client-id",
      "ClientSecret": "my-secret"
    },
    "OAuth": {
      "Url": "https://login.cloud.camunda.io/oauth/token"
    },
    "Backpressure": {
      "Profile": "CONSERVATIVE"
    }
  }
}
```

Pass the section to the client:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+AppSettingsConfig -->

```csharp
using Camunda.Orchestration.Sdk;

var builder = WebApplication.CreateBuilder(args);

using var client = CamundaClient.Create(new CamundaOptions
{
    Configuration = builder.Configuration.GetSection("Camunda"),
});
```

Precedence (highest wins): `Config` dictionary > `IConfiguration` section > environment variables > defaults.

This means you can set secrets via environment variables (or a vault) and non-sensitive settings via `appsettings.json` — they layer naturally:

```json
// appsettings.json — non-sensitive, checked into source control
{
  "Camunda": {
    "RestAddress": "https://cluster.example.com",
    "Backpressure": { "Profile": "CONSERVATIVE" }
  }
}
```

```bash
# Secrets injected via environment (vault, CI, container orchestrator)
CAMUNDA_CLIENT_ID=***
CAMUNDA_CLIENT_SECRET=***
CAMUNDA_OAUTH_URL=https://login.cloud.camunda.io/oauth/token
```

<details>
<summary>appsettings.json key reference</summary>

| appsettings.json key              | Maps to env var                                 |
| --------------------------------- | ----------------------------------------------- |
| `RestAddress`                     | `CAMUNDA_REST_ADDRESS`                          |
| `TokenAudience`                   | `CAMUNDA_TOKEN_AUDIENCE`                        |
| `DefaultTenantId`                 | `CAMUNDA_DEFAULT_TENANT_ID`                     |
| `LogLevel`                        | `CAMUNDA_SDK_LOG_LEVEL`                         |
| `Validation`                      | `CAMUNDA_SDK_VALIDATION`                        |
| `Auth:Strategy`                   | `CAMUNDA_AUTH_STRATEGY`                         |
| `Auth:ClientId`                   | `CAMUNDA_CLIENT_ID`                             |
| `Auth:ClientSecret`               | `CAMUNDA_CLIENT_SECRET`                         |
| `Auth:BasicUsername`              | `CAMUNDA_BASIC_AUTH_USERNAME`                   |
| `Auth:BasicPassword`              | `CAMUNDA_BASIC_AUTH_PASSWORD`                   |
| `OAuth:Url`                       | `CAMUNDA_OAUTH_URL`                             |
| `OAuth:ClientId`                  | `CAMUNDA_CLIENT_ID`                             |
| `OAuth:ClientSecret`              | `CAMUNDA_CLIENT_SECRET`                         |
| `OAuth:GrantType`                 | `CAMUNDA_OAUTH_GRANT_TYPE`                      |
| `OAuth:Scope`                     | `CAMUNDA_OAUTH_SCOPE`                           |
| `OAuth:TimeoutMs`                 | `CAMUNDA_OAUTH_TIMEOUT_MS`                      |
| `OAuth:RetryMax`                  | `CAMUNDA_OAUTH_RETRY_MAX`                       |
| `OAuth:RetryBaseDelayMs`          | `CAMUNDA_OAUTH_RETRY_BASE_DELAY_MS`             |
| `HttpRetry:MaxAttempts`           | `CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS`           |
| `HttpRetry:BaseDelayMs`           | `CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS`          |
| `HttpRetry:MaxDelayMs`            | `CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS`           |
| `Backpressure:Profile`            | `CAMUNDA_SDK_BACKPRESSURE_PROFILE`              |
| `Backpressure:InitialMax`         | `CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX`          |
| `Backpressure:SoftFactor`         | `CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR`          |
| `Backpressure:SevereFactor`       | `CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR`        |
| `Backpressure:RecoveryIntervalMs` | `CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS` |
| `Backpressure:RecoveryStep`       | `CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP`        |
| `Backpressure:DecayQuietMs`       | `CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS`       |
| `Backpressure:Floor`              | `CAMUNDA_SDK_BACKPRESSURE_FLOOR`                |
| `Backpressure:SevereThreshold`    | `CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD`     |
| `Eventual:PollDefaultMs`          | `CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS`          |

</details>

## Dependency Injection (`AddCamundaClient`)

For ASP.NET Core and other DI-based applications, use the `AddCamundaClient()` extension method on `IServiceCollection`. The client is registered as a singleton and automatically picks up `ILoggerFactory` from the container.

**Zero-config** (environment variables only):

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+DIZeroConfig -->

```csharp
using Camunda.Orchestration.Sdk;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddCamundaClient();
```

**With `appsettings.json`**:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+DIAppSettings -->

```csharp
using Camunda.Orchestration.Sdk;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddCamundaClient(builder.Configuration.GetSection("Camunda"));
```

**With options callback** (full control):

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+DIOptionsCallback -->

```csharp
using Camunda.Orchestration.Sdk;

builder.Services.AddCamundaClient(options =>
{
    options.Configuration = builder.Configuration.GetSection("Camunda");
    // or: options.Config = new Dictionary<string, string> { ... };
});
```

Inject the client anywhere via constructor injection:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: DIControllerInjection -->

```csharp
public class OrderController(CamundaClient camunda) : ControllerBase
{
    [HttpPost]
    public async Task<IActionResult> StartProcess()
    {
        var result = await camunda.CreateProcessInstanceAsync(
            new ProcessInstanceCreationInstructionById
            {
                ProcessDefinitionId = ProcessDefinitionId.AssumeExists("order-process"),
            });
        return Ok(result);
    }
}
```

## Custom HttpClient

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+CustomHttpClient -->

```csharp
using Camunda.Orchestration.Sdk;

var httpClient = new HttpClient { BaseAddress = new Uri("https://my-cluster/v2/") };
using var client = CamundaClient.Create(new CamundaOptions
{
    HttpClient = httpClient,
});
```

---

## Resilience


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

## HTTP Retry

Automatic retry with exponential backoff and jitter for transient failures (429, 503, 500, timeouts).

| Variable                               | Default | Description                        |
| -------------------------------------- | ------- | ---------------------------------- |
| `CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS`  | `3`     | Total attempts (initial + retries) |
| `CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS` | `100`   | Base backoff delay (ms)            |
| `CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS`  | `2000`  | Maximum backoff cap (ms)           |

## Global Backpressure (Adaptive Concurrency)

The client includes an adaptive backpressure manager that throttles the number of in-flight operations when the cluster signals resource exhaustion. It complements (not replaces) per-request HTTP retry.

### Signals Considered

An HTTP response is treated as a backpressure signal when it matches one of:

- `429` (Too Many Requests) — always
- `503` with `title === "RESOURCE_EXHAUSTED"`
- `500` whose RFC 9457 / 7807 `detail` text contains `RESOURCE_EXHAUSTED`

All other 5xx variants are treated as non-retryable (fail fast) and do **not** influence the adaptive gate.

### How It Works

1. Normal state starts with the concurrency cap from `CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX` (default 16).
2. On backpressure signals the manager reduces available permits using the soft factor (70% by default).
3. Repeated consecutive signals escalate severity to `severe`, applying a stronger reduction factor (50%).
4. Successful (non-backpressure) completions trigger passive recovery checks that gradually restore permits over time if the system stays quiet.
5. Quiet periods (no signals for a configurable decay interval) downgrade severity and reset the consecutive counter.

The policy is intentionally conservative: it only engages after genuine pressure signals and recovers gradually to avoid oscillation.

### Configuration

| Variable                                        | Default    | Description                                             |
| ----------------------------------------------- | ---------- | ------------------------------------------------------- |
| `CAMUNDA_SDK_BACKPRESSURE_PROFILE`              | `BALANCED` | Preset profile (see below)                              |
| `CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX`          | `16`       | Bootstrap concurrency cap                               |
| `CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR`          | `70`       | Percentage multiplier on soft backpressure (70 → 0.70×) |
| `CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR`        | `50`       | Percentage multiplier on severe backpressure            |
| `CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS` | `1000`     | Interval between passive recovery checks (ms)           |
| `CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP`        | `1`        | Permits regained per recovery interval                  |
| `CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS`       | `2000`     | Quiet period to downgrade severity (ms)                 |
| `CAMUNDA_SDK_BACKPRESSURE_FLOOR`                | `1`        | Minimum concurrency floor while degraded                |
| `CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD`     | `3`        | Consecutive signals required to enter severe state      |

### Profiles

Profiles supply coordinated defaults. Any explicitly set env var overrides the profile value.

| Profile        | initialMax | softFactor% | severeFactor% | recoveryMs | recoveryStep | quietDecayMs | floor | severeThreshold | Use case                     |
| -------------- | ---------- | ----------- | ------------- | ---------- | ------------ | ------------ | ----- | --------------- | ---------------------------- |
| `BALANCED`     | 16         | 70          | 50            | 1000       | 1            | 2000         | 1     | 3               | General workloads            |
| `CONSERVATIVE` | 12         | 60          | 40            | 1200       | 1            | 2500         | 1     | 2               | Tighter capacity constraints |
| `AGGRESSIVE`   | 24         | 80          | 60            | 800        | 2            | 1500         | 2     | 4               | High throughput scenarios    |
| `LEGACY`       | —          | —           | —             | —          | —            | —            | —     | —               | Observe-only (no gating)     |

Select via environment:

```bash
CAMUNDA_SDK_BACKPRESSURE_PROFILE=AGGRESSIVE
```

Override individual knobs on top of a profile:

```bash
CAMUNDA_SDK_BACKPRESSURE_PROFILE=AGGRESSIVE
CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX=32
```

The `LEGACY` profile disables adaptive gating entirely — signals are still tracked for observability but no concurrency limits are applied. Use this to opt out of backpressure management while retaining per-request retry.

### Inspecting State Programmatically

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: BackpressureState -->

```csharp
var state = client.GetBackpressureState();
// state.Severity: "healthy", "soft", or "severe"
// state.Consecutive: consecutive backpressure signals observed
// state.PermitsMax: current concurrency cap (null when LEGACY / not engaged)
```

## Eventual Consistency

Built-in polling for eventually consistent endpoints with configurable wait times and predicates.

---

## Self-signed TLS / mTLS


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

The SDK supports custom TLS certificates via environment variables. This is useful for:

- **Self-signed server certificates** — trust a CA that signed your server's certificate, without presenting a client identity.
- **Mutual TLS (mTLS)** — present a client certificate and key to prove the client's identity.
- **Both** — trust a custom CA _and_ present client credentials.

## Trusting a self-signed server certificate

Set only the CA certificate to trust the server's self-signed certificate:

```bash
# Path to PEM file:
CAMUNDA_MTLS_CA_PATH=/path/to/ca.pem

# Or inline PEM:
CAMUNDA_MTLS_CA="-----BEGIN CERTIFICATE-----\n..."
```

## Mutual TLS (client certificate)

To present a client certificate for mutual TLS, provide both the certificate and private key:

```bash
CAMUNDA_MTLS_CERT_PATH=/path/to/client.crt
CAMUNDA_MTLS_KEY_PATH=/path/to/client.key

# Optional — passphrase if the key is encrypted:
# CAMUNDA_MTLS_KEY_PASSPHRASE=secret
```

## Full mTLS with custom CA

Combine a custom CA with client credentials:

```bash
CAMUNDA_MTLS_CA_PATH=/path/to/ca.pem
CAMUNDA_MTLS_CERT_PATH=/path/to/client.crt
CAMUNDA_MTLS_KEY_PATH=/path/to/client.key
```

Inline PEM values (`CAMUNDA_MTLS_CERT`, `CAMUNDA_MTLS_KEY`, `CAMUNDA_MTLS_CA`) take precedence over their `_PATH` counterparts. TLS is applied to all outbound calls, including OAuth token requests.

No code changes are needed — the SDK picks up TLS configuration from environment variables automatically:

<!-- snippet-exempt: trivial env-var usage illustration -->

```csharp
using Camunda.Orchestration.Sdk;

var client = CamundaClient.Create(); // TLS configured from env vars
```

---

## Strongly-Typed Domain Keys


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

All domain identifiers (process definition keys, job keys, user task keys, etc.) are `readonly record struct` types rather than plain strings. This prevents accidentally mixing different key types at compile time — the same pattern as the JS SDK's branded types.

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+DomainKeys -->

```csharp
using Camunda.Orchestration.Sdk;

// Lift a raw value into the correct nominal type
var defKey = ProcessDefinitionKey.AssumeExists("2251799813686749");

// Type safety — compiler prevents mixing key types
var taskKey = UserTaskKey.AssumeExists("123456");
// await client.GetProcessDefinitionAsync(taskKey); // ← compile error

// Validation — constraints (pattern, length) checked at construction
ProcessDefinitionKey.IsValid("2251799813686749"); // true

// Values returned from API calls are already typed
var result = await client.GetProcessDefinitionAsync(defKey);
// result.ProcessDefinitionKey is ProcessDefinitionKey, not string

// Transparent JSON serialization — no special handling needed
```

Key types implement `ICamundaKey` (string-backed) or `ICamundaLongKey` (long-backed) and serialize as plain JSON values. Constraint validation (regex pattern, min/max length) is enforced in `AssumeExists()` and queryable via `IsValid()`.

---

## Support status


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

This is a technical preview of the C# client that will become fully supported in Camunda 8.10.0.

The Technical Preview gives you a stable foundation to build on now, with a clear path to full support. We don't anticipate major changes — and [your feedback](https://github.com/camunda/orchestration-cluster-api-csharp/issues) between now and 8.10 is what closes that gap.

---

## Typed Variables with DTOs


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

Camunda API operations use dynamic `variables` and `customHeaders` payloads. By default these are untyped (`object`), but you can opt in to compile-time type safety using your own DTOs.

## Sending Variables (Input)

Assign any DTO or dictionary to the `Variables` property — `System.Text.Json` serializes the runtime type automatically:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+SendingVariables+SendingVariablesBody -->

```csharp
using Camunda.Orchestration.Sdk;

// Define your application domain models
public record OrderInput(string OrderId, decimal Amount);

// Assign the DTO directly
await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
{
    ProcessDefinitionId = processDefinitionId,
    Variables = new OrderInput("ord-123", 99.99m),
});

// Dictionaries also work — no DTO required
await client.CompleteJobAsync(jobKey, new JobCompletionRequest
{
    Variables = new Dictionary<string, object> { ["processed"] = true },
});
```

## Receiving Variables (Output)

Use `DeserializeAs<T>()` to extract typed DTOs from API responses:

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+ReceivingVariables+ReceivingVariablesBody -->

```csharp
using Camunda.Orchestration.Sdk;

public record OrderResult(bool Processed, string InvoiceNumber);

// Deserialize variables from any API response
var result = await client.CreateProcessInstanceAsync(
    new ProcessInstanceCreationInstructionById
    {
        ProcessDefinitionId = processDefinitionId,
    });
var output = result.Variables.DeserializeAs<OrderResult>();
// output.Processed, output.InvoiceNumber — fully typed
```

`DeserializeAs<T>()` handles the common runtime shapes:

- `JsonElement` (standard API response) → deserialized via `System.Text.Json`
- Already the target type → returned as-is (zero-copy)
- `null` → returns `default(T)`

Custom `JsonSerializerOptions` can be passed for non-standard naming conventions.

## Searching Variables as a DTO

`SearchVariablesAsDtoAsync<T>()` queries a process instance for exactly the variables declared on your DTO, pages through all results, and collapses them into a typed `VariableMap<T>`. Variable names are derived from the same `JsonSerializerOptions` used to deserialize (camelCase by default, overridable with `[JsonPropertyName]`), so the query filter, the raw keys, and DTO binding always agree.

<!-- snippet-source: docs/examples/ReadmeExamples.cs | regions: UsingDirective+SearchVariablesAsDto+SearchVariablesAsDtoBody -->

```csharp
using Camunda.Orchestration.Sdk;

public record OrderVariables(string OrderId, decimal Amount, string? Notes);

// Query only the variables declared on the DTO, across all pages, and
// collapse them into a single typed object.
var map = await client.SearchVariablesAsDtoAsync<OrderVariables>(processInstanceKey);

// Inspect individual values without materializing the whole DTO
if (map.Contains("amount"))
{
    var amount = map.Get<decimal>("amount");
}

// Validate() enforces that every non-nullable DTO member is present,
// throwing VariableValidationException if any required variable is missing.
OrderVariables order = map.Validate();
// order.OrderId, order.Amount — fully typed; order.Notes is optional
```

Behavior notes:

- **Scope collision**: if the same variable name appears at more than one scope (e.g. a local and a parent scope), `SearchVariablesAsDtoAsync` throws `VariableScopeCollisionException` rather than guessing. Narrow the query with the optional `scopeKey` parameter.
- **`Validate()`** throws `VariableValidationException` listing every missing required member; nullable members (`string?`, `int?`) are optional.
- **`Get<TValue>(name)`** and **`Get(name)`** read individual values lazily and return `default`/`null` when absent.

---

## C# SDK (Technical Preview)


:::caution Technical Preview
The C# SDK is a **technical preview** available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.
:::

<!-- WARNING: The content and specific structure of this file drives Docusaurus generation in camunda-docs. Also, code examples are injected during build. Please refer to MAINTAINER.md before editing. -->

Technical preview of the C# client SDK for the [Camunda 8 Orchestration Cluster REST API](../apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).

Unified configuration, OAuth/Basic auth, automatic retry, backpressure management, strongly-typed domain keys, and opt-in typed variables.

---

## Introduction to task applications

Task applications are the interface between humans and Camunda processes to orchestrate human work. Learn key concepts of the architecture of task applications before you build your own.

## What are task applications?

Task applications are end-user applications that allow humans to perform work orchestrated with a process. A [user task](/components/modeler/bpmn/user-tasks/user-tasks.md#user-task-forms) (for [human task orchestration](/guides/getting-started-orchestrate-human-tasks.md)) represents a single **work item** to be performed by an individual or a group. The jobs of a task application include:

- Listing available tasks and allowing users to select a task to work on.
- Providing filter and search options for users so they can more easily find the right next task to work on.
- Presenting the selected task and an interface for completing the task, usually via a form.
- Providing an interface to create new tasks, e.g. by starting a new process.
- Provide insight into the progress of work tasks, including processes and cases.
- Aggregate information so users and their managers can assess the impact on process goals, such as KPIs and SLAs.
- Ensure tasks are visible only to authorized users.

Task applications play a key role in the orchestration of business processes. They enable the orchestration of processes that still contain manual work without automating each process step in advance. This unlocks the potential for continuous improvement and for identifying opportunities for process optimization and automation.

:::tip
Not sure if you should use Camunda Tasklist, build your custom task application, or use a third-party application? Read the [guide to understand human task management](/components/best-practices/architecture/understanding-human-tasks-management.md#deciding-about-your-task-list-frontend) first.
:::

## Tasklist layout

Camunda 8 comes with a ready-to-use Tasklist UI that implements all key concepts of a task application. The Tasklist UI is a generic task application; your custom task application should probably be tailored to your specific use case and also include external data sources and tools.

The Tasklist UI is split into two main pages: the [tasks page](#task-page) and the [processes page](#processes-page).

### Task page

The task page lists all tasks pending for a user or user group, and allows users to pick and claim a task from that queue to work on. On the same page, the details of a selected task are displayed including the form that the user must submit in order to execute and complete the task. The task page is optimized for efficient workflows, where the most important tasks should be worked on first.

The task page is divided into two main areas:

- Left side showing the tasks queue.
- Right side showing the details of the selected task.

#### Tasks queue

The **tasks queue side panel** lists all tasks pending for a user or user group. It comes with filter and sort options that allow users to identify the right task to work on next. The tasks can be sorted by the creation date, due date, or follow-up date.

Learn more how to work with the task queue in the [Tasklist user guide](/components/tasklist/userguide/using-tasklist.md).

#### Task details

Task details are shown when a task is selected from the queue. A [form](/components/modeler/forms/utilizing-forms.md) is displayed as the task content, which must be filled out to complete the task.

:::tip
Typically, a task application utilizes forms to capture information from the user, to make a decision, to collect the results from a real-world task, or to provide task instructions to the user.

However, a [user task](/components/modeler/bpmn/user-tasks/user-tasks.md#user-task-forms) is not limited to forms. A user task could also represent navigating to an external desktop or web application, where a task is to be performed, such as updating a record in a CRM. You can even use them to track physical work or actions using sensors, IoT devices, or any interface that can talk to the web, by using the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).

For these cases, utilize the flexible [custom form key](/components/hub/workspace/modeler/modeling/advanced-modeling/form-linking.md#custom-form-key).
:::

On the top of the form, a header shows the title of the task to work on, and the current assignee. Depending on the status of the assignment, a button allows you to assign the task to yourself or release it to the queue.

At the bottom of the form there is a button with which you can complete the task.

To the right of the task, you find additional information about the task, such as the [due date](/components/modeler/bpmn/user-tasks/user-tasks.md#scheduling) of the task, or the authorization data that controls who can work on the task.

Potential extensions are dependent on your use case. You can consider adding more buttons to the bottom of the panel to indicate different task outcomes such as "approve" or "reject", or you could add a list of attachments to the right panel.

Learn more how to work with the task details panel in the [Tasklist user guide](/components/tasklist/userguide/using-tasklist.md).

### Processes page

The **Processes** page lists all processes available to the logged in user, and allows the user to start a process from there.

Potential extensions are dependent on your use case. You can consider grouping processes by apps, domains, or teams, showing a process history, or adding a list of open process instances or cases.

Learn more about the **Processes** page in the [Tasklist documentation](/components/tasklist/userguide/starting-processes.md).

:::tip Alternative layouts
There are many alternative layouts that you can choose for creating your task application. Design the layout based on the use case. For longer running processes and tasks with a lot of hierarchy between the tasks and the associated data, for example, tabular views together with multi-part detail views are more suitable.
:::

## Task lifecycle

Every task follows a task life cycle. In the typical task life cycle, a task can, for example:

- Be **created**, but not yet assigned
- Be **assigned** and ready to work
- Be **open** or **started**
- Be **paused** and marked with a follow-up date
- Be **delegated** to another user
- Be **completed** or **canceled**

Before you create your task application, you should be clear about [which task lifecycle is suitable for your use case](./02-user-task-lifecycle.md).

```mermaid
flowchart
    subgraph Assignment
        Unassigned(Unassigned) -->|assign/claim| Assigned(fa:fa-user Assigned)
        Assigned -->|return| Unassigned
        Assigned -->|reassign| Assigned
    end

    subgraph Work state
        New(( )) -->|create| A(Open)
        A -->|start| B(In progress)
        B -->|complete| C(fa:fa-check Completed)
        B -->|pause| D(Paused)
        D -->|resume| B(In progress)
        B -->|return| A
        style New fill:black
        style C stroke-width:2px
    end
```

The lifecycle of human task orchestration is mostly a generic issue. There is no need to model common aspects into all your processes, as this often makes models unreadable. Use Camunda task management features or implement your requirements in a generic way.

Learn how to define and implement your task lifecycle on the [user task lifecycle](./02-user-task-lifecycle.md) page.

## Task assignment

Every task can be assigned to either a group of people, or a specific individual. An individual can **claim** a task, indicating that they are picking the task from the pool (to avoid multiple people working on the same task).

As a general rule, you should assign user tasks in your business process to groups of people instead of specific individuals. This avoids bottlenecks (such as high workloads on single individuals or employees being on sick leave) and can greatly improve your process performance.

In the [XML of a user task](/components/modeler/bpmn/user-tasks/user-tasks.md#xml-representations), this is represented as follows:

```xml
<bpmn:userTask id="task_review_loan">
  <bpmn:extensionElements>
    <zeebe:assignmentDefinition candidateGroups="Loan team" />
  </bpmn:extensionElements>
```

Then, require individual members of that group to explicitly claim tasks before working on them. This way, you avoid different people trying to work on the same task at the same time, which can cause a race condition.

## Additional elements and alternative use cases

Often, task applications support the collaborative work on tasks, generally done using **comments**. **Document management** is a common use case of task applications, allowing users to upload, manage, and review **attachments**. Task applications are also the right place to browse, reference, and manage **case management data**.

Task applications are not limited to web applications to be worked on desktops. Camunda has been used successfully for the the development of omnichannel customer-facing applications, such as **mobile banking apps**, often via a **backend-for-frontend** implementation.

## Next steps

You learned the basic concepts of a task application. Your possible next steps are:

- Learn how to [embed or customize Camunda Forms](/apis-tools/frontend-development/03-forms/01-introduction-to-forms.md) to render tailored forms that can be designed by business users.
- Learn how to utilize the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) to query and execute tasks in your task application, and to enrich it with process execution data.

<!--
TODO Section to be added once pages are available

* Run through a comprehensive guide on how to build your own task application.
* Run throuh a guide on how to integrate with low-code tools to design your task application.
-->

---

## User task lifecycle

The user task lifecycle in Camunda defines how users interact with tasks and perform work. Define it before implementing your application logic and user interface.

## Define your task lifecycle

Define your task lifecycle based on your use case, the users interacting with the task, and the data you want to track.

Use the following task lifecycle as a starting point.

## Task lifecycle example

[Tasklist](/components/tasklist/introduction-to-tasklist.md) implements a lifecycle optimized for tracking work on individual tasks using [forms](../03-forms/01-introduction-to-forms.md). It separates assignment from task state to support collaborative processes.

In a typical flow, users can:

- Get assigned to a task, or assign the task to themselves.
- Start working on the task.
- Complete the task when the work is done.
- Pause, resume, or return the task if they can't continue work, depending on how your task application handles interrupted work.

If your application supports interrupted work, make sure it explicitly persists any draft or intermediate data before users leave the form.

```mermaid
stateDiagram-v2
    direction LR
    [*] --> creating
    creating --> created

    created --> assigning
    assigning --> created

    created --> updating
    updating --> created

    created --> completing
    completing --> created
    completing --> completed

    creating --> canceling
    created --> canceling
    assigning --> canceling
    updating --> canceling
    completing --> canceling
    canceling --> canceled

    classDef listenerEvent fill:#fc5d0d,color:white,font-weight:bold
    class creating listenerEvent
    class assigning listenerEvent
    class updating listenerEvent
    class completing listenerEvent
    class canceling listenerEvent
```

The engine derives the task state using a CQRS pattern. [Zeebe](/components/zeebe/zeebe-overview.md), Camunda's process execution engine, manages a stream of events. There is no single status attribute on tasks. Instead, the task status is derived from these events.

User task listeners run in a blocking manner. The lifecycle transition pauses until all listeners complete.

Listeners can also deny certain transitions. During `completing`, a listener can reject the transition and return the task to its previous state.

:::tip
Optimize currently tracks assigned and unassigned time for user tasks. If you need more detailed reporting, such as work started, paused, resumed, or returned, model these as custom `action` values and process them in your own reporting or audit logic.
:::

### Task assignment

Assignment runs independently of the work state, so tasks can be reassigned while work is in progress. A task may be assigned but remain open for some time, indicating that the assigned user is not available to work on it immediately. The assignee can also change while work is in progress.

In the Tasklist user interface, a task can be claimed by the logged-in user, which assigns the task to that user. Managers can assign unassigned tasks to team members and reassign them as needed.

```mermaid
flowchart
    subgraph Assignment
        Unassigned(Unassigned) -->|assign/claim| Assigned(fa:fa-user Assigned)
        Assigned -->|return| Unassigned
        Assigned -->|reassign| Assigned
    end
```

The execution engine does not validate user authorization. Your application must enforce access control.

Tasklist allows only the assigned user or another authorized user to update and complete a task. You can implement different rules in your application, such as allowing a user to complete a task on behalf of another user.

In Camunda 8.9 and later, you can use [user task authorizations](../../../components/tasklist/user-task-authorization.md) to control who can read, update, assign, or complete user tasks.

The following best practices are implemented in Tasklist:

- `update` and `complete` operations can only be performed by the assigned user or an admin or manager.
- Users can only see tasks assigned to them and tasks assigned to their candidate groups.
- When a task is returned to the queue, the assignee is cleared so another user can pick it up.
- Only authorized users can reassign tasks.
- Users can return tasks, but they must provide a comment explaining why.
- Users can mark tasks with a follow-up date. Depending on the assignment, the task remains assigned to the user or becomes unassigned.

Define validation logic that matches your use case.

## Lifecycle events

Camunda emits lifecycle events that can be triggered by REST API operations. User task listeners react to them to execute custom logic. For details, see [user task listeners](/components/concepts/user-task-listeners.md).

Supported events:

- `creating`
- `assigning`
- `updating`
- `completing`
- `canceling`

Lifecycle events represent engine-level transitions. Supported API calls can include an `action` value to add application-specific meaning to the resulting user task listener event. For example, your application can use actions such as `start`, `pause`, or `resume` to represent application-level work progress.

### `creating`

The `creating` event is emitted when a task instance is created. If the `creating` event already contains an assignee, no additional `assigning` event is fired.

### `assigning`

The engine emits the `assigning` event when a task assignment changes. The resulting event can include an `action` value, such as `claim`, `assign`, `return`, or `unassign`.

### `updating`

The engine emits the `updating` event when task data changes, except assignment changes. This can include changes to variables, candidate users, candidate groups, or other supported task fields.

The update API can also include an `action` value. Use this value to add application-specific meaning to the resulting event, such as `start`, `pause`, or `resume`.

### `completing`

The engine emits the `completing` event when a task is being completed. It can contain a custom action to indicate the outcome, such as `approved` or `rejected`.

### `canceling`

The engine emits the `canceling` event when a user task is terminated by the process. This happens when the process instance is canceled or an interrupting catch event ends the user task.

## Implement the lifecycle

Use the Orchestration Cluster REST API to implement task lifecycle operations in your application.  
See the [full API reference](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).

### Perform lifecycle operations

You interact with user tasks through the following endpoints:

- Assign or unassign a task:
  - [`POST /user-tasks/:userTaskKey/assignment`](/apis-tools/orchestration-cluster-api-rest/specifications/assign-user-task.api.mdx)
  - [`DELETE /user-tasks/:userTaskKey/assignee`](/apis-tools/orchestration-cluster-api-rest/specifications/unassign-user-task.api.mdx)

- Update a task:
  - [`PATCH /user-tasks/:userTaskKey`](/apis-tools/orchestration-cluster-api-rest/specifications/update-user-task.api.mdx)

- Complete a task:
  - [`POST /user-tasks/:userTaskKey/completion`](/apis-tools/orchestration-cluster-api-rest/specifications/complete-user-task.api.mdx)

These operations trigger lifecycle events such as `assigning`, `updating`, and `completing`.

### Assign a task

Use the assignment endpoint to assign, reassign, or unassign a task.

- `POST /user-tasks/:userTaskKey/assignment` assigns or reassigns a task.
- `DELETE /user-tasks/:userTaskKey/assignee` removes the current assignee.

Use the `action` attribute to describe the reason for the change, such as `claim`, `assign`, or `reassign`.

### Update a task

Use the update endpoint to modify task data or provide an application-specific `action` value.

You can:

- Update fields such as candidate users, candidate groups, due date, or follow-up date using a `changeset`.
- Add application-specific meaning to the resulting event by providing an `action` value, such as `start`, `pause`, or `resume`.

You can also send custom actions for audit or business logic purposes, such as `escalate`, `requestFurtherInformation`, `uploadDocument`, or `openExternalApp`.

Example request:

```json
{
  "changeset": {
    "dueDate": "2024-03-18T20:47:20.340Z"
  },
  "action": "escalate"
}
```

### Complete a task

Use `POST /user-tasks/:userTaskKey/completion` to complete a task. You can include an `action` to indicate the outcome, such as `approve` or `reject`.

## Reporting

Use lifecycle events to build audit logs or productivity reports.

### Task lifecycle reporting in Optimize

Optimize supports task productivity reports but currently measures only assigned vs. unassigned time.

It does not calculate:

- **Idle time:** Time a task was open (time to `start`).
- **Net working time:** Time during which a task was processed from a custom `start` action to completion, excluding time between custom `pause` and `resume` actions.

### Export task lifecycle information

Use user task listeners and job workers to send lifecycle event data to external systems such as analytics or monitoring tools.

---

## Task application architecture

A typical task application architecture consists of a task application frontend, a backend-for-frontend, and one or more data sources or services that contain business data relevant for the application users to perform their work. The backend implements Camunda Zeebe and Tasklist clients to retrieve and interact with tasks via Camunda APIs. For historical process instance data, Operate is also required.

Depending on the user task implementation type (job worker-based vs Camunda user task) you use in your processes, you need to run either the Tasklist or Zeebe client to run operations on tasks. Task, form, and variable retrieval happens via the API. Learn more about the differences of the task implementation types in the [migration guide for Camunda user tasks](/apis-tools/migration-manuals/migrate-to-camunda-user-tasks.md), and complete that migration before upgrading to 8.10 if you still use job worker-based user tasks.

:::tip
Starting a new project? Use Camunda user tasks to simplify your implementation.
:::

Click on any element of this diagram to jump to the documentation page for the respective component:

```mermaid
%%{init: {"flowchart": {"htmlLabels": true}} }%%
flowchart LR
    subgraph Architecture
        direction LR
        subgraph Custom Task Application
            direction LR
            Frontend --- BFF
            B --- ExtData
            subgraph BFF[ ]
                direction TB
                B[BFF \n <small>Backend for Frontend</small>]
                ExtData[Business Data]
            end
        end
        subgraph Camunda 8
            direction LR

            subgraph Tasklist
                Rest[Rest API]
                Forms
            end

            subgraph Zeebe
                ZeebeRest[Rest API]
            end

            Tasklist <-.-> Job[Job worker-based tasks]
            Tasklist <-.-> ZeebeTasks
            Rest <-.-> Forms
            Zeebe[Zeebe REST API] <-.-> ZeebeTasks[Zeebe-based tasks]
        end

        BFF -->|Query Tasks\n<small>Job-Based or Zeebe</small>| Tasklist

        BFF -->|Operation\n<small>Job-based</small>| Tasklist
        BFF -->|Operation\n<small>Zeebe</small>| Zeebe
    end

style Frontend fill:#2272c9,color:#fff
style B fill:#2272c9,color:#fff

style Rest fill:#10c95d,color:#fff
style ZeebeRest fill:#ed7d31,color:#fff
style Zeebe stroke:#ed7d31

style Job fill:#10c95d,color:#fff
style ZeebeTasks fill:#ed7d31,color:#fff

style subGraph1 fill:#e4eef8,stroke:#2272c9
style BFF fill:#c8dcf0,stroke:#2272c9
style ExtData fill:#a5caef,stroke:#2272c9

style Tasklist stroke:#10c95d,color:#000

click Forms "../../forms/introduction-to-forms"
click Rest "../../../tasklist-api-rest/tasklist-api-rest-overview"
click Job "../../../migration-manuals/migrate-to-camunda-user-tasks"
click ZeebeTasks "../../../migration-manuals/migrate-to-camunda-user-tasks"
click ZeebeRest "../../../zeebe-api-rest/zeebe-api-rest-overview"
```

Follow these resources to learn more about the individual components:

- Learn how to use the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/specifications/assign-user-task.api.mdx) for task, variable, and form retrieval, and to run operations on Camunda user tasks.
- If you still use older job worker-based user tasks, review [migrating to Camunda user tasks](/apis-tools/migration-manuals/migrate-to-camunda-user-tasks.md) and complete that migration before upgrading to 8.10, because this capability relied on the removed V1 Tasklist API.
- Understand how to design, embed, and customize [forms](/apis-tools/frontend-development/03-forms/01-introduction-to-forms.md).
- Understand how this architecture fits into the overall Camunda architecture with the [Java greenfield stack](/components/best-practices/architecture/deciding-about-your-stack.md).

---

## Introduction to forms

Forms play a key role in giving work instructions, collecting information and making decisions within human task orchestration. Forms are lightweight user interfaces, tailored for focused data input in specific steps of a process, rendering the orchestration of human tasks more efficient than simply routing users to the applications that are orchestrated.

Forms are commonly used in [user tasks](/components/modeler/bpmn/user-tasks/user-tasks.md#user-task-forms), but also as [start forms](/components/tasklist/userguide/starting-processes.md) to start a new process instance.

## Camunda Forms

In Camunda 8, you can design forms using a drag'n'drop editor. The form editor is available in both Desktop and Web Modeler. Learn more about Camunda Forms and available components in the [Camunda Forms reference documentation](/components/modeler/forms/camunda-forms-reference.md), and learn how to design a human workflow with forms in the [getting started guide](/guides/getting-started-orchestrate-human-tasks.md).

## form-js

Camunda Forms present a flexible, open solution to form creation. Camunda Forms are based on the [form-js library](https://github.com/bpmn-io/form-js) <GHIcon />, maintained by Camunda. As a result, the form editor and renderer are non-proprietary, open-source technology, and can be used everywhere, also outside the context of Camunda 8. This unlocks a world of use cases, and eliminates any doubt around vendor lock-in or technical barriers.

Form-js is a vanilla JavaScript library with [Preact](https://preactjs.com/) in the background, and can be used in any framework, from Angular to React.

The resulting forms are serialized as a JSON document. The JSON document conforms to an open form schema that allows you to render the form using both the built-in form render, or even with a custom render. The form schema is extensible, allowing you to build your own extensions or custom components.

<!-- TODO link to dedicated form.js page -->

:::tip Want to Contribute?
We welcome your contributions to form-js! Whether it's fixing a bug, adding a feature or a new component, your input is valuable. You can also provide your ideas by opening issues for us or the community.

**How to Contribute:**

1. 🌐 Visit our [GitHub Repository](https://github.com/bpmn-io/form-js).
2. 🛠️ Check out the issues or open a new one.
3. 💻 Fork the repository and submit a pull request.

Let's make form-js better together! 👩‍💻👨‍💻
:::

Continue reading to learn how to setup, embed, and extend form-js to build form-based task applications for any use case.

<!-- TODO cards -->

---

## Concepts

Use form-js, the open-source library that powers Camunda Forms, to embed forms anywhere from vanilla JavaScript to low-code application platforms. With form-js, you can view, visually edit, and simulate forms that are based on pure JSON.

## form-js basics

The form-js project is made of three core libraries: the [form editor](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-editor) <GHIcon />, the [form viewer](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer) <GHIcon />, and the [form playground](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-playground) <GHIcon />.

### Form editor

The [form editor](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-editor) <GHIcon /> allows to design forms with a drag'n'drop interface, and uses [FEEL expressions](/components/modeler/feel/what-is-feel.md) to execute form logic, such as visibility conditions, in realtime. Learn more about using the form editor in the [getting started guide](/components/modeler/forms/utilizing-forms.md).

The form editor as it is shipped in Camunda 8 actually uses the [form playground](#form-playground), which provides realtime preview and validation functionality.

### Form viewer

The [form viewer](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer) <GHIcon /> renders a form built using the form editor. It is versatile and can be embedded in any JavaScript application to render a form and capture user interactions. Learn more about embedding the form viewer on the following pages.

See the following example form using the form viewer, and interact with it:

<FormViewer schema={ policyReviewForm } />

### Form playground

The [form playground](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-playground) <GHIcon /> is a tool to preview forms, simulate their behavior, and explore form-js in a playful manner. It combines the [editor](#form-editor) and the [viewer](#form-viewer) with mock data input and output panels to test a form and form editor features instantly.

There is also a [Camunda-flavored version of the form playground](https://github.com/camunda/form-playground) <GHIcon />, which closely resembles the form editor experience in Camunda Web and Desktop Modeler, and supports rapid development.

The form playground mainly comprises the following areas:

- The **component palette** to search and add components.
- The **editor canvas**, allowing to compose a form by dragging components.
- The **preview pane**, which shows an interactive preview of the form. The preview updates in real-time when a change happens in the editor, properties panel, or mock input data.
- The **properties panel**, which is used to configure the properties of a component.
- The **data input panel**, which allows to simulate the form preview using mock input data.
- The **output panel**, which calculates and shows the current form output in real-time, based on the interactions with the preview.

The input and output panel, together with the preview, come in handy to simulate the behavior of a form, and to validate or debug the configuration of one or multiple components, especially when using expressions extensively. Use the input data panel to simulate process variables, business objects, or static data used in your form.

   
      Try form playground
   

Try the form playground yourself directly on the web, no log in needed.

## The form schema

A form is serialized as plain JSON with a simple, flat structure to maximize flexibility and versatility. In the root, a form contains some metadata attributes. The main form is defined by a list of components, where the components carry their layout properties themselves (e.g. which row a component belongs to). This is in contrast to markup languages such as HTML, where the arrangement of the nodes determines the layout. This enables backward compatibility and compatibility with user-defined renderers.

See this simple form schema for example, and the resulting form:

```json
{
  "components": [
    {
      "label": "First name",
      "type": "textfield",
      "layout": {
        "row": "Row_0hqc9xn",
        "columns": null
      },
      "id": "Field_05l2s7c",
      "key": "firstName"
    },
    {
      "label": "Last name",
      "type": "textfield",
      "layout": {
        "row": "Row_0hqc9xn",
        "columns": null
      },
      "id": "Field_0nw7e1c",
      "key": "lastName"
    },
    {
      "label": "Income",
      "type": "number",
      "layout": {
        "row": "Row_1ggwq2d",
        "columns": 8
      },
      "id": "Field_12yshuy",
      "key": "monthlyNetIncome",
      "description": "Monthly net income",
      "appearance": {
        "prefixAdorner": "USD"
      },
      "increment": "100",
      "validate": {
        "required": true,
        "min": 0
      }
    }
  ],
  "type": "default",
  "id": "ExampleForm",
  "executionPlatform": "Camunda Cloud",
  "executionPlatformVersion": "8.4.0",
  "exporter": {
    "name": "Camunda Modeler",
    "version": "5.18.0"
  },
  "schemaVersion": 12
}
```

<FormViewer schema={ simpleForm } />

All form-js packages share the same [JSON schema](https://github.com/bpmn-io/form-js/tree/develop/packages/form-json-schema) <GHIcon /> for forms.

This enables the interoperability of the created forms between the form editor and the viewer and possibly also between custom-made form renderers, or translating from a Camunda Form to another form. Using the form schema, you can write extensions to existing components, while still receiving benefits from updates made to the core form-js libraries.

The schema abstracts the form model from the viewer, and allows you to inject another expression or templating language as an alternative to FEEL, since expressions are simply stored as strings.

The schema is built on top of and validated by [`json-schema@draft-07`](https://json-schema.org/draft-07/json-schema-release-notes.html).

:::tip
You can use tools like this [JSON Schema Viewer](https://navneethg.github.io/jsonschemaviewer/) to explore the schema visually, or this [tool from Atlassian](https://json-schema.app/view/%23?url=https%3A%2F%2Funpkg.com%2F%40bpmn-io%2Fform-json-schema%401.6.0%2Fresources%2Fschema.json) to validate a form against the schema.
:::

### Schema variables

Form-js comes with versatile methods to extract the expected input and output variables from a form schema. This makes it easy to validate the input and output of a form, and you can combine it with data validation libraries like [joi](https://github.com/hapijs/joi) <GHIcon /> to ensure type and schema safety. Learn more about schema variables in the [embedding guide](./02-embed-in-javascript.md).

## Examples

Visit the [form-js examples repository](https://github.com/bpmn-io/form-js-examples) <GHIcon /> to explore form-js by playing with the toolkit.

---

## Embed forms in JavaScript

Learn how to embed the form viewer in your own applications and web pages using JavaScript.

## Set up form-js

Set up the [form viewer](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer) <GHIcon /> in your own JavaScript projects by importing the library from NPM or a CDN. Alternatively, you can fork the code and [build it yourself](https://github.com/bpmn-io/form-js?tab=readme-ov-file#build-and-run) <GHIcon />.

### NPM

If you use [NPM](https://docs.npmjs.com/getting-started/what-is-npm), install the form viewer as follows:

```sh
npm install @bpmn-io/form-js-viewer
```

### CDN

You can import the form viewer from a content delivery network (CDN), for example when you want to use the form viewer directly in a browser environment without bundling it with your application. Form-js is served via unpkg. Specify the version you want to reference in the URL.

```js
<script src="https://unpkg.com/@bpmn-io/form-js@<VERSION>/dist/form-viewer.umd.js"></script>
```

If you want to automatically use the latest version of the form viewer, you can specify only the major version.

```js
<script src="https://unpkg.com/@bpmn-io/form-js@1/dist/form-viewer.umd.js"></script>
```

Make sure to import the stylesheets as well, and ensure that the version matches:

```js
<link rel="stylesheet" href="https://unpkg.com/@bpmn-io/form-js@1/dist/assets/form-js.css">
```

## Embed into your application

Embedding a form with the form viewer requires only a few steps.

1. Import the library
2. Specify the render target div and render the form
3. Import the [form schema](./01-concepts.md#the-form-schema)

```js

const form = new Form({
  container: document.querySelector("#form"),
});

// schema of the form to embed
const schema = {
  type: "default",
  id: "TestForm",
  components: [
    {
      key: "name",
      label: "Name",
      type: "textfield",
      validate: {
        required: true,
      },
    },
  ],
};

await form.importSchema(schema);
```

This results in:

<FormViewer schema={ {
"type": "default",
"id": "TestForm",
"components": [
{
"key": "name",
"label": "Name",
"type": "textfield",
"validate": {
"required": true
}
}
]
} } />

You can also detach a form from a container and attach to another during form runtime. Learn more about that in the [API documentation](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#formattachtoparentnode-htmlelement--void) <GHIcon />.

### Input form context data

To provide data to your form, such as process variables or business objects, pass a JSON object containing this data to the `importSchema` function.

```js
...

const schema = {
  ...
};

// form context/input data
const data = {
  name: 'ACME Corp'
};

await form.importSchema(schema, data);
```

This results in:

<FormViewer schema={ {
"type": "default",
"id": "TestForm",
"components": [
{
"key": "name",
"label": "Name",
"type": "textfield",
"validate": {
"required": true
}
}
]
} } data={ {
"name": "ACME Corp"
} } />

You can use context data not just to populate field values, but also to control form behavior, to provide options for select fields, or even to provide localization to your forms. You can fetch business data via an API first, and inject it via the data object. The following example demonstrates how to provide select options via context data, by using a `valuesExpression`.

```js
...

const schema = {
  components: [
    {
      label: "Business domain",
      type: "select",
      key: "domain",
      valuesExpression: "=businessDomains"
    }
  ],
  type: "default",
  id: "TestForm",
  schemaVersion: 12
};

// form context/input data
const data = {
  businessDomains: ["Software development", "Consulting"]
};

await form.importSchema(schema, data);
```

This results in:

<FormViewer schema={ {
"components": [
{
"label": "Business domain",
"type": "select",
"key": "domain",
"valuesExpression": "=businessDomains"
}
],
"type": "default",
"id": "TestForm",
"schemaVersion": 12
} } data={ {
"businessDomains": ["Software development", "Consulting"]
} } />

### Validate a form

Before you allow a user to submit a form, you can use the `validate` function to ensure that all validation rules of your form are met and that all required fields are completed. Learn more in the [form API documentation](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#formvalidate--errors) <GHIcon />.

```js
const errors = form.validate();

if (Object.keys(errors).length) {
  console.error("Form has errors", errors);
}
```

### Trigger and listen to form events

Form-js provides a comprehensive set of events and APIs to react on form state changes. You can listen for

- [form state changes](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#changed---data-errors-) <GHIcon />,
- [form submissions](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#submit---data-errors-) <GHIcon />,
- [form layout changes](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#layouting-events) <GHIcon />.

In addition, hook into [lifecycle events](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#lifecycle-events) <GHIcon /> to add custom logic (e.g. initialize listeners on form fields after the form loaded).

Learn more about the full API in the [GitHub repository documentation](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#api) <GHIcon />.

### Retrieve form output data

To retrieve the current form output data on any form state change, listen to the [`changed`](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#changed---data-errors--) <GHIcon /> event.

To retrieve the data on submit, listen to the [`submit`](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer#formsubmit---data-data-errors-errors-) <GHIcon /> event.

### Retrieve schema variables

Use the `getSchemaVariables` util to retrieve the [variables defined in a form schema](./01-concepts.md#schema-variables). This is useful to gather what data is consumed and produced by a form.

```javascript

const variables = getSchemaVariables(schema);

console.log("Schema variables", variables);
```

It is also possible to distinct between input and output variables:

```javascript

const outputVariables = getSchemaVariables(schema, { inputs: false });
const inputVariables = getSchemaVariables(schema, { outputs: false });
```

:::note
form-js does not enforce typing. Retrieving schema variables returns the variable names, but not the type or whether the variable is optional (i.e. whether the field is required or not). To retrieve the expected type of the variable, parse the form schema manually. To enforce the typing of input variables, use validation libraries such as [joi](https://github.com/hapijs/joi) <GHIcon />.
:::

### Next steps

- [Style forms](../03-customize-and-extend/01-styling.md) using CSS and custom renderers.
- [Integrate external data via APIs](../03-customize-and-extend/03-integrate-api-data.md) into your forms and task applications.
- Create [custom form components](../03-customize-and-extend/02-custom-components.md) to design flexible forms tailored to your individual use case.

<!--
- Using React instead of vanilla JavaScript? Learn how to embed forms in a React environment.
-->

---

## Styling

Forms can be easily styled by combining defining own CSS rules and overriding a set of CSS variables. If you want to go beyond CSS, you can fork the [form viewer](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer) <GHIcon /> and change the HTML returned by the individual form component renderers.

## Styling via CSS

### CSS variables

The variables are defined at the root of the form-js container:

```css
.fjs-container {
  /**
   * Color settings. Specify color variables in the following schema:
   * 1 - use specified layer
   * 2 - use layer one
   * 3 - use fallback 
   */
  --color-background: var(--cds-field, var(--cds-field-01, var(--color-white)));
  --color-background-disabled: var(
    --cds-background,
    var(--color-grey-225-10-95)
  );
  --color-background-readonly: var(
    --cds-background,
    var(--color-grey-225-10-95)
  );
  --color-background-adornment: var(
    --cds-field,
    var(--cds-field-01, var(--color-grey-225-10-95))
  );
  --color-background-inverted: var(
    --cds-background-inverse,
    var(--color-grey-225-10-90)
  );
  --color-background-inverted-hover: var(
    --cds-background-inverse-hover,
    var(--color-grey-225-10-93)
  );
  --color-background-active: var(
    --cds-background-active,
    var(--color-grey-225-10-75)
  );
  --color-layer: var(--cds-layer, var(--cds-layer-01, var(--color-white)));
  --color-layer-accent: var(--cds-layer-accent, var(--color-grey-0-0-88));
  --color-icon-base: var(--cds-icon-primary, var(--color-black));
  --color-icon-inverted: var(--cds-icon-inverse, var(--color-black));
  --color-text: var(--cds-text-primary, var(--color-grey-225-10-15));
  --color-text-light: var(--cds-text-secondary, var(--color-grey-225-10-35));
  --color-text-lighter: var(--cds-text-secondary, var(--color-grey-225-10-45));
  --color-text-lightest: var(
    --cds-text-placeholder,
    var(--color-grey-225-10-55)
  );
  --color-text-inverted: var(--cds-text-inverse, var(--color-text));
  --color-text-disabled: var(--cds-text-disabled, var(--color-text-light));
  --color-borders: var(
    --cds-border-strong,
    var(--cds-border-strong-01, var(--color-grey-225-10-55))
  );
  --color-borders-group: var(--cds-border-subtle, var(--color-grey-225-10-85));
  --color-borders-table: var(--color-borders-group);
  --color-borders-disabled: var(
    --cds-border-disabled,
    var(--color-grey-225-10-75)
  );
  --color-borders-adornment: var(
    --cds-border-subtle,
    var(--cds-border-subtle-01, var(--color-grey-225-10-85))
  );
  --color-borders-readonly: var(
    --cds-border-subtle,
    var(--color-grey-225-10-75)
  );
  --color-borders-inverted: var(
    --cds-border-inverse,
    var(--color-grey-225-10-90)
  );
  --color-warning: var(--cds-text-error, var(--color-red-360-100-45));
  --color-warning-light: var(--cds-text-error, var(--color-red-360-100-92));
  --color-accent: var(--cds-link-primary, var(--color-blue-205-100-40));
  --color-accent-readonly: var(
    --cds-border-strong,
    var(--cds-border-strong-01, var(--color-grey-225-10-55))
  );
  --color-datepicker-focused-day: var(
    --cds-button-primary,
    var(--color-grey-225-10-55)
  );
  --color-shadow: var(--cds-shadow, var(--color-grey-225-10-85));

  /* font + text settings */
  --font-family: "IBM Plex Sans", sans-serif;
  --font-size-group: 15px;
  --font-size-base: 14px;
  --font-size-input: 14px;
  --font-size-label: 12px;
  --line-height-base: 20px;
  --line-height-input: 18px;
  --line-height-label: 16px;
  --letter-spacing-base: 0.16px;
  --letter-spacing-input: 0.16px;
  --letter-spacing-label: 0.32px;

  /* field settings */
  --form-field-height: 36px;
  --border-definition: 1px solid var(--color-borders);
  --border-definition-adornment: 1px solid var(--color-borders-adornment);
  --outline-definition: 1px solid var(--cds-focus, var(--color-borders));
  --button-warning-outline-definition: 2px solid var(--color-warning);
  --border-definition-disabled: 1px solid var(--color-borders-disabled);
  --border-definition-readonly: 1px solid var(--color-borders-readonly);
}
```

### Styleable classes

The simplest way to find the right styleable elements to override is inspecting form-js using your browser's developer tools. Scope rules with the `.fjs-container` class to prevent CSS conflicts.

For example, to override field borders for single-line fields:

```css
.fjs-container .fjs-input-group {
  border-width: 0 0 1px 0;
}
```

### Example

Camunda 8 web applications are built using the IBM Carbon design system. Forms rendered in Tasklist appear in this design system by default. Visit the [Carbon form-js styles repository](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-carbon-styles) <GHIcon /> to learn how to create your own form styles.

Basic style
<FormViewer schema={ exampleForm } />

Custom style (Material-like)
<FormViewer customClass="materialized" schema={ exampleForm } />

## Styling via form viewer customization

The [form viewer](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer) <GHIcon /> contains all [basic form components](https://github.com/bpmn-io/form-js/tree/develop/packages/form-js-viewer/src/render/components/form-fields) <GHIcon /> shipped in Camunda Forms. For full flexibility, fork the library and change the returned HTML of the individual components, or override existing components via [custom form components](02-custom-components.md).

### Example

The following example demonstrates replacing the default rendering of the [text field component](https://github.com/bpmn-io/form-js/blob/develop/packages/form-js-viewer/src/render/components/form-fields/Textfield.js) <GHIcon /> with [Material UI](https://mui.com/material-ui/react-text-field/).

```js title="packages/form-js-viewer/src/render/components/form-fields/Textfield.js"

...

export default function Textfield(props) {
  const {
    ...
  } = props;

  ...

  const onInputBlur = () => {
    ...
  };

  return 
    // using MUI TextField instead of default
    <TextField
        id={ domId }
        label={ label }
        value={ value }
        defaultValue={ defaultValue }
        onChange={(event) => {
            ...
        }}
    />

    <Description description={ description } />
    <Errors errors={ errors } id={ errorMessageId } />
  ;

  ...
}
```

---

## Custom components

Form-js comes with an extension point to hook in custom components. You can define the renderer, the configuration options of the component in the properties panel, and the palette entry.

Custom components are built and distributed separately from the form viewer and renderer, and can be plugged in on demand by registering them as `additionalModules`.

```js

new Form({
  container,
  schema,
  data,
  additionalModules: [MyCustomComponent],
});
```

Read the [step-by-step guide](https://github.com/bpmn-io/form-js-examples/tree/master/custom-components) <GHIcon /> and inspect the example component to learn how to write your own custom components.

:::note
Custom components currently can not be imported into Camunda Web or Desktop Modeler. If you use custom components, you need to host the form editor yourself.
:::

<!-- TODO
Learn more in the build your own form editor guide.
-->

## Use cases for custom components

- **Integration with external APIs:** create components that integrate with external APIs to fetch real-time data or perform specific actions. For example, a location input component could connect to a mapping API to suggest locations as users type.
- **Tailored services architecture:** write your own backend (micro-)services coupled to your components, and let the components communicate with these services to fetch domain-specifc or internal data in a secure fashion.
- **File upload:** develop a component that allows users to upload a file, which is stored in a document storage system and returns the reference ID or URL of the document as the component/form output.
- **Data visualization:** build components that visualize data directly within the form. This could include charts, graphs, or other visual representations of information relevant to the form's purpose.
- **Geolocation services:** create components that leverage geolocation services to capture or display location-based information. This can be helpful for forms that require location-specific data.
- **Payment processing:** develop secure components that integrate with payment gateways to handle financial transactions within a form.

---

## Integrate API data

Read this page to learn how to integrate external business data into your forms via APIs.

## Load data on form initation

Before you initiate your form with data, make sure to fetch external business data and merge it with the process variables first. Data that is not bound to a form field using a key will not be submitted, keeping process instance data clean.

As an example, use a `valuesExpression` in your form to populate the options of a select field.

```js
//...

const schema = {
  components: [
    {
      label: "Opportunities",
      type: "select",
      key: "opportunity",
      valuesExpression: "=external.salesforce.opportunities",
    },
  ],
  type: "default",
  id: "TestForm",
  schemaVersion: 12,
};

const response = await fetch(url, fetchOptions);
const opportunities = await response.json(); //...

// form context/input data
const data = {
  ...processVariables,
  external: {
    salesforce: {
      opportunities,
    },
    // ...
  },
};

await form.importSchema(schema, data);
```

## Load data on runtime with form events

:::info
Workaround

Currently, there is no built-in way to update a form's context data on runtime. However, a workaround exists.
:::

To load and update data on runtime (e.g. when searching in a searchable select box, or entering a query in a text field), follow these steps:

1. Listen to the `changed`, `formField.blur`, or `formField.search` event.
2. Gather the current form state from the `changed` event, or call the `submit` function to retrieve the data.
3. Find the query term in the changed state that is relevant for your API calls.
4. Run your API call, e.g. fetch records based on the query term.
5. Re-import the form schema but with the updated data (the current form state you obtained earlier, merged with the API results).

Don't forget to block the UI, e.g. using a loading spinner.

## Load data on runtime with a custom component

A convenient way to provide realtime data fetching capabilities to your form designers is to design a custom component. For example, you can create a searcheable select that allows users to search and select a record from a CRM system. With custom components, you can create any logic for data retrieval without limitations. You could consider writing your own backend (micro-)services coupled to your components, and let the components communicate with these services to fetch domain-specifc or internal data in a secure fashion.

Learn how to develop a custom component in the [custom component guide](./02-custom-components.md).

:::note
Custom components currently can not be imported into Camunda Web or Desktop Modeler. If you use custom components, you need to host the form editor yourself.
:::

<!-- TODO
Learn more in the build your own form editor guide.
-->

---

## Authentication(Hub-api-saas)

<PageDescription />

## The process

Generate a [JSON Web Token (JWT)](https://jwt.io/introduction/), and include it in every request. If you already have a client or token for Web Modeler API v1, you can reuse it for this API.

## Prerequisites

Before you begin, make sure you have the **Admin** user role.

## Create new client credentials

Create an API client with Web Modeler API permissions.

1. In Camunda Hub, under **Organization overview**, click **Admin APIs**.
2. From the **Administration API** management page, click **Create new credentials**.
3. Name the client, and grant it access to the **Web Modeler API** with the necessary permissions.
4. Click **Create**, and capture the following values required to generate a token:
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   | Name                     | Environment variable name        | Default value                                |
   | ------------------------ | -------------------------------- | -------------------------------------------- |
   | Client ID                | `CAMUNDA_CONSOLE_CLIENT_ID`      | -                                            |
   | Client Secret            | `CAMUNDA_CONSOLE_CLIENT_SECRET`  | -                                            |
   | Authorization Server URL | `CAMUNDA_OAUTH_URL`              | `https://login.cloud.camunda.io/oauth/token` |
   | Audience                 | `CAMUNDA_CONSOLE_OAUTH_AUDIENCE` | `api.cloud.camunda.io`                       |
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   :::caution
   When you create client credentials, the client secret is only shown once. Save the client secret somewhere safe.
   :::

## Generate a token

After [creating new client credentials](#create-a-new-application), generate an access token:

```bash
curl --request POST ${CAMUNDA_OAUTH_URL} \
   --header 'Content-Type: application/x-www-form-urlencoded' \
   --data-urlencode 'grant_type=client_credentials' \
   --data-urlencode "audience=${CAMUNDA_CONSOLE_OAUTH_AUDIENCE}" \
   --data-urlencode "client_id=${CAMUNDA_CONSOLE_CLIENT_ID}" \
   --data-urlencode "client_secret=${CAMUNDA_CONSOLE_CLIENT_SECRET}"
```

A successful response looks like this:

```json
{
  "access_token": "<TOKEN>",
  "expires_in": 300,
  "refresh_expires_in": 0,
  "token_type": "Bearer",
  "not-before-policy": 0
}
```

With this `access_token`, you're ready to [authenticate with the Camunda Hub API](#authenticate-with-your-token).

## Authenticate with your token

Once you have [generated a token](#generate-a-token), use it in the authorization header in every Camunda Hub API request: `Authorization: Bearer <TOKEN>`.

For example, send a request to the Camunda Hub API's `/info` endpoint:

```shell
curl --header "Authorization: Bearer ${TOKEN}" \
     https://hub.cloud.camunda.io/api/v2/info
```

## Organization-level access

API tokens are granted to organization-level _clients_ rather than individual _users_. With an API token, you can read, edit, and delete all workspaces and workspace resources in the organization, as long as the application has the required permissions for the Camunda Hub API. This is true even if you aren't a member of the workspace and you can't see it in the Camunda Hub user interface.

## Token expiration

Access tokens expire according to the `expires_in` property of an authenticated response. After this duration, in seconds, you must request a new access token.

---

## Camunda Hub API (SaaS)

<PageDescription />

:::note WORK IN PROGRESS
The Camunda Hub API is not yet exposed in Camunda 8 SaaS.
:::

## Authentication

See the [authentication guide](/apis-tools/hub-api-saas/authentication.md) for setup instructions.

## Migrating from Web Modeler API v1

Web Modeler API v1 is deprecated in Camunda 8.10 and will be removed in 8.12. [Migrate](/apis-tools/hub-api-saas/overview.md) to Camunda Hub REST API v2 before upgrading to 8.12.

---

## Authentication(Hub-api-sm)

<PageDescription />

## The process

Generate a [JSON Web Token (JWT)](https://jwt.io/introduction/), and include it in every request. If you already have a Web Modeler API v1 token, you can use the same token for this API.

## Create a new application

Create an application with Web Modeler API permissions.

1. [Add an M2M application in Management Identity](/self-managed/components/management-identity/application-user-group-role-management/applications.md#add-an-application).
2. [Grant this application access](/self-managed/components/management-identity/access-management/manage-permissions.md#assign-a-permission-to-an-application) to the **Web Modeler API** with the necessary permissions. This authorization also adds the required `web-modeler-public-api` audience to tokens issued for this application, so no `audience` parameter is needed in the token request.
3. Capture the `Client ID` and `Client Secret` from the application in Management Identity.

## Generate a token

After [creating a new application](#create-a-new-application), use its client ID and secret to [generate an access token](/self-managed/components/management-identity/authentication.md#generate-a-token):

```shell
curl --location --request POST 'http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data-urlencode "client_id=${CLIENT_ID}" \
  --data-urlencode "client_secret=${CLIENT_SECRET}" \
  --data-urlencode 'grant_type=client_credentials'
```

A successful authentication response looks like this:

```json
{
  "access_token": "<TOKEN>",
  "expires_in": 300,
  "refresh_expires_in": 0,
  "token_type": "Bearer",
  "not-before-policy": 0
}
```

With this `access_token`, you're ready to [authenticate with the Camunda Hub API](#authenticate-with-your-token).

## Authenticate with your token

Once you have [generated a token](#generate-a-token), use it in the authorization header in every Camunda Hub API request: `Authorization: Bearer <TOKEN>`.

For example, send a request to the Camunda Hub API's `/info` endpoint:

```shell
curl --header "Authorization: Bearer ${TOKEN}" \
     ${CAMUNDA_HUB_REST_URL}/api/v2/info
```

In this example, `${CAMUNDA_HUB_REST_URL}` represents the URL of the Camunda Hub API. You can configure this value in your Self-Managed installation. The default value is `http://localhost:8088`.

The Camunda Hub API validates both the token's audience and the application's permissions:

- A `401 Unauthorized` response means the token is missing the `web-modeler-public-api` audience. This audience is added when the application is authorized for the **Camunda Hub API** (see step 2), so confirm that authorization is in place.
- A `403 Forbidden` response means the application is missing the permissions required for the operation on the **Camunda Hub API** (for example, `create`, `update`, or `delete`).

## Organization-level access

API tokens are granted to organization-level _applications_ rather than individual _users_. With an API token, you can read, edit, and delete all workspaces and workspace resources in the organization, as long as the application has the required permissions for the Camunda Hub API. This is true even if you aren't a member of the workspace and you can't see it in the Camunda Hub user interface.

## Token expiration

Access tokens expire according to the `expires_in` property of an authenticated response. After this duration, in seconds, you must request a new access token.

---

## Camunda Hub API (Self-Managed)

<PageDescription />

:::note WORK IN PROGRESS
The Camunda Hub API is not yet exposed in Camunda 8 Self-Managed.
:::

## Authentication

See the [authentication guide](/apis-tools/hub-api-sm/authentication.md) for setup instructions.

## Migrating from Web Modeler API v1

Web Modeler API v1 is deprecated in Camunda 8.10 and will be removed in 8.12. [Migrate](/apis-tools/hub-api-sm/overview.md) to Camunda Hub REST API v2 before upgrading to 8.12.

---

## Java client

<PageDescription />

## About

The Camunda Java Client is the official Java library for building process applications that integrate with Camunda 8.

This client provides everything needed to interact with the Orchestration Cluster programmatically, such as orchestrating microservices, managing human tasks, or visualizing process data, and so on. For example, you can use it to build a job worker that handles polling for available jobs, use SLF4J for logging useful notes.

:::info Public API
The Camunda Java Client is part of the Camunda 8 [public API](/reference/public-api.md) and follows [Semantic Versioning](https://semver.org/) (except for alpha features). Minor and patch releases will not introduce breaking changes.
:::

## What is the Camunda Java Client?

The Camunda Java Client is a comprehensive library enabling Java developers to:

- **Deploy processes and decisions** to Camunda 8 clusters
- **Start and manage processes** programmatically
- **Implement job workers** to handle automated tasks within your processes
- **Query and manage process data** via the Orchestration Cluster API

It supports both REST and gRPC protocols, authentication setup, and provides robust error handling with retry mechanisms.

:::info Migration from Zeebe Java Client
**The Camunda Java Client replaces the Zeebe Java Client as of version 8.8.**

- Provides improved structure and full Orchestration Cluster API support
- Uses **REST** as default communication protocol (gRPC configurable)
- The Zeebe Java Client will be **removed in version 8.10**
- **Migrate before upgrading to 8.10** to avoid breaking changes

See our [migration guide](../migration-manuals/migrate-to-camunda-java-client.md) for details.
:::

## What can you build with it?

Use the Camunda Java Client to build:

- **Job workers** that perform automated tasks and call external systems (APIs, databases, file systems)
- **Integration services** that connect Camunda processes with existing systems or third-party services
- **Data processing applications** that leverage process data for visualization, analytics, or business intelligence

## Get started

### Step 1: Add the dependency

Add the Camunda Java Client to your project:

**Maven:**

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-client-java</artifactId>
  <version>${camunda.version}</version>
</dependency>
```

**Gradle:**

```groovy
implementation 'io.camunda:camunda-client-java:${camunda.version}'
```

Use the latest version from [Maven Central](https://search.maven.org/artifact/io.camunda/camunda-client-java).

### Step 2a: Connect to a Self-Managed Orchestration Cluster

Create a client instance to connect to your Self-Managed Camunda 8 cluster.  
Select the appropriate [authentication method](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md) for your environment:

<Tabs groupId="authentication" defaultValue="no-auth" queryString values={[
{label: 'No authentication', value: 'no-auth' },
{label: 'Basic authentication', value: 'basic-auth' },
{label: 'OIDC-based authentication (Self-Managed)', value: 'oidc-self-managed' },
{label: 'OIDC-based mutual TLS authentication', value: 'mTLS' },
]}>

<TabItem value="no-auth">

**Use for:** Local development when security is not required.

```java
private static final String CAMUNDA_GRPC_ADDRESS = "[Address of Zeebe API (gRPC) - default: http://localhost:26500]";
private static final String CAMUNDA_REST_ADDRESS = "[Address of the Orchestration Cluster API - default: http://localhost:8080]";

public static void main(String[] args) {

    try (CamundaClient client = CamundaClient.newClientBuilder()
            .grpcAddress(URI.create(CAMUNDA_GRPC_ADDRESS))
            .restAddress(URI.create(CAMUNDA_REST_ADDRESS))
            .build()) {

        // Test the connection
        client.newTopologyRequest().execute();
        System.out.println("Connected to Camunda 8!");
    }
}
```

**What this code does**

1. **Creates a no-authentication provider** – Configures the client to skip authentication.
2. **Builds a client using the protocol-specified transport** – Uses plaintext or TLS depending on whether the addresses use `http` or `https`.
3. **Connects to both APIs** – Configures access to the Zeebe gRPC and Orchestration Cluster REST APIs.
4. **Tests the connection** – Verifies connectivity by requesting cluster topology information.

**Environment variables option**  
You can also configure the client using environment variables:

```bash
export CAMUNDA_GRPC_ADDRESS='[Address of Zeebe API (gRPC) - default: http://localhost:26500]'
export CAMUNDA_REST_ADDRESS='[Address of the Orchestration Cluster API - default: http://localhost:8080]'
```

```java
CamundaClient client = CamundaClient.newClientBuilder().build();
```

The client will automatically read these environment variables and configure the appropriate authentication method.

Ensure addresses are in absolute URI format: `scheme://host(:port)`. The protocol (`http` or `https`) determines whether the connection is encrypted.

</TabItem>

<TabItem value="basic-auth">

**Use for:** Development or testing environments with username/password protection.

```java
private static final String CAMUNDA_GRPC_ADDRESS = "[Address of Zeebe API (gRPC) - default: http://localhost:26500]";
private static final String CAMUNDA_REST_ADDRESS = "[Address of the Orchestration Cluster API - default: http://localhost:8080]";
private static final String CAMUNDA_BASIC_AUTH_USERNAME = "[Your username - default: demo]";
private static final String CAMUNDA_BASIC_AUTH_PASSWORD = "[Your password - default: demo]";

public static void main(String[] args) {

    CredentialsProvider credentialsProvider = new BasicAuthCredentialsProviderBuilder()
            .username(CAMUNDA_BASIC_AUTH_USERNAME)
            .password(CAMUNDA_BASIC_AUTH_PASSWORD)
            .build();

    try (CamundaClient client = CamundaClient.newClientBuilder()
            .grpcAddress(URI.create(CAMUNDA_GRPC_ADDRESS))
            .restAddress(URI.create(CAMUNDA_REST_ADDRESS))
            .credentialsProvider(credentialsProvider)
            .build()) {

        // Test the connection
        client.newTopologyRequest().execute();
        System.out.println("Connected to Camunda 8!");
    }
}
```

**What this code does**

1. **Sets up username/password authentication** – Configures the client to use basic credentials.
2. **Builds a client using the protocol-specified transport** – Establishes an unencrypted connection if the addresses use `http` or an encrypted connection if they use `https`.
3. **Connects to both APIs** – Configures access to the Zeebe gRPC and Orchestration Cluster REST APIs.
4. **Tests the connection** – Verifies authentication by requesting cluster topology information.

**Environment variables option**  
You can also set connection details via environment variables to create the client more simply:

```bash
export CAMUNDA_GRPC_ADDRESS='[Address of Zeebe API (gRPC) - default: http://localhost:26500]'
export CAMUNDA_REST_ADDRESS='[Address of the Orchestration Cluster API - default: http://localhost:8080]'
export CAMUNDA_BASIC_AUTH_USERNAME='[Your username - default: demo]'
export CAMUNDA_BASIC_AUTH_PASSWORD='[Your password - default: demo]'
```

```java
CamundaClient client = CamundaClient.newClientBuilder().build();
```

The client will automatically read the environment variables and configure the appropriate authentication method.

:::note

- Ensure addresses use absolute URI format: `scheme://host(:port)`.
- By default, environment variables override any values provided in Java code. To give Java code values precedence, use the `.applyEnvironmentOverrides(false)` method on `BasicAuthCredentialsProviderBuilder`.
- The client adds an `Authorization` header to each request with the value `Basic username:password` (where `username:password` is base64 encoded).

:::

</TabItem>

<TabItem value="oidc-self-managed">

**Use for:** Self-Managed production environments with OIDC-based authentication. Standard `client_secret_basic` authentication method.

```java
private static final String CAMUNDA_GRPC_ADDRESS = "[Address of Zeebe API (gRPC) - default: http://localhost:26500]";
private static final String CAMUNDA_REST_ADDRESS = "[Address of the Orchestration Cluster API - default: http://localhost:8080]";
// There are three ways to define the authorization server URL
private static final String CAMUNDA_AUTHORIZATION_SERVER_URL = "[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token]";
private static final String CAMUNDA_WELL_KNOWN_CONFIGURATION_URL = "[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/.well-known/openid-configuration]";
private static final String CAMUNDA_ISSUER_URL = "[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform]";

// Audience is the API that will receive the token, such as the Orchestration Cluster for example
private static final String AUDIENCE = "[Orchestration Cluster audience]";

// Scope is the permission requested from the IdP (or leave empty)
private static final String SCOPE = "[optional additional scopes]";

private static final String CLIENT_ID = "[Client ID registered in your IdP]";
private static final String CLIENT_SECRET = "[Client Secret]";

public static void main(String[] args) {
    CredentialsProvider credentialsProvider = new OAuthCredentialsProviderBuilder()
            // Select the authorization server configuration option according to your properties from above
            .authorizationServerUrl(CAMUNDA_AUTHORIZATION_SERVER_URL)
            .issuerUrl(CAMUNDA_ISSUER_URL)
            .wellKnownConfigurationUrl(CAMUNDA_WELL_KNOWN_CONFIGURATION_URL)
            // End authorization server
            .audience(AUDIENCE)
            .scope(SCOPE)
            .clientId(CLIENT_ID)
            .clientSecret(CLIENT_SECRET)
            .build();

    try (CamundaClient client = CamundaClient.newClientBuilder()
            .grpcAddress(URI.create(CAMUNDA_GRPC_ADDRESS))
            .restAddress(URI.create(CAMUNDA_REST_ADDRESS))
            .credentialsProvider(credentialsProvider)
            .build()) {

        // Test the connection
        client.newTopologyRequest().execute();
        System.out.println("Connected to Camunda 8!");
    }
}
```

**Notes for Microsoft Entra ID**

- Use `scope=CLIENT_ID_OC + "/.default"` instead of `scope=CLIENT_ID_OC`.
- The issuer URL is typically in the format:

```
https://login.microsoftonline.com/<Microsoft Entra tenant ID>/v2.0
```

:::note Audience validation
If you have [configured the audiences property for the Orchestration Cluster (`camunda.security.authentication.oidc.audiences`)](/self-managed/components/orchestration-cluster/core-settings/configuration/properties.md#camunda.security.authentication.oidc), the Orchestration Cluster will validate the audience claim in the token against the configured audiences.

Make sure your token includes the correct audience from the Orchestration Cluster configuration, or add your audience to the configuration. Often this is the client ID you used when setting up the Orchestration Cluster.
:::

**What this code does**

1. **Sets up OAuth2 authentication** – Configures the client to use OAuth tokens from your identity provider.
2. **Builds a secure client** – Establishes an encrypted connection to your self-managed cluster (default).
3. **Connects to both APIs** – Configures access to the Zeebe gRPC and Orchestration Cluster REST APIs.
4. **Tests the connection** – Verifies OAuth authentication by requesting cluster topology information.

**Environment variables option**  
You can also set connection details via environment variables to create the client more simply:

```bash
export CAMUNDA_GRPC_ADDRESS='[Address of Zeebe API (gRPC) - default: http://localhost:26500]'
export CAMUNDA_REST_ADDRESS='[Address of the Orchestration Cluster API - default: http://localhost:8080]'
# There are three ways to define the authorization server URL
export CAMUNDA_AUTHORIZATION_SERVER_URL='[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token]'
export CAMUNDA_WELL_KNOWN_CONFIGURATION_URL='[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/.well-known/openid-configuration]'
export CAMUNDA_ISSUER_URL='[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform]'

export CAMUNDA_TOKEN_AUDIENCE='[Audience]'
export CAMUNDA_CLIENT_ID='[Client ID]'
export CAMUNDA_CLIENT_SECRET='[Client Secret]'
```

```java
CamundaClient client = CamundaClient.newClientBuilder().build();
```

The client will automatically read the environment variables and configure the appropriate authentication method.

:::note

- Ensure addresses use absolute URI format: `scheme://host(:port)`.
- By default, environment variables override any values provided in Java code. To give Java code values precedence, use the `.applyEnvironmentOverrides(false)` method on `OAuthCredentialsProviderBuilder`.
- The client adds an `Authorization` header to each request with the value `Bearer <token>`. The token is obtained from the authorization server, cached to avoid unnecessary requests, and refreshed lazily upon expiration.
- There are three ways to define the token URL. They're prioritized as follows:
  1. Provide the `camunda.client.auth.token-url`.
  2. Provide the issuer's well-known configuration URL `camunda.client.auth.well-known-configuration-url`. This extracts the token URL from the `token_url` field in the loaded configuration.
  3. Provide the issuer's URL `camunda.client.auth.issuer-url`. This generates the well-known configuration URL and extracts the token URL from the `token_url` field in the loaded configuration.

:::

</TabItem>
<TabItem value="mTLS">

**Use for:** Production environments with mTLS certificate-based client authentication.

Several identity providers, such as Keycloak, support client mTLS authentication as an alternative to `client_secret_basic`.

**Prerequisites**

- Properly configured KeyStore and TrustStore
- Both your application and identity provider share the same CA trust certificates
- Certificates for the identity provider are signed by a trusted CA
- The application DN is registered in the identity provider client authorization details

```java
private static final String CAMUNDA_GRPC_ADDRESS = "[Address of Zeebe API (gRPC) - default: http://localhost:26500]";
private static final String CAMUNDA_REST_ADDRESS = "[Address of the Orchestration Cluster API - default: http://localhost:8080]";
// There are three ways to define the authorization server URL
private static final String CAMUNDA_AUTHORIZATION_SERVER_URL = "[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token]";
private static final String CAMUNDA_WELL_KNOWN_CONFIGURATION_URL = "[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/.well-known/openid-configuration]",
private static final String CAMUNDA_ISSUER_URL = "[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform]";

private static final String AUDIENCE = "[Audience - default: zeebe-api]";
private static final String CLIENT_ID = "[Client ID]";
private static final Path KEYSTORE_PATH = Paths.get("/path/to/keystore.p12");
private static final String KEYSTORE_PASSWORD = "password";
private static final String KEYSTORE_KEY_PASSWORD = "password";
private static final Path TRUSTSTORE_PATH = Paths.get("/path/to/truststore.jks");
private static final String TRUSTSTORE_PASSWORD = "password";

public static void main(String[] args) {

    CredentialsProvider credentialsProvider = new OAuthCredentialsProviderBuilder()
            // Select the authorization server configuration option according to your properties from above
            .authorizationServerUrl(CAMUNDA_AUTHORIZATION_SERVER_URL)
            .issuerUrl(CAMUNDA_ISSUER_URL)
            .wellKnownConfigurationUrl(CAMUNDA_WELL_KNOWN_CONFIGURATION_URL)
            // End authorization server
            .audience(AUDIENCE)
            .clientId(CLIENT_ID)
            .keystorePath(KEYSTORE_PATH)
            .keystorePassword(KEYSTORE_PASSWORD)
            .keystoreKeyPassword(KEYSTORE_KEY_PASSWORD)
            .truststorePath(TRUSTSTORE_PATH)
            .truststorePassword(TRUSTSTORE_PASSWORD)
            .build();

    try (CamundaClient client = CamundaClient.newClientBuilder()
            .grpcAddress(URI.create(CAMUNDA_GRPC_ADDRESS))
            .restAddress(URI.create(CAMUNDA_REST_ADDRESS))
            .credentialsProvider(credentialsProvider)
            .build()) {

        // Test the connection
        client.newTopologyRequest().execute();
        System.out.println("Connected to Camunda 8!");
    }
}
```

**What this code does**

1. **Sets up mTLS certificate authentication** – Configures the client to authenticate using client certificates with OAuth.
2. **Builds a secure client** – Establishes an encrypted connection using mutual TLS authentication.
3. **Connects to both APIs** – Configures access to the Zeebe gRPC and Orchestration Cluster REST APIs.
4. **Tests the connection** – Verifies certificate authentication by requesting cluster topology information.

**Environment variables option**  
You can also set connection details via environment variables to create the client more simply:

```bash
export CAMUNDA_GRPC_ADDRESS='[Address of Zeebe API (gRPC) - default: http://localhost:26500]'
export CAMUNDA_REST_ADDRESS='[Address of the Orchestration Cluster API - default: http://localhost:8080]'
# There are three ways to define the authorization server URL
export CAMUNDA_AUTHORIZATION_SERVER_URL='[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token]'
export CAMUNDA_WELL_KNOWN_CONFIGURATION_URL='[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform/.well-known/openid-configuration]'
export CAMUNDA_ISSUER_URL='[OAuth URL e.g. http://localhost:18080/auth/realms/camunda-platform]'

export CAMUNDA_TOKEN_AUDIENCE='[Audience - default: zeebe-api]'
export CAMUNDA_CLIENT_ID='[Client ID]'
export CAMUNDA_CLIENT_SECRET='[Client Secret]'
export CAMUNDA_SSL_CLIENT_KEYSTORE_PATH='[Keystore path]'
export CAMUNDA_SSL_CLIENT_KEYSTORE_SECRET='[Keystore password]'
export CAMUNDA_SSL_CLIENT_KEYSTORE_KEY_SECRET='[Keystore material password]'
export CAMUNDA_SSL_CLIENT_TRUSTSTORE_PATH='[Truststore path]'
export CAMUNDA_SSL_CLIENT_TRUSTSTORE_SECRET='[Truststore password]'
```

```java
CamundaClient client = CamundaClient.newClientBuilder().build();
```

The client automatically reads environment variables and configures the appropriate authentication method.

Refer to your identity provider documentation for configuring mutual TLS authentication. For example, see [Keycloak](https://www.keycloak.org/server/mutual-tls).

:::note

- Ensure addresses use absolute URI format: `scheme://host(:port)`.
- By default, environment variables override any values provided in Java code. To give Java code values precedence, use the `.applyEnvironmentOverrides(false)` method on `OAuthCredentialsProviderBuilder`.
- The client adds an `Authorization` header to each request with the value `Bearer <token>`. The token is obtained from the authorization server, cached to avoid unnecessary requests, and refreshed lazily upon expiration.
- There are three ways to define the token URL. They're prioritized as follows:
  1. Provide the `camunda.client.auth.token-url`.
  2. Provide the issuer's well-known configuration URL `camunda.client.auth.well-known-configuration-url`. This extracts the token URL from the `token_url` field in the loaded configuration.
  3. Provide the issuer's URL `camunda.client.auth.issuer-url`. This generates the well-known configuration URL and extracts the token URL from the `token_url` field in the loaded configuration.

:::

</TabItem>

</Tabs>

### Step 2b: Configure the Orchestration Cluster connection for SaaS

**Use for:** Camunda 8 SaaS environments.
Get the values below from your [Camunda Console client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client).

```java
private static final String CAMUNDA_CLUSTER_ID = "[Cluster ID from Console]";
private static final String CAMUNDA_CLIENT_ID = "[Client ID from Console]";
private static final String CAMUNDA_CLIENT_SECRET = "[Client Secret from Console]";
private static final String CAMUNDA_CLUSTER_REGION = "[Cluster Region from Console]";

public static void main(String[] args) {

    try (CamundaClient client = CamundaClient.newCloudClientBuilder()
            .withClusterId(CAMUNDA_CLUSTER_ID)
            .withClientId(CAMUNDA_CLIENT_ID)
            .withClientSecret(CAMUNDA_CLIENT_SECRET)
            .withRegion(CAMUNDA_CLUSTER_REGION)
            .build()) {

        // Test the connection
        client.newTopologyRequest().execute();
        System.out.println("Connected to Camunda 8!");
    }
}
```

**What this code does**

1. **Sets up SaaS authentication** – Configures the client to connect to Camunda 8 SaaS using your cluster credentials.
2. **Builds a cloud client** – Creates a client optimized for SaaS with automatic endpoint discovery.
3. **Connects to your cluster** – Uses your cluster ID and region to locate and connect to the correct SaaS instance.
4. **Tests the connection** – Verifies SaaS authentication by requesting cluster topology information.

**Environment variables option**  
You can also set connection details via environment variables to create the client more simply:

```bash
export CAMUNDA_GRPC_ADDRESS='[Orchestration Cluster gRPC Address from Console]'
export CAMUNDA_REST_ADDRESS='[Orchestration Cluster REST Address from Console]'
export CAMUNDA_OAUTH_URL='[OAuth URL from Console]'
export CAMUNDA_TOKEN_AUDIENCE='[Audience from Console - default: zeebe.camunda.io]'
export CAMUNDA_CLIENT_ID='[Client ID from Console]'
export CAMUNDA_CLIENT_SECRET='[Client Secret from Console]'
```

```java
CamundaClient client = CamundaClient.newClientBuilder().build();
```

The client will automatically read the environment variables and configure the appropriate authentication method.

:::note
Ensure addresses are in absolute URI format: `scheme://host(:port)`.
:::

### Step 3: Start building your process application

With a connected client, you are ready to build your process application. Below are the core operations you’ll typically perform, along with guidance on the next steps.

#### Essential operations

**Deploy a process:**

```java
final DeploymentEvent deploymentEvent = client.newDeployResourceCommand()
    .addResourceFromClasspath("process.bpmn")
    .execute();
```

This deploys your BPMN process definition to the cluster. Place your `.bpmn` files in `src/main/resources` and reference them by filename.

**Start a process instance:**

```java
final ProcessInstanceEvent processInstanceEvent = client.newCreateInstanceCommand()
    .bpmnProcessId("my-process")
    .latestVersion()
    .variables(Map.of("orderId", "12345", "amount", 100.0))
    .execute();
```

This creates a new instance of your process. The `bpmnProcessId` should match the Process ID from your BPMN file, and you can pass initial variables as a Map.

For a comprehensive example demonstrating these steps, see the [DeployAndComplete example](https://github.com/camunda-community-hub/camunda-8-examples/blob/main/camunda-client-plain-java/src/main/java/io/camunda/example/e2e/process/DeployAndComplete.java) in the Camunda 8 examples repository. This example illustrates a complete workflow from process deployment to job completion.

## Key features and capabilities

- **Full Orchestration Cluster 8 API support:** Access all Orchestration Cluster API capabilities, including process deployment, management, job handling, and querying process data.
- **Multiple authentication methods:** Supports no authentication (development), basic authentication, and OIDC access tokens for production environments.
- **Automatic token management:** Handles authentication token acquisition and renewal automatically—no manual token management required.
- **Protocol flexibility:** Choose between REST and gRPC protocols depending on your requirements and infrastructure.

## Next steps and resources

**Learn the fundamentals**

- [Job worker implementation](job-worker.md) – Build workers to handle automated tasks
- [Process testing](../testing/getting-started.md) – Test your processes with Camunda Process Test
- [Getting Started Tutorial](../../guides/getting-started-example.md) – Complete walkthrough with Modeler, Operate, and Spring SDK

**Advanced topics**

- [Logging configuration](logging.md) – Set up proper logging for your application
- [Client documentation](https://javadoc.io/doc/io.camunda/camunda-client-java) – Complete Javadoc reference. Make sure you select the relevant Javadoc version as the latest version is shown by default at this URL.

**Need help?**

- [Camunda Community Forum](https://forum.camunda.io/) – Get help from the community
- [GitHub repository](https://github.com/camunda/camunda) – Report issues and contribute

---

## Job worker

**Job workers are the backbone of process automation in Camunda 8.** They handle automated tasks (service tasks) in your BPMN processes by continuously polling for available jobs and executing your business logic when jobs become available.

This guide covers everything you need to know about implementing and configuring job workers with the Camunda Java Client, from basic concepts to advanced features such as streaming, metrics, and multi-tenancy.

## Quick start

Before diving into the details, here is a simple example of creating a job worker:

```java
try (final JobWorker workerRegistration = client.newWorker()
        .jobType(jobType)
        .handler(new EmailJobHandler())
        .open()) {

    System.out.println("Job worker opened and receiving jobs of type: " + jobType);

    // Keep the worker running
    Thread.sleep(Duration.ofMinutes(10));
} catch (InterruptedException e) {
    throw new RuntimeException(e);
}

private static class EmailJobHandler implements JobHandler {
    @Override
    public void handle(final JobClient client, final ActivatedJob job) {
        // Perform your business logic here
        System.out.println("Processing job: " + job.getKey() + " for a process instance: " + job.getProcessInstanceKey());

        // Complete the job (or use client.newFailCommand() if something goes wrong)
        client.newCompleteCommand(job.getKey())
                .variables(Map.of("emailSent", true))
                .send()
                .join();
    }
}
```

For a complete walkthrough, see the [getting started guide](getting-started.md).

## What are job workers?

A job worker is a service that:

- **Polls for jobs** of a specific type from the Camunda cluster
- **Executes your business logic** when jobs are activated
- **Reports job completion or failure** back to the cluster
- **Handles retries and error scenarios** automatically

When you model a service task in your BPMN process and assign it a job type (e.g., `send-email`, `process-payment`), job workers subscribe to these job types and process them as they become available.

## Key benefits

- **Decoupled architecture**: Workers run independently from the process engine
- **Scalable processing**: Add more workers to handle increased load
- **Fault tolerance**: Built-in retry mechanisms and error handling
- **Language flexibility**: Implement workers in any language with a Camunda client

## Related resources

- [Job worker basics](/components/concepts/job-workers.md)

## How job workers work

The Java client provides a job worker that handles polling for available jobs. This allows you to focus on writing code to handle the activated jobs.

:::caution REST API limitation
The Java client cannot keep the long-lived polling connections required for job polling via the Orchestration Cluster REST API in the following cases:

- Performing long-polling job activation when activating jobs larger than the [maximum message size](../../self-managed/components/orchestration-cluster/zeebe/configuration/gateway.md#zeebegatewaynetwork).
- Issuing any additional job activation requests while a long-polling connection is open - whether from the same client instance, another client in the same JVM, or a client in a different JVM.

When the cases above occurs, the open long-polling request will be interrupted.
You may observe workers intermittently stop receiving jobs and cause reduced throughput due to wasted I/O and connection churn.
If you encounter this issue, consider using job activation via the Orchestration Cluster REST API with long polling disabled, or switching to the Zeebe gRPC protocol for job activation.

Additionally, the long-polling connection might still receive jobs after the Java client is closed.
As the Java client does not process these jobs they will time out.
This means some jobs are not processed and will become available again after their timeout has elapsed.
:::

On `open`, the job worker waits `pollInterval` milliseconds and then polls for `maxJobsActive` jobs. It then continues with the following schedule:

1. If a poll did not activate any jobs, it waits for `pollInterval` milliseconds and then polls for more jobs.
2. If a poll activated jobs, the worker submits each job to the job handler.
3. Every time a job is handled, the worker checks whether the number of unhandled jobs have dropped below 30% (rounded up) of `maxJobsActive`. The first time that happens, it will poll for more jobs.
4. If a poll fails with an error response, a backoff strategy is applied. This strategy waits for the delay provided by the `backoffSupplier` and polls for more jobs.

For example, imagine you have 10 process instances and a single job worker configured with `maxJobsActive = 3`. The job worker will first pull three jobs and begin executing them. The threshold to poll for new jobs is 1 (30% of 3 rounded up). After two jobs have completed, the threshold is reached and the job worker will poll for up to 2 additional jobs. This process repeats until the jobs from all 10 process instances are completed.

If streaming is enabled (via `streamEnabled`), it will also open a long-living stream over which jobs will be pushed without having to be polled. In such cases, a worker will only buffer up to `maxJobsActive` jobs at the same time. You can then estimate its memory usage as `maxJobsActive` times the max message size.

## Backoff configuration

When a poll fails with an error response, the job worker applies a backoff strategy. It waits for some time, after which it polls again for more jobs. This gives a Zeebe cluster some time to recover from a failure. In some cases, you may want to configure this backoff strategy to better fit your situation.

The retry delay (i.e. the time the job worker waits after an error before the next poll for new jobs) is provided by the [`BackoffSupplier`](https://github.com/camunda/camunda/blob/main/clients/java/src/main/java/io/camunda/client/api/worker/BackoffSupplier.java). You can replace it using the `.backoffSupplier()` method on the [`JobWorkerBuilder`](https://github.com/camunda/camunda/blob/main/clients/java/src/main/java/io/camunda/client/api/worker/JobWorkerBuilderStep1.java).

By default, the job worker uses an exponential backoff implementation, which you can configure using `BackoffSupplier.newBackoffBuilder()`.

The backoff strategy is especially useful for dealing with the `GRPC_STATUS_RESOURCE_EXHAUSTED` error response (refer to [gRPC Technical Error Handling](/apis-tools/zeebe-api/technical-error-handling.md)).

This error code indicates the Zeebe cluster is currently under too large of a load and has decided to reject this request.

By backing off, the job worker helps Zeebe by reducing the load.

:::note
Zeebe's [backpressure mechanism](../../../self-managed/components/orchestration-cluster/zeebe/operations/backpressure) can also be configured.
:::

## Metrics

The job worker exposes metrics through a custom interface: [JobWorkerMetrics](https://github.com/camunda/camunda/blob/main/clients/java/src/main/java/io/camunda/client/api/worker/JobWorkerMetrics.java). These represent specific callbacks used by the job worker to keep track of various internals, e.g. count of jobs activated, count of jobs handled, etc.

:::note
By default, job workers will not track any metrics, and it's up to the caller to specify an implementation if they wish to make use of this feature.
:::

### Available metrics

The API currently supports two metrics: the count of jobs activated, and the count of jobs handled.

- **The count of jobs activated** is incremented every time a worker activates new jobs. This is done by calling `JobWorkerMetrics#jobActivated(int)`, with the first argument being the count of jobs newly activated. The method is called before the job is passed to the job handler.
- **The count of jobs handled** is incremented every time a worker's `JobHandler` (passed to the builder via `JobWorkerBuilderStep2#handler(JobHandler)`) returns (regardless of whether it was successful). This is done by calling `JobWorkerMetrics#jobHandled(int)`, with the first argument being the count of jobs newly handled.

For both counters, the expectation is that implementations will simply increment an underlying counter, and track the rate or increase of this counter to derive the speed at which jobs are activated/handled by a given worker.

Additionally, by subtracting both counters, you can derive the count of queued or buffered jobs - jobs which have yet to be handled by the worker. This can help you tune your workers, e.g. scaling in or out, tuning the amount of jobs activated, etc.

### Usage

To use job worker metrics, create a new instance of a `JobWorkerMetrics` implementation, and pass it along to the builder:

```java
public final JobWorker openWorker(final CamundaClient client, final JobHandler handler) {
  final JobWorkerMetrics metrics = new MyCustomJobWorkerMetrics();
  return client.newJobWorker()
    .jobType("foo")
    .handler(handler)
    .metrics(metrics)
    .open();
}
```

#### Micrometer implementation

The Java client comes with an optional, built-in [Micrometer](https://micrometer.io/) implementation of `JobWorkerMetrics`.

:::note
[Micrometer](https://micrometer.io/) is a popular metrics facade in the Java ecosystem - what SLF4J is to logging. It can be configured to export metrics to many other systems, such as OpenTelemetry, Prometheus, StatsD, Datadog, etc.
:::

If your project does not yet use Micrometer, you need to add it to your dependencies, and wire it up to your metrics backend, [as described in the Micrometer docs](https://micrometer.io/docs).

Once Micrometer is set up in your project, you can start using the implementation. For example:

```java
public final JobWorker openWorker(final CamundaClient client, final JobHandler handler) {
  final MeterRegistry meterRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
  final JobWorkerMetrics metrics = JobWorkerMetrics
    .micrometer()
    .withMeterRegistry(meterRegistry)
    .withTags(Tags.of("zeebe.client.worker.jobType", "foo", "zeebe.client.worker.name", "bee"))
    .build();
  return client.newJobWorker()
    .jobType("foo")
    .handler(handler)
    .metrics(metrics)
    .name("bee")
    .open();
}
```

:::note
There are currently no built-in tags, primarily because these are likely to be high cardinality, which can become an issue with some metric registries. If you want per-worker tags, create a different `JobWorkerMetrics` instance per worker.
:::

This implementation creates four metrics:

| Metric name                         | Description                           | Notes                                                                     |
| ----------------------------------- | ------------------------------------- | ------------------------------------------------------------------------- |
| camunda.client.worker.job.activated | Counts the number of jobs activated   | New                                                                       |
| camunda.client.worker.job.handled   | Counts the number of jobs handled     | New                                                                       |
| zeebe.client.worker.job.activated   | Deprecated counter for jobs activated | Will be removed at 8.10. Use camunda.client.worker.job.activated instead. |
| zeebe.client.worker.job.handled     | Deprecated counter for jobs handled   | Will be removed at 8.10. Use camunda.client.worker.job.handled instead.   |

:::warning Deprecated metrics
The following metrics are deprecated and will be removed in version 8.10:

- `zeebe.client.worker.job.activated`, replace with `camunda.client.worker.job.activated`
- `zeebe.client.worker.job.handled`, replace with `camunda.client.worker.job.handled`

Please update your monitoring integrations to use the new metrics before upgrading to version 8.10.
:::

### Workarounds for additional metrics

The decision to track a small set of metrics directly in the client is a conscious one. The idea is we should only be tracking what is not possible for users to track themselves. If you believe a specific metric should be tracked by us, do open a feature request for it. In the meantime, here is a list of workarounds to help you track additional job worker-related metrics that you can already use:

#### Job polling count

You can use a gRPC [ClientInterceptor](https://grpc.github.io/grpc-java/javadoc/io/grpc/ClientInterceptor.html) or an Apache HttpClient [AsyncExecChainHandler](https://hc.apache.org/httpcomponents-client-5.3.x/current/httpclient5/apidocs/org/apache/hc/client5/http/async/AsyncExecChainHandler.html) to track any client calls, including the `ActivateJobsCommand` call that is sent every time a worker polls for more jobs.

Here's an example using Micrometer APIs that integrate a gRPC [ClientInterceptor](https://javadoc.io/doc/io.micrometer/micrometer-core/1.7.2/io/micrometer/core/instrument/binder/grpc/MetricCollectingServerInterceptor.html) and Apache HttpClient [AsyncExecChainHandler](https://javadoc.io/doc/io.micrometer/micrometer-core/1.12.0/io/micrometer/core/instrument/binder/httpcomponents/hc5/ObservationExecChainHandler.html):

```java

public CamundaClientBuilder configureClientMetrics(final CamundaClientBuilder builder, final MeterRegistry meterRegistry, final ObservationRegistry observationRegistry) {
    final ClientInterceptor monitoringInterceptor = new MetricCollectingClientInterceptor(meterRegistry);
    final AsyncExecChainHandler monitoringHandler = new ObservationExecChainHandler(observationRegistry);
    return builder.withInterceptors(monitoringInterceptor).withChainHandlers(monitoringHandler);
}
```

#### Executor metrics

If you wish to tune your job worker executor, you can pass a custom, instrumented executor to the client builder. For example, if we use Micrometer:

```java
public CamundaClientBuilder configureClientMetrics(
    final CamundaClientBuilder builder,
    final ScheduledExecutorService executor,
    final MeterRegistry meterRegistry) {
  final ScheduledExecutorService instrumentedExecutor = ExecutorServiceMetrics.monitor(meterRegistry, executor, "job-worker-executor");
  return builder.jobWorkerExecutor(instrumentedExecutor);
}
```

## Job streaming

Job workers are designed to regularly poll and activate jobs. It's also possible to use them in a streaming fashion, such that jobs are automatically activated and pushed downstream to workers without requiring an extra round of polling. This greatly cuts down on overall activation latency by completely removing the poll request.

### Usage

Enabling job streaming consists of toggling a single flag in the job worker builder:

```java
public JobWorkerBuilderStep3 enableStreaming(final JobWorkerBuilderStep3 builder) {
  return builder.streamEnabled(true);
}
```

This configures the job worker to open a long-living stream between itself and a gateway, through which activated jobs will be pushed. **If the stream is closed for any reason - e.g. the gateway crashed, there is a temporary network issue, etc. - it is automatically recreated.**

:::note
It's also possible to set an overall timeout - so called `streamTimeout` - which ensures the underlying long-living stream is refreshed once the timeout is reached. This is useful to trigger load balancing of your workers overtime, instead of having workers pinned to the same gateway.
:::

#### Backfilling

Even with streaming enabled, job workers still occasionally poll the cluster for jobs. Due to implementation constraints, when a job is made activate-able, it is pushed out only if there exists a stream for it; if not, it remains untouched. However, if a stream exists, then streaming is always prioritized over polling.

This ensures polling will not activate any new jobs, and the worker will back off and poll less often as long as it receives empty responses overtime.

#### Backpressure

To avoid your workers being overloaded with too many jobs, e.g. running out of memory, the Java job worker relies on the [built-in gRPC flow control mechanism](https://grpc.io/docs/guides/flow-control/). If streaming is enabled, this means the worker will never work on more jobs than the configured `maxJobsActive` parameter. For example, if `maxJobsActive = 32`, then your worker will only work on at most 32 jobs concurrently. If this is already the case, and a 33rd job comes in, the gRPC thread will block, thus signaling the gateway to stop sending more jobs.

**If streaming is enabled, back pressure applies to both pushing and polling**. You can then use `maxJobsActive` as a way to soft-bound the memory usage of your worker. For example, if your max message size is 4MB, and `maxJobsActive = 32`, then a single worker could use up to 128MB of memory in the worst case.

:::note
If the worker blocks longer than the job's deadline, the job will **not** be passed to the worker, but will be dropped. As it will time out on the broker side, it will be pushed again.
:::

#### Proxying

If you're using a reverse proxy or a load balancer between your worker and your gateway, you may need to configure additional parameters to ensure the job stream is not closed unexpectedly with an error. If you observe regular 504 timeouts, read our guide on [job streaming](../../../self-managed/components/orchestration-cluster/zeebe/zeebe-gateway/job-streaming).

By default, the Java job workers have a stream timeout of one hour. You can overwrite this by calling the `streamTimeout` of the job worker builder:

```java
final JobWorkerBuilderStep3 builder = ...;
builder.streamTimeout(Duration.ofMinutes(30));
```

## Multi-tenancy

You can configure a job worker to pick up jobs belonging to one or more tenants. The job worker builder provides two ways to control which tenants a worker retrieves jobs for: explicitly providing tenant IDs, or using the tenants assigned to the worker in the engine.

### Filtering by assigned tenants

Use `.tenantFilter()` to control how the worker resolves tenants. It accepts a `TenantFilter` enum with two options:

- `TenantFilter.PROVIDED` _(default)_: The worker retrieves jobs for the tenant IDs explicitly provided via `.tenantId()` or `.tenantIds()`. See [Filtering by provided tenant IDs](#filtering-by-provided-tenant-ids) below.
- `TenantFilter.ASSIGNED`: The worker retrieves jobs for the tenants assigned to it in the engine. When this option is set, any tenant IDs configured via `.tenantId()` or `.tenantIds()` are ignored.

Using `TenantFilter.ASSIGNED`:

```java
client.newWorker()
    .jobType("myJobType")
    .handler(new MyJobTypeHandler())
    .tenantFilter(TenantFilter.ASSIGNED)
    .open();
```

### Filtering by provided tenant IDs

When using `TenantFilter.PROVIDED` (the default), you must also specify the tenant IDs the worker should retrieve jobs for.

:::note
The client must be authorized for **all** the provided tenants. If it is not, the job worker will not work on any jobs.
:::

Opening a job worker for a single tenant:

```java
client.newWorker()
    .jobType("myJobType")
    .handler(new MyJobTypeHandler())
    .tenantId("myTenant")
    .open();
```

Opening a job worker for multiple tenants:

```java
client.newWorker()
    .jobType("myJobType")
    .handler(new MyJobTypeHandler())
    .tenantIds("myTenant", "myOtherTenant")
    .open();
```

### Default tenant

You can configure the default tenant(s) using environment variables or system properties. It's configured using
`CAMUNDA_DEFAULT_JOB_WORKER_TENANT_IDS` or `camunda.client.worker.tenantIds` respectively.

---

## Logging(Java-client)

The client uses SLF4J for logging useful notes, such as exception stack traces when a job handler fails execution. Using the SLF4J API, any SLF4J implementation can be plugged in. The following example uses Log4J 2:

## Maven dependencies

```xml
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j-impl</artifactId>
  <version>2.8.1</version>
</dependency>

<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.8.1</version>
</dependency>
```

## Configuration

First, add a file called `log4j2.xml` to the classpath of your application.

Then, add the following content:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" strict="true"
    xmlns="http://logging.apache.org/log4j/2.0/config"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://logging.apache.org/log4j/2.0/config https://raw.githubusercontent.com/apache/logging-log4j2/log4j-2.8.1/log4j-core/src/main/resources/Log4j-config.xsd">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %X Java Client: %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="info">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>
```

This will log every log message to the console.

## MDC context

Job workers include an MDC context that contains the following:

- `processDefinitionKey`
- `processInstanceKey`
- `elementInstanceKey`
- `jobKey`

See [the example above](#configuration), which includes `%X` in the pattern to print the entire MDC context.

---

## Migrate Component V1 APIs

<PageDescription />

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide is retained to help customers migrate before upgrading from 8.9 to 8.10. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

This document outlines the changes required to migrate from the component REST APIs before upgrading to Camunda 8.10, where the V1 component APIs are removed. Use it if migration to the new [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) was not yet possible during your 8.8 or 8.9 upgrade.

In this context, **components** refer to the standalone Camunda applications **Operate** and **Tasklist**, each exposing its own V1 REST API.

:::note
As of version 8.8, the V1 component APIs are deprecated. They are removed in 8.10, so complete this migration before upgrading. We strongly recommend [migrating to the Orchestration Cluster REST API](/apis-tools/migration-manuals/migrate-to-camunda-api.md) where possible.
:::

## Migrate V1 APIs

With Camunda 8.8, permissions for resource access have been reworked. For the V1 APIs, this means that access to endpoints now depends on specific read and write permissions for related resources.

To continue using the V1 APIs, users and clients must be assigned the appropriate permissions under [the new authorization model](/components/concepts/access-control/authorizations.md).

Users now require wildcard (`*`) permissions for the resource type and permission type being accessed.

:::info
For guidance on assigning permissions in Admin, see the [Admin authorization guide](../../components/admin/authorization.md).
:::

### Mapping Operate permissions to new authorizations

To maintain the same access level for the Operate V1 API, apply the following authorizations:

**`operate-api:read`** is replaced by:

- `PROCESS_DEFINITION:*:READ_PROCESS_DEFINITION,READ_PROCESSINSTANCE`
- `DECISION_DEFINITION:*:READ_DECISION_DEFINITION`
- `DECISION_REQUIREMENTS_DEFINITION:*:READ`

**`operate-api:write`** is replaced by:

- `PROCESS_DEFINITION:*:DELETE_PROCESS_INSTANCES`

### Operate V1 API permission matrix

To enable more fine-grained access control, the matrix below details the required permissions for each Operate V1 API endpoint.
Ensure the user has general access (resource ID `*`) for each listed resource and permission type.

| Endpoint                                        | Resource Type                    | Permission type          |
| ----------------------------------------------- | -------------------------------- | ------------------------ |
| `POST /v1/process-definitions/search`           | PROCESS_DEFINITION               | READ_PROCESS_DEFINITION  |
| `GET /v1/process-definitions/:key`              | PROCESS_DEFINITION               | READ_PROCESS_DEFINITION  |
| `GET v1/process-definitions/:key/xml`           | PROCESS_DEFINITION               | READ_PROCESS_DEFINITION  |
| `POST /v1/decision-definitions/search`          | DECISION_DEFINITION              | READ_DECISION_DEFINITION |
| `GET /v1/decision-definitions/:key`             | DECISION_DEFINITION              | READ_DECISION_DEFINITION |
| `POST /v1/decision-instances/search`            | DECISION_DEFINITION              | READ_DECISION_INSTANCE   |
| `GET /v1/decision-instances/:id`                | DECISION_DEFINITION              | READ_DECISION_INSTANCE   |
| `POST /v1/flownode-instances/search`            | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `GET /v1/flownode-instances/:key`               | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `POST /v1/variables/search`                     | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `GET /v1/variables/:key`                        | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `POST /v1/process-instances/search`             | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `GET /v1/process-instances/:key`                | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `GET /v1/process-instances/:key/statistics`     | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `GET /v1/process-instances/:key/sequence-flows` | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `DEL /v1/process-instances/:key`                | PROCESS_DEFINITION               | DELETE_PROCESS_INSTANCE  |
| `POST /v1/drd/search`                           | DECISION_REQUIREMENTS_DEFINITION | READ                     |
| `GET /v1/drd/:key`                              | DECISION_REQUIREMENTS_DEFINITION | READ                     |
| `GET /v1/drd/:key/xml`                          | DECISION_REQUIREMENTS_DEFINITION | READ                     |
| `POST /v1/incidents/search`                     | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |
| `GET /v1/incidents/:key`                        | PROCESS_DEFINITION               | READ_PROCESS_INSTANCE    |

### Mapping Tasklist permissions to new authorizations

To maintain the same access level for the Tasklist V1 API, apply the following authorizations:

**`tasklist-api:read`** is replaced by:

- `PROCESS_DEFINITION:*:READ_PROCESS_DEFINITION,READ_USER_TASK`

**`taslist-api:write`** is replaced by:

- `PROCESS_DEFINITION:*:UPDATE_USER_TASK`

### Tasklist V1 API permission matrix

To enable more fine-grained access control, the matrix below details the required permissions for each Tasklist V1 API endpoint.  
Ensure the user has general access (resource ID `*`) for each listed resource and permission type.

| Endpoint                                  | Resource Type      | Permission type  |
| ----------------------------------------- | ------------------ | ---------------- |
| `GET /v1/forms/:formId`                   | PROCESS_DEFINITION | READ_USER_TASK   |
| `POST /v1/tasks/search`                   | PROCESS_DEFINITION | READ_USER_TASK   |
| `GET /v1/tasks/:taskId`                   | PROCESS_DEFINITION | READ_USER_TASK   |
| `PATCH /v1/tasks/:taskId/assign`          | PROCESS_DEFINITION | UPDATE_USER_TASK |
| `PATCH /v1/tasks/:taskId/unassign`        | PROCESS_DEFINITION | UPDATE_USER_TASK |
| `PATCH /v1/tasks/:taskId/complete`        | PROCESS_DEFINITION | UPDATE_USER_TASK |
| `POST /v1/tasks/:taskId/variables`        | PROCESS_DEFINTION  | UPDATE_USER_TASK |
| `POST /v1/tasks/:taskId/variables/search` | PROCESS_DEFINITION | READ_USER_TASK   |
| `GET /v1/variables/:variableId`           | PROCESS_DEFINITION | READ_USER_TASK   |

---

## Migrate from gRPC to the Orchestration Cluster API

<PageDescription />

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide remains in the 8.9 documentation for customers who did not perform this migration during their 8.8 upgrade. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

This guide provides an overview of the process for migrating to the Orchestration Cluster REST API.

The [Orchestration Cluster API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) is the official REST API for connecting to Orchestration Cluster, automating processes, and implementing job workers.

## Camunda Java Client

In version 8.8.0, the [Camunda Java Client](/apis-tools/java-client/getting-started.md) changes to use the Orchestration Cluster API as a default cluster communication method.

:::info
Refer to the [Camunda Java Client migration guide](migrate-to-camunda-java-client.md#protocol-and-connection-rest-vs-grpc-selection) for details on how you can continue using gRPC.
:::

## gRPC vs REST mapping reference

The following table provides a mapping reference between gRPC methods and their equivalent REST API endpoints in the Orchestration Cluster API.

:::info
For detailed information on each REST endpoint, see [Orchestration Cluster API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).
:::

| gRPC Method Name (Gateway.proto)  | Orchestration Cluster REST API Endpoint                        | Notes                                                                    |
| --------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------ |
| `ActivateJobs`                    | `POST /v2/jobs/activation`                                     | Batch job activation via long polling (streaming not available in REST). |
| `BroadcastSignal`                 | `POST /v2/signals/broadcast`                                   | Triggers signal events.                                                  |
| `CancelProcessInstance`           | `POST /v2/process-instances/{processInstanceKey}/cancellation` | Cancels a process instance.                                              |
| `CompleteJob`                     | `POST /v2/jobs/{jobKey}/completion`                            | Completes a job.                                                         |
| `CreateProcessInstance`           | `POST /v2/process-instances`                                   | Starts a new process instance.                                           |
| `CreateProcessInstanceWithResult` | `POST /v2/process-instances?awaitCompletion=true`              | Starts a process instance, waits for completion.                         |
| `DeleteResource`                  | `POST /v2/resources/{resourceKey}/deletion`                    | Deletes a resource.                                                      |
| `DeployResource`                  | `POST /v2/deployments`                                         | Deploys BPMN, DMN, or form resources (multipart upload).                 |
| `EvaluateDecision`                | `POST /v2/decisions/evaluation`                                | Evaluates a DMN decision by key or id.                                   |
| `FailJob`                         | `POST /v2/jobs/{jobKey}/failure`                               | Marks a job as failed.                                                   |
| `MigrateProcessInstance`          | `POST /v2/process-instances/{processInstanceKey}/migration`    | Migrates a process instance (phase 1 only).                              |
| `ModifyProcessInstance`           | `POST /v2/process-instances/{processInstanceKey}/modification` | Modifies a running process instance.                                     |
| `PublishMessage`                  | `POST /v2/messages/publication`                                | Publishes a message asynchronously.                                      |
| `ResolveIncident`                 | `POST /v2/incidents/{incidentKey}/resolution`                  | Resolves an incident.                                                    |
| `SetVariables`                    | `PUT /v2/element-instances/{elementInstanceKey}/variables`     | Sets variables (local/global by param).                                  |
| `ThrowError`                      | `POST /v2/jobs/{jobKey}/error`                                 | Throws BPMN error from worker to engine.                                 |
| `Topology`                        | `GET /v2/topology`                                             | Returns cluster info.                                                    |
| `UpdateJobRetries`                | `PATCH /v2/jobs/{jobKey}`                                      | Updates job retries, PATCH can update multiple job properties.           |
| `UpdateJobTimeout`                | `PATCH /v2/jobs/{jobKey}`                                      | Updates job timeout, PATCH can update multiple job properties.           |

---

## Migrate from Web Modeler to the Camunda Hub API

<PageDescription />

:::warning Deprecation notice
Web Modeler API v1 is deprecated in Camunda 8.10 and will be removed in 8.12. Migrate to [Camunda Hub API v2](/apis-tools/hub-api-saas/overview.md) before upgrading to 8.12.
:::

## About this migration

Web Modeler API v1 is the REST API for Web Modeler, a standalone product for modeling and managing process diagrams. It exposes resources like projects, folders, files, and collaborators as they exist within Web Modeler.

[Camunda Hub API v2](/apis-tools/hub-api-saas/overview.md) is the successor API for the broader Camunda Hub platform. Camunda Hub unifies organizational management, workspace governance, and process modeling into a single platform. As a result, the conceptual model and architecture of the API have changed.

:::tip
Camunda Hub API v2 adopts the [Orchestration Cluster API v2](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) conventions. If you're already familiar with the Orchestration Cluster API v2, you will recognize patterns such as the offset-based pagination model, explicit filter operators, and flat response structures used throughout Camunda Hub API v2.
:::

Before migrating, familiarize yourself with the structural and terminology changes introduced in Camunda 8.10.

## Structure and terminology

Camunda 8.10 changes how resources are organized.

Before Camunda 8.10, Web Modeler resources were organized like this:

```
Organization
├─ Project
│  ├─ Process application
│  │   ├─ File
│  │   └─ Folder
│  │      └─ File
│  ├─ Folder
│  │   └─ File
│  └─ File
└─ Project
```

Organizations had projects. Projects optionally contained process applications, folders, and files.

Starting with Camunda 8.10, Camunda Hub resources are organized like this:

```
Organization
└─ Workspace
   ├─ Project
   │  ├─ Folder
   │  │   ├─ File
   │  │   └─ Folder
   │  └─ File
   └─ Project
```

Organizations have workspaces. Workspaces contain projects. Projects optionally contain folders and files.

The new structure introduces the following terminology changes:

| Web Modeler (\<8.10) | Camunda Hub (8.10+) | Notes                                                                                                                                                                                             |
| :------------------- | :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Project              | Workspace           | Files and folders can no longer be created at the workspace level.                                                                                                                                |
| Process application  | Project             | Process applications weren't explicitly exposed in Web Modeler API v1. In Camunda Hub API v2, there is a dedicated [project API](/apis-tools/hub-api-saas/specifications/create-project.api.mdx). |

In Camunda Hub API v2, the endpoint paths, field names, and underlying data all reflect the structural and terminology changes. In Web Modeler API v1 running on Camunda 8.10+, only the underlying data reflects the new organization. The sections below identify all affected endpoints and fields.

## Deprecation timeline

| Version  | Action                                                                                                                                                        |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **8.10** | Camunda Hub API v2 ships alongside Web Modeler API v1. Web Modeler API v1 is documented as **deprecated**, and its OpenAPI spec is marked `deprecated: true`. |
| **8.11** | Web Modeler API v1 remains available but isn't extended. No new features are added to deprecated endpoints.                                                   |
| **8.12** | Web Modeler API v1 endpoints are removed. Applications still using v1 receive `404`.                                                                          |

## General changes

The following sections cover changes that apply across the entire API, regardless of which resource you're working with. Review these before making any endpoint-specific changes.

### Base URLs

The base URL has changed for both SaaS and Self-Managed deployments. Update any hardcoded URLs or environment variables in your integration.

| Environment  | Web Modeler API v1                        | Camunda Hub API v2                    |
| ------------ | ----------------------------------------- | ------------------------------------- |
| SaaS         | `https://modeler.cloud.camunda.io/api/v1` | `https://hub.cloud.camunda.io/api/v2` |
| Self-Managed | `http://localhost:8070/api/v1`            | `http://localhost:8088/api/v2`        |

In Camunda 8 Self-Managed, the URLs depend on your configuration. The URLs and ports provided in this table are examples based on a [no-domain Helm deployment to a local kind cluster](/self-managed/deployment/helm/cloud-providers/kind.md#no-domain-mode-deployment).

### Authentication

See the Camunda Hub API authentication guide for [SaaS](/apis-tools/hub-api-saas/authentication.md) or [Self-Managed](/apis-tools/hub-api-sm/authentication.md) for setup instructions.

### Pagination

Offset pagination in Camunda Hub API v2 is different from Web Modeler API v1.

In Web Modeler API v1, you use two fields to paginate items:

- `page` specifies the page to return, starting with page 0.
- `size` specifies the number of items per page.

For example:

```json title="Web Modeler API v1"
{
  "page": 3,
  "size": 20
}
```

This request skips the first three _pages_ of 20 items (pages 0–2 and item indexes 0–59, inclusive) and returns the fourth page of 20 items (indexes 60–79). If there aren't enough items to fill the fourth page, you receive all remaining items.

The response includes two fields, `items` and `total`:

```json title="Web Modeler API v1"
{
    "items": [
        ...
    ],
    "total": 141
}
```

In Camunda Hub API v2, you use a `page` object with two fields:

- `page.from` specifies the offset, the item index to start from, starting with index 0.
- `page.limit` limits the number of items returned.

For example:

```json title="Camunda Hub API v2"
{
  "page": {
    "from": 60,
    "limit": 20
  }
}
```

Instead of specifying the number of pages to skip, you specify the index to start _from_ (60) and the maximum number, or _limit_, of items to return (20). This request returns the items at indexes 60–79. As in v1, if there are fewer items than the limit, you receive all remaining items.

The new response replaces `total` with a new `page` object that includes two fields, `totalItems` and `hasMoreTotalItems`:

```json title="Camunda Hub API v2"
{
    "items": [
        ...
    ],
    "page": {
        "totalItems": 360,
        "hasMoreTotalItems": false
    }
}
```

In addition to the different pagination model, the default page size has changed. In v1, the default page size is 10. In v2, the default limit is 100.

### Date filters

Web Modeler API v1 supports a custom date precision syntax that encodes a comparison operator, timestamp, and truncation unit into a single string. Camunda Hub API v2 uses explicit operators instead. You compute period boundaries yourself.

The following examples show equivalent date filters in Web Modeler API v1 and Camunda Hub API v2:

| Web Modeler API v1             | Camunda Hub API v2                                                       | Explanation                          |
| ------------------------------ | ------------------------------------------------------------------------ | ------------------------------------ |
| `2023-09-20T00:00:00Z\|\|/y`   | `{ "$gte": "2023-01-01T00:00:00Z", "$lte": "2023-12-31T23:59:59.999Z" }` | Within year 2023                     |
| `2023-09-20T00:00:00Z\|\|/M`   | `{ "$gte": "2023-09-01T00:00:00Z", "$lte": "2023-09-30T23:59:59.999Z" }` | Within September 2023                |
| `>=2023-09-20T00:00:00Z\|\|/y` | `{ "$gte": "2023-01-01T00:00:00Z" }`                                     | On or after start of 2023            |
| `<2023-09-20T00:00:00Z\|\|/M`  | `{ "$lt": "2023-09-01T00:00:00Z" }`                                      | Before September 2023                |
| `2023-09-20T11:31:20Z`         | `{ "$eq": "2023-09-20T11:31:20Z" }`                                      | Exact match                          |
| `>=2023-09-20T11:31:20Z`       | `{ "$gte": "2023-09-20T11:31:20Z" }`                                     | On or after a specific date and time |

The following date filter operators are available in Camunda Hub API v2:

| Operator | Description                 |
| -------- | --------------------------- |
| `$eq`    | Equals (same as v1 default) |
| `$gt`    | Greater than                |
| `$gte`   | Greater than or equal to    |
| `$lt`    | Less than                   |
| `$lte`   | Less than or equal to       |

### Search filters

Web Modeler API v1 uses equality-only filters, except for dates:

```json title="Web Modeler API v1"
{
  "filter": {
    "name": "my-process",
    "type": "bpmn"
  }
}
```

You can still use simple equality filters in Camunda Hub API v2, and you can also use more advanced explicit filter operators:

```json title="Camunda Hub API v2"
{
  "filter": {
    "name": { "$eq": "my-process" },
    "type": { "$in": ["bpmn"] }
  }
}
```

The following advanced filter operators are available in Camunda Hub API v2:

| Operator         | Description                             | Example                                                                     |
| ---------------- | --------------------------------------- | --------------------------------------------------------------------------- |
| `$eq`            | Equals (same as v1 default)             | `{ "name": { "$eq": "my-process" } }`                                       |
| `$neq`           | Not equals                              | `{ "type": { "$neq": "dmn" } }`                                             |
| `$gt` / `$gte`   | Greater than / greater than or equal to | `{ "created": { "$gte": "2024-01-01T00:00:00Z" } }`                         |
| `$lt` / `$lte`   | Less than / less than or equal to       | `{ "created": { "$lt": "2024-06-01T00:00:00Z" } }`                          |
| `$like`          | Pattern match (SQL LIKE)                | `{ "name": { "$like": "%order%" } }`                                        |
| `$in` / `$notIn` | In / not in list                        | `{ "type": { "$in": ["bpmn", "form"] } }`                                   |
| `$exists`        | Null check                              | `{ "folderKey": { "$exists": false } }`                                     |
| `$or`            | Logical OR                              | `{ "$or": [{ "type": { "$eq": "bpmn" } }, { "type": { "$eq": "form" } }] }` |

## Dropped endpoints

The following v1 endpoints have no v2 equivalent:

| Web Modeler API v1                                     | Notes                                                                                    |
| ------------------------------------------------------ | ---------------------------------------------------------------------------------------- |
| `POST /v1/milestones`                                  | Milestones were deprecated in Camunda 8.7. Use the [Versions API](#version-api) instead. |
| `GET /v1/milestones/{milestoneId}`                     | Use the [Versions API](#version-api) instead.                                            |
| `PATCH /v1/milestones/{milestoneId}`                   | Use the [Versions API](#version-api) instead.                                            |
| `DELETE /v1/milestones/{milestoneId}`                  | Use the [Versions API](#version-api) instead.                                            |
| `GET /v1/versions/compare/{version1Id}...{version2Id}` | See [Compare two versions](#compare-two-versions).                                       |

## File API

The following sections cover changes that apply to file API endpoints.

### Endpoint mapping

All file API endpoints have a Camunda Hub API v2 equivalent:

| Operation     | Web Modeler API v1          | Camunda Hub API v2           |
| ------------- | --------------------------- | ---------------------------- |
| Create a file | `POST /v1/files`            | `POST /v2/files`             |
| Get a file    | `GET /v1/files/{fileId}`    | `GET /v2/files/{fileKey}`    |
| Update a file | `PATCH /v1/files/{fileId}`  | `PATCH /v2/files/{fileKey}`  |
| Delete a file | `DELETE /v1/files/{fileId}` | `DELETE /v2/files/{fileKey}` |
| Search files  | `POST /v1/files/search`     | `POST /v2/files/search`      |

### Field mapping {#file-api-field-mapping}

The following fields have changed across all file endpoints:

| Web Modeler API v1 | Camunda Hub API v2 | Application      | Notes                                                                                                                                                                                                                                                                                                                                                                   |
| ------------------ | ------------------ | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fileType`         | `type`             | Request/response | Renamed. `element_template` is now `element-template`. File creation no longer supports `connector_template`. Existing connector template files are reported as `element-template`.                                                                                                                                                                                     |
| `folderId`         | `folderKey`        | Request/response | Renamed. If the file isn't in a folder, v1 endpoints return the project ID (["process application" before Camunda 8.10](#structure-and-terminology)), and v2 endpoints return `null`.                                                                                                                                                                                   |
| `projectId`        | `projectKey`       | Request/response | In v1, `projectId` refers to the ID of the "workspace" ([called the "project" before Camunda 8.10](#structure-and-terminology)). In v2, `projectKey` refers to the key of the "project". The concept of a "project" was [called a "process application" before Camunda 8.10](#structure-and-terminology), but process application data is not explicitly exposed in v1. |
| -                  | `content`          | Response         | In v1, `content` is returned as a separate top-level field alongside `metadata`. In v2, it's included in the flat file object.                                                                                                                                                                                                                                          |
| `id`               | `fileKey`          | Response         | Renamed                                                                                                                                                                                                                                                                                                                                                                 |
| `canonicalPath`    | `canonicalPath`    | Response         | In v1, `canonicalPath` is a list of objects. In v2, it's a [string](#canonical-path).                                                                                                                                                                                                                                                                                   |

### Canonical path

In Web Modeler API v1, `canonicalPath` is an array of objects containing an `id` and a `name` for each path element in the file's unique path:

```json title="Web Modeler API v1"
{
  "canonicalPath": [
    {
      "id": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
      "name": "Process application"
    },
    {
      "id": "b06c97f5-7e39-4108-b947-2848fdc023f0",
      "name": "Parent folder"
    },
    {
      "id": "62132025-57ff-4077-8c80-fc4ebe84aebe",
      "name": "Child folder"
    }
  ]
}
```

In Camunda Hub API v2, `canonicalPath` expresses the file's unique path as a `/`-delimited string. Unlike Web Modeler API v1, which includes `projects` ([called `process applications` before Camunda 8.10](#structure-and-terminology)), Camunda Hub API v2 only includes folder keys. The project is given in a separate field, called `projectKey`:

```json title="Camunda Hub API v2"
{
  "projectKey": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
  "canonicalPath": "b06c97f5-7e39-4108-b947-2848fdc023f0/62132025-57ff-4077-8c80-fc4ebe84aebe"
}
```

### Get a file

The v1 response returns a nested structure, with `metadata` and `content` as separate top-level fields:

```json title="Web Modeler API v1"
{
  "metadata": {
    "id": "57f4635b-5452-44a5-9020-bfce455484ab",
    "name": "process",
    "projectId": "b9b57035-fbce-4412-a7d5-9f0df61ed74d",
    "folderId": "62132025-57ff-4077-8c80-fc4ebe84aebe",
    "simplePath": "Process application/Parent folder/Child folder/process.bpmn",
    "canonicalPath": [
      {
        "id": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
        "name": "Process application"
      },
      {
        "id": "b06c97f5-7e39-4108-b947-2848fdc023f0",
        "name": "Parent folder"
      },
      {
        "id": "62132025-57ff-4077-8c80-fc4ebe84aebe",
        "name": "Child folder"
      }
    ],
    "revision": 5,
    "type": "BPMN",
    "created": "2026-07-08T09:59:34.262858Z",
    "createdBy": {
      "name": "...",
      "email": "..."
    },
    "updated": "2026-07-08T10:05:09.045782Z",
    "updatedBy": {
      "name": "...",
      "email": "..."
    }
  },
  "content": "..."
}
```

The v2 response is a flat object:

```json title="Camunda Hub API v2"
{
  "fileKey": "57f4635b-5452-44a5-9020-bfce455484ab",
  "name": "process",
  "projectKey": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
  "folderKey": "62132025-57ff-4077-8c80-fc4ebe84aebe",
  "simplePath": "Parent folder/Child folder/process.bpmn",
  "canonicalPath": "b06c97f5-7e39-4108-b947-2848fdc023f0/62132025-57ff-4077-8c80-fc4ebe84aebe",
  "revision": 5,
  "type": "bpmn",
  "content": "...",
  "created": "2026-07-08T09:59:34.262858Z",
  "createdBy": {
    "name": "...",
    "email": "..."
  },
  "updated": "2026-07-08T10:05:09.045782Z",
  "updatedBy": {
    "name": "...",
    "email": "..."
  }
}
```

### Update a file

A `revision` is now required to prevent overwriting concurrent changes. Fetch the current revision from a get or create response, and include it in your update request:

```json title="Camunda Hub API v2"
{
  "name": "process",
  "projectKey": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
  "folderKey": "62132025-57ff-4077-8c80-fc4ebe84aebe",
  // highlight-next-line
  "revision": 5,
  "content": "..."
}
```

### Search files

In addition to the [general field changes](#file-api-field-mapping), the following request fields have changed:

| Web Modeler API v1       | Camunda Hub API v2 | Notes                                                                                                               |
| ------------------------ | ------------------ | ------------------------------------------------------------------------------------------------------------------- |
| `filter`                 | `filter`           | Now uses [advanced operators](#search-filters), including `$eq`, `$in`, and `$like`                                 |
| `filter.folderId`        | `filter.folderKey` | Renamed                                                                                                             |
| `filter.createdBy.email` | `filter.createdBy` | In v1, `createdBy` is an object. In v2, it's a string representing the creator's email address.                     |
| `filter.updatedBy.email` | `filter.updatedBy` | In v1, `updatedBy` is an object. In v2, it's a string representing the updater's email address.                     |
| `sort.direction`         | `sort.order`       | Renamed                                                                                                             |
| `filter.projectId`       | -                  | Removed. You can no longer filter files by workspace (["project" before Camunda 8.10](#structure-and-terminology)). |

`content` is `null` on all items in the search response. Fetch individual files to retrieve content.

The following example shows a v1 request:

```json title="Web Modeler API v1"
{
  "filter": {
    "folderId": "16b0beb0-e6c0-494b-9953-c3ff461975f7",
    "createdBy": {
      "email": "jane.doe@email.com"
    }
  },
  "sort": {
    "field": "name",
    "direction": "DESC"
  }
}
```

The equivalent v2 request:

```json title="Camunda Hub API v2"
{
  "filter": {
    "folderKey": { "$eq": "16b0beb0-e6c0-494b-9953-c3ff461975f7" },
    "createdBy": "jane.doe@email.com"
  },
  "sort": {
    "field": "name",
    "order": "DESC"
  }
}
```

## Folder API

The following sections cover changes that apply to folder API endpoints.

### Endpoint mapping

All folder API endpoints have a Camunda Hub API v2 equivalent:

| Operation       | Web Modeler API v1              | Camunda Hub API v2               |
| --------------- | ------------------------------- | -------------------------------- |
| Create a folder | `POST /v1/folders`              | `POST /v2/folders`               |
| Get a folder    | `GET /v1/folders/{folderId}`    | `GET /v2/folders/{folderKey}`    |
| Update a folder | `PATCH /v1/folders/{folderId}`  | `PATCH /v2/folders/{folderKey}`  |
| Delete a folder | `DELETE /v1/folders/{folderId}` | `DELETE /v2/folders/{folderKey}` |

### Field mapping {#folder-api-field-mapping}

The following fields have changed across all folder endpoints:

| Web Modeler API v1 | Camunda Hub API v2 | Application      | Notes                                                                                                                                                                                                                                                                                                                |
| ------------------ | ------------------ | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `parentId`         | `parentFolderKey`  | Request/response | Renamed. If the folder is at the root of a project (["process application" before Camunda 8.10](#structure-and-terminology)), v1 endpoints return the project ID, and v2 endpoints return `null`.                                                                                                                    |
| `projectId`        | `projectKey`       | Request/response | In v1, `projectId` refers to the ID of the workspace ([called "project" before Camunda 8.10](#structure-and-terminology)). In v2, the workspace key is no longer available. Instead, `projectKey` refers to the key of the project ([called "process application" before Camunda 8.10](#structure-and-terminology)). |
| `id`               | `folderKey`        | Response         | Renamed                                                                                                                                                                                                                                                                                                              |

### Get a folder

In Web Modeler API v1, folder data in the response is nested under a `metadata` key:

```json title="Web Modeler API v1"
{
  "metadata": {
    "id": "b06c97f5-7e39-4108-b947-2848fdc023f0",
    "name": "Parent folder",
    "projectId": "b9b57035-fbce-4412-a7d5-9f0df61ed74d",
    "parentId": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
    "created": "2026-07-08T09:59:30.719344Z",
    "updated": "2026-07-08T10:04:56.47393Z",
    "createdBy": {
      "name": "...",
      "email": "..."
    },
    "updatedBy": {
      "name": "...",
      "email": "..."
    }
  },
  "content": {
    "folders": [],
    "files": []
  }
}
```

In Camunda Hub API v2, folder data is nested under a `folder` key:

```json title="Camunda Hub API v2"
{
  "folder": {
    "folderKey": "b06c97f5-7e39-4108-b947-2848fdc023f0",
    "name": "Parent folder",
    "projectKey": "1abf0198-3462-4fd2-a0e9-362f213d81d0",
    "parentFolderKey": null,
    "created": "2026-07-08T09:59:30.719344Z",
    "createdBy": {
      "name": "...",
      "email": "..."
    },
    "updated": "2026-07-08T10:04:56.47393Z",
    "updatedBy": {
      "name": "...",
      "email": "..."
    }
  },
  "content": {
    "folders": [],
    "files": []
  }
}
```

## Workspace API

In Web Modeler API v1, you manage workspaces ([called "projects" before Camunda 8.10](#structure-and-terminology)) with the `projects` resource. In Camunda Hub API v2, you manage them with the `workspaces` resource. The UUID values are the same. The concept, field names, and API paths have changed.

### Endpoint mapping

All workspace API endpoints have a Camunda Hub API v2 equivalent:

| Operation          | Web Modeler API v1                | Camunda Hub API v2                     |
| ------------------ | --------------------------------- | -------------------------------------- |
| Create a workspace | `POST /v1/projects`               | `POST /v2/workspaces`                  |
| Get a workspace    | `GET /v1/projects/{projectId}`    | `GET /v2/workspaces/{workspaceKey}`    |
| Update a workspace | `PATCH /v1/projects/{projectId}`  | `PATCH /v2/workspaces/{workspaceKey}`  |
| Delete a workspace | `DELETE /v1/projects/{projectId}` | `DELETE /v2/workspaces/{workspaceKey}` |
| Search workspaces  | `POST /v1/projects/search`        | `POST /v2/workspaces/search`           |

### Field mapping {#workspace-api-field-mapping}

The following fields have changed across all workspace endpoints:

| Web Modeler API v1 | Camunda Hub API v2 | Application | Notes    |
| ------------------ | ------------------ | ----------- | -------- |
| `id`               | `workspaceKey`     | Response    | Renamed. |

### Get a workspace

In Web Modeler API v1, workspace data in the response is nested under a `metadata` key with `folders` and `files` in the `content`:

```json title="Web Modeler API v1"
{
    "metadata": {
        "id": "b9b57035-fbce-4412-a7d5-9f0df61ed74d",
        "name": "Orders",
        "created": "2026-07-08T07:58:57.601559Z",
        "createdBy": {
            "name": "...",
            "email": "..."
        },
        "updated": "2026-07-08T07:59:13.386407Z",
        "updatedBy": {
            "name": "...",
            "email": "..."
        }
    },
    "content": {
        "folders": [ ... ],
        "files": [ ... ]
    }
}
```

In Camunda Hub API v2, workspace data is nested under a `workspace` key with `projects` in the `content`:

```json title="Camunda Hub API v2"
{
    "workspace": {
        "workspaceKey": "b9b57035-fbce-4412-a7d5-9f0df61ed74d",
        "name": "Orders",
        "description": null,
        "created": "2026-07-08T07:58:57.601559Z",
        "createdBy": {
            "name": "...",
            "email": "..."
        },
        "updated": "2026-07-08T07:59:13.386407Z",
        "updatedBy": {
            "name": "...",
            "email": "..."
        }
    },
    "content": {
        "projects": [ ... ]
    }
}
```

### Search workspaces

In addition to the [general field changes](#workspace-api-field-mapping), the following request fields have changed:

| Web Modeler API v1       | Camunda Hub API v2 | Notes                                                                                           |
| ------------------------ | ------------------ | ----------------------------------------------------------------------------------------------- |
| `filter`                 | `filter`           | Now uses [advanced operators](#search-filters), including `$eq`, `$in`, and `$like`             |
| `filter.id`              | -                  | Removed                                                                                         |
| `filter.description`     | -                  | Removed                                                                                         |
| `filter.createdBy.email` | `filter.createdBy` | In v1, `createdBy` is an object. In v2, it's a string representing the creator's email address. |
| `filter.updatedBy.email` | `filter.updatedBy` | In v1, `updatedBy` is an object. In v2, it's a string representing the updater's email address. |
| `sort.direction`         | `sort.order`       | Renamed                                                                                         |

The following example shows a v1 request:

```json title="Web Modeler API v1"
{
  "filter": {
    "createdBy": {
      "email": "jane.doe@email.com"
    }
  },
  "sort": {
    "field": "name",
    "direction": "DESC"
  }
}
```

The equivalent v2 request:

```json title="Camunda Hub API v2"
{
  "filter": {
    "createdBy": "jane.doe@email.com"
  },
  "sort": {
    "field": "name",
    "order": "DESC"
  }
}
```

## Member API

In Camunda Hub API v2, the collaborators API has been renamed to `members`. The following sections cover changes that apply to the member API endpoints.

### Endpoint mapping

All member API endpoints have a Camunda Hub API v2 equivalent:

| Operation             | Web Modeler API v1                                      | Camunda Hub API v2                                     |
| --------------------- | ------------------------------------------------------- | ------------------------------------------------------ |
| Add a collaborator    | `PUT /v1/collaborators`                                 | `POST /v2/workspaces/{workspaceKey}/members`           |
| Remove a collaborator | `DELETE /v1/projects/{projectId}/collaborators/{email}` | `DELETE /v2/workspaces/{workspaceKey}/members/{email}` |
| Search collaborators  | `POST /v1/collaborators/search`                         | `POST /v2/members/search`                              |

### Field mapping {#member-api-field-mapping}

The following fields have changed across all member endpoints:

| Web Modeler API v1 | Camunda Hub API v2 | Application      | Notes    |
| ------------------ | ------------------ | ---------------- | -------- |
| `projectId`        | `workspaceKey`     | Request/response | Renamed. |

### Add a member

In Web Modeler API v1, the method is `PUT`, and the `projectId` is in the request body:

```bash title="Web Modeler API v1"
PUT /api/v1/collaborators
{
    "email": "jane.doe@email.com",
    "projectId": "b9b57035-fbce-4412-a7d5-9f0df61ed74d",
    "role": "viewer"
}
```

In Camunda Hub API v2, the method is `POST`, and the workspace key is in the path:

```bash title="Camunda Hub API v2"
POST /api/v2/workspaces/b9b57035-fbce-4412-a7d5-9f0df61ed74d/members
{
    "email": "jane.doe@email.com",
    "role": "viewer"
}
```

### Search members

In addition to the [general field changes](#member-api-field-mapping), the following request fields have changed:

| Web Modeler API v1 | Camunda Hub API v2    | Notes                                                                                           |
| ------------------ | --------------------- | ----------------------------------------------------------------------------------------------- |
| `filter`           | `filter`              | Now uses [advanced operators](#search-filters), including `$eq`, `$in`, and `$like`             |
| `filter.projectId` | `filter.workspaceKey` | Renamed. In v2, `filter.workspaceKey` is required. Members can't be searched across workspaces. |
| `sort.direction`   | `sort.order`          | Renamed                                                                                         |

The following example shows a v1 request:

```json title="Web Modeler API v1"
{
  "filter": {
    "projectId": "b9b57035-fbce-4412-a7d5-9f0df61ed74d",
    "role": "project_admin"
  },
  "sort": {
    "field": "name",
    "direction": "DESC"
  }
}
```

The equivalent v2 request:

```json title="Camunda Hub API v2"
{
  "filter": {
    "workspaceKey": { "$eq": "b9b57035-fbce-4412-a7d5-9f0df61ed74d" },
    "role": { "$eq": "workspace_admin" }
  },
  "sort": {
    "field": "name",
    "order": "DESC"
  }
}
```

### Role enum

| Web Modeler API v1 | Camunda Hub API v2 | Notes                                  |
| ------------------ | ------------------ | -------------------------------------- |
| `project_admin`    | `workspace_admin`  | Renamed to match workspace terminology |
| `editor`           | `editor`           | Unchanged                              |
| `commenter`        | `commenter`        | Unchanged                              |
| `viewer`           | `viewer`           | Unchanged                              |

## Version API

The following sections cover changes that apply to version API endpoints.

### Endpoint mapping

All version API endpoints have a Camunda Hub API v2 equivalent, except the compare versions endpoint:

| Operation            | Web Modeler API v1                                     | Camunda Hub API v2                           |
| -------------------- | ------------------------------------------------------ | -------------------------------------------- |
| Create a version     | `POST /v1/versions`                                    | `POST /v2/versions`                          |
| Get a version        | `GET /v1/versions/{versionId}`                         | `GET /v2/versions/{versionKey}`              |
| Update a version     | `PATCH /v1/versions/{versionId}`                       | `PATCH /v2/versions/{versionKey}`            |
| Delete a version     | `DELETE /v1/versions/{versionId}`                      | `DELETE /v2/versions/{versionKey}`           |
| Search versions      | `POST /v1/versions/search`                             | `POST /v2/versions/search`                   |
| Restore a version    | `POST /v1/versions/{versionId}/restore`                | `POST /v2/versions/{versionKey}/restoration` |
| Compare two versions | `GET /v1/versions/compare/{version1Id}...{version2Id}` | [Does not exist](#compare-two-versions)      |

### Field mapping {#version-api-field-mapping}

The following fields have changed across all version endpoints:

| Web Modeler API v1 | Camunda Hub API v2 | Application      | Notes   |
| ------------------ | ------------------ | ---------------- | ------- |
| `fileId`           | `fileKey`          | Request/response | Renamed |
| `id`/`versionId`   | `versionKey`       | Response         | Renamed |

### Get a version

In Web Modeler API v1, version data in the response is nested under a `metadata` key:

```json title="Web Modeler API v1"
{
  "metadata": {
    "id": "c3e3a091-513e-4911-94d0-32aca88c80b9",
    "name": "V2",
    "description": "...",
    "fileId": "0ade583b-4022-47b5-8982-93ddd849ee6b",
    "created": "2026-06-09T16:50:37.186742Z",
    "createdBy": {
      "name": "...",
      "email": "..."
    },
    "updated": "2026-06-09T16:50:58.356172Z",
    "updatedBy": {
      "name": "...",
      "email": "..."
    },
    "organizationPublic": false
  },
  "content": "..."
}
```

In Camunda Hub API v2, version data is at the top level of the response body:

```json title="Camunda Hub API v2"
{
  "versionKey": "c3e3a091-513e-4911-94d0-32aca88c80b9",
  "name": "V2",
  "description": "...",
  "fileKey": "0ade583b-4022-47b5-8982-93ddd849ee6b",
  "organizationPublic": false,
  "created": "2026-06-09T16:50:37.186742Z",
  "createdBy": {
    "name": "...",
    "email": "..."
  },
  "updated": "2026-06-09T16:50:58.356172Z",
  "updatedBy": {
    "name": "...",
    "email": "..."
  },
  "content": "..."
}
```

### Search versions

In addition to the [general field changes](#version-api-field-mapping), the following request fields have changed:

| Web Modeler API v1 | Camunda Hub API v2 | Notes                                                                                  |
| ------------------ | ------------------ | -------------------------------------------------------------------------------------- |
| `filter`           | `filter`           | Now uses [advanced operators](#search-filters), including `$eq`, `$in`, and `$like`    |
| `filter.fileId`    | `filter.fileKey`   | Renamed. In v2, `filter.fileKey` is required. Versions can't be searched across files. |
| `sort.direction`   | `sort.order`       | Renamed                                                                                |

The following example shows a v1 request:

```json title="Web Modeler API v1"
{
  "filter": {
    "fileId": "0ade583b-4022-47b5-8982-93ddd849ee6b"
  },
  "sort": {
    "field": "name",
    "direction": "DESC"
  }
}
```

The equivalent v2 request:

```json title="Camunda Hub API v2"
{
  "filter": {
    "fileKey": { "$eq": "0ade583b-4022-47b5-8982-93ddd849ee6b" }
  },
  "sort": {
    "field": "name",
    "order": "DESC"
  }
}
```

### Restore a version

In Web Modeler API v1, the endpoint path uses `/restore`, and you pass the `versionId` in both the path and the request body:

```bash title="Web Modeler API v1"
POST /api/v1/versions/{versionId}/restore
{
  "versionId": {versionId}
}
```

In Camunda Hub API v2, the endpoint path uses `/restoration`, and you identify the version using the path parameter:

```bash title="Camunda Hub API v2"
POST /api/v2/versions/{versionKey}/restoration
(no body)
```

For element template files, include a `version` integer in the request body to set the target version number in the restored content:

```bash title="Camunda Hub API v2"
POST /api/v2/versions/{versionKey}/restoration
{ "version": 2 }
```

### Compare two versions

The compare versions endpoint `GET /versions/compare/{version1Id}...{version2Id}` no longer exists in Camunda Hub API v2.

In Web Modeler API v1, the compare versions endpoint returns a link to a visual comparison between two versions, with `version1Id` as the baseline and `version2Id` as the version being compared.

Instead of making an API request for this link, you can construct it yourself:

1. Get the file and version keys from the search or get version API.
2. Insert the keys into one of the following URL patterns, and open the URL in your browser:

| Resource type    | Template URL                                                                     |
| :--------------- | :------------------------------------------------------------------------------- |
| BPMN             | `{baseURL}/diagrams/{fileKey}/versions/{versionKey1}...{versionKey2}`            |
| Element template | `{baseURL}/connector-templates/{fileKey}/versions/{versionKey1}...{versionKey2}` |
| Form             | `{baseURL}/forms/{fileKey}/versions/{versionKey1}...{versionKey2}`               |
| RPA              | `{baseURL}/rpa-scripts/{fileKey}/versions/{versionKey1}...{versionKey2}`         |

Replace `{baseURL}` with the Camunda Hub base URL. The version keys must be for the same file.

For example:

```bash
https://hub.cloud.camunda.io/diagrams/98634f96-52e9-4c00-8702-893a12803771/versions/2b6fd548-e107-4338-ae59-37a609f65202...78e0f8c5-0462-4521-bff9-5f432d689925
```

## Info API

### Endpoint mapping

The info API endpoint has a Camunda Hub API v2 equivalent:

| Operation | Web Modeler API v1 | Camunda Hub API v2 |
| --------- | ------------------ | ------------------ |
| Get info  | `GET /v1/info`     | `GET /v2/info`     |

### Get info

The following response fields have changed:

| Web Modeler API v1         | Camunda Hub API v2         | Notes     |
| -------------------------- | -------------------------- | --------- |
| `version` (returns `"v1"`) | `version` (returns `"v2"`) | New value |
| `createPermission`         | -                          | Removed   |
| `readPermission`           | -                          | Removed   |
| `updatePermission`         | -                          | Removed   |
| `deletePermission`         | -                          | Removed   |

To determine your permissions, check the scopes you configured when creating your API token. If a request lacks the required permission, the API returns `403 Forbidden` with a `ProblemDetail` body explaining which permission is missing.

---

## Camunda 8.10 APIs & Tools migration guide

<PageDescription />

## About

This guide details the API and SDK changes introduced in Camunda 8.10 that require customer action, including breaking changes, deprecations, and step-by-step migration actions.

Details are provided for each integration type, including what changed, why, and what action you must take.

| Integration type       | Description                                               |
| :--------------------- | :-------------------------------------------------------- |
| Official SDK users     | Java client, TypeScript SDK, Python SDK, and C# SDK.      |
| Generated-client users | Clients generated from the Camunda OpenAPI specification. |
| Custom integrations    | Custom code that calls the Camunda REST API directly.     |

<!--- >:::info
For a full list of changes, see the [8.10 release announcements](/reference/announcements-release-notes/8100/8100-announcements.md) and [release notes](/reference/announcements-release-notes/8100/8100-release-notes.md).
::: --->

## Upgrade steps

Complete the following steps in this guide:

1. Upgrade to the latest official Camunda SDK versions.
1. If you generate clients from OpenAPI, regenerate them from the 8.10 specification.
1. Re-run compilation/type checks and address any errors.
1. Review and apply fixes for the breaking changes, deprecations, and supported environment changes below.

### Camunda 8.10 breaking changes, deprecations, and supported environment changes

Review the actions required for the following 8.10 changes:

| Type                                                              | Change                                                                                                                      |
| :---------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------- |
| Breaking change      | [Search filters: `UserTaskFilter` process filters converted into advanced search filters](#usertask-process-filter)         |
| Breaking change      | [`POST /v2/message-subscriptions/search` returns start event subscriptions](#message-subscription-type)                     |
| Breaking change      | [Administration API (Self-Managed) migrated](#administration-api-self-managed-migrated)                                     |
| Behavioral change | [Element instance search: advanced filters on `elementId` / `elementName` and `$or` support](#element-instance-advanced-or) |
| Behavioral change | [Resource API now uses eventual consistency](#resource-eventual-consistency)                                                |
| Deprecated        | [Deprecated: GET resource content API](#deprecated-get-resource-content)                                                    |

## Breaking changes

Review actions required for the following breaking changes:

### Search filters: `UserTaskFilter` process filters converted into advanced search filters {#usertask-process-filter}

#### Change

The search filter criteria for `processDefinitionKey`, `processInstanceKey`, and `bpmnProcessId` in `UserTaskFilter` have been converted into advanced search filters.

#### Why

As a result of the V1 API removal, advanced process filtering for user tasks was no longer supported. These changes let you use advanced process filters with the V2 User Tasks API again.

#### Impact

This affects the Java client because `io.camunda.client.api.search.filter.UserTaskFilter` now accepts advanced filters for `processDefinitionKey`, `processInstanceKey`, and `bpmnProcessId`.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. The new SDK version includes advanced filters for `processDefinitionKey`, `processInstanceKey`, and `bpmnProcessId` in `UserTaskFilter`.

</TabItem>
<TabItem value='generated'>

Regenerate your client.

</TabItem>
<TabItem value='custom'>

No change is needed if your code already uses the exact-match filters for `processDefinitionKey`, `processInstanceKey`, and `bpmnProcessId` in `UserTaskFilter`.

</TabItem>
</Tabs>

### `POST /v2/message-subscriptions/search` returns start event subscriptions {#message-subscription-type}

#### Change

The `POST /v2/message-subscriptions/search` endpoint now returns both start event and intermediate event message subscriptions. Previously, only intermediate event subscriptions were returned.

#### Why

This change provides complete visibility into all active message subscriptions for a process, including start event subscriptions that were previously excluded.

#### New field

Each result includes a new `messageSubscriptionType` enum field:

| Value           | Description                                       |
| :-------------- | :------------------------------------------------ |
| `START_EVENT`   | A start event message subscription.               |
| `PROCESS_EVENT` | An intermediate catch event message subscription. |

In existing legacy data, this field is `NULL`.

#### Impact

Integrations that consume results from `POST /v2/message-subscriptions/search` will now receive start event subscriptions in addition to intermediate event subscriptions. Code that assumes only intermediate events may produce unexpected behavior.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. If your code relies on the endpoint returning only intermediate event subscriptions, add a filter to exclude start events when constructing your search query.

</TabItem>
<TabItem value='generated'>

Regenerate your client from the 8.10 OpenAPI specification to include the new `messageSubscriptionType` field. If your code expects only intermediate event subscriptions, add the filter shown in the **Custom integrations** tab to your request payload.

</TabItem>
<TabItem value='custom'>

If your code relies on the endpoint returning only intermediate event subscriptions, add the following filter to restore the previous behavior:

```json title="Before (no filter needed — endpoint returned only intermediate events)"
{
  "filter": {}
}
```

```json title="After (filter required to exclude start events)"
{
  "filter": {
    "messageSubscriptionType": { "$neq": "START_EVENT" }
  }
}
```

This filter works correctly for both new data and legacy data (which has `NULL` in the `messageSubscriptionType` field).

</TabItem>
</Tabs>

### Administration API (Self-Managed) migrated

The Administration API endpoints for Self-Managed have been migrated to the now-deprecated [Web Modeler API v1](../web-modeler-api/index.md):

| Admin API (Self-Managed)       | Web Modeler API v1                   |
| :----------------------------- | :----------------------------------- |
| `GET /admin-api/usage-metrics` | `GET /api/v1/clusters/usage-metrics` |
| `GET /admin-api/clusters`      | `GET /api/v1/clusters`               |

For both endpoints, you need a [token with read permissions](../web-modeler-api/authentication.md#generate-a-token).

These endpoints return the same data as the original Administration APIs, but the response format matches the other Web Modeler APIs.

## Behavioral changes

### Element instance search: advanced filters on `elementId` / `elementName` and `$or` support {#element-instance-advanced-or}

#### Change

The element instance search endpoint (`POST /v2/element-instances/search`) gained two filtering capabilities:

- The `elementId` and `elementName` filter fields now accept [advanced search filter objects](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-data-fetching.md#advanced-search-filters) in addition to plain string equality. Supported operators: `$eq`, `$neq`, `$exists`, `$in`, `$notIn`, `$like` (wildcard pattern with `*` and `?`).
- The request body's `filter` object now accepts a top-level `$or` property that takes an array of alternative filter groups combined with OR logic. Top-level filter fields and `$or` are combined with AND logic.

#### Why

These additions let you express the queries the user interface (UI) needs (for example, "match any element whose name or ID contains a substring") in a single request, avoiding multiple round trips and client-side merging.

#### Impact

The change is additive and backward compatible — existing exact-match requests continue to work unchanged. New requests can now use advanced operators and `$or` to express richer queries:

```json
{
  "filter": {
    "processInstanceKey": "2251799813685323",
    "$or": [
      { "elementName": { "$like": "*Order*" } },
      { "elementId": { "$like": "*Order*" } }
    ]
  }
}
```

The example matches element instances where `processInstanceKey` equals the given value AND either `elementName` or `elementId` contains the substring `Order`.

:::note
Complex `$or` conditions may impact performance in high-volume environments; use them with care.
:::

The `elementName` filter only matches instances created in 8.8 or later, since earlier runtimes did not persist this field on element instances.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. The new SDK exposes advanced filters for `elementId` and `elementName`, and the `$or` filter on `ElementInstanceFilter`.

</TabItem>
<TabItem value='generated'>

Regenerate your client from the 8.10 OpenAPI specification to pick up the advanced filter and `$or` types on `ElementInstanceFilter`.

</TabItem>
<TabItem value='custom'>

No change is needed for existing requests. To use the new operators, send advanced filter objects on `elementId` / `elementName`, or a top-level `$or` array, as shown above.

</TabItem>
</Tabs>

### Resource API now uses eventual consistency {#resource-eventual-consistency}

The [Get resource] and [Get resource content] APIs now retrieve from secondary storage, resulting in eventual consistency. After a resource is deployed, there may be a brief delay before it becomes retrievable via these endpoints.

If your application assumes immediate resource retrieval after deployment, add retry logic or a short delay before querying resources.

## Deprecations

Review the actions required for the following deprecations:

### Deprecated: GET resource content API {#deprecated-get-resource-content}

The [Get resource content] endpoint is deprecated. Use [Get resource content binary] instead, which provides the same functionality and also returns generic resources.

## Next steps

Once you have completed the [upgrade steps](#upgrade-steps) in this guide, you should:

1. Re-compile and run your test suite against the 8.10 API.
<!--- 1. Review [8.10 release announcements](/reference/announcements-release-notes/8100/8100-announcements.md) for additional context on each change. --->

[Get resource]: ../orchestration-cluster-api-rest/specifications/get-resource.api.mdx
[Get resource content]: ../orchestration-cluster-api-rest/specifications/get-resource-content.api.mdx
[Get resource content binary]: ../orchestration-cluster-api-rest/specifications/get-resource-content-binary.api.mdx

---

## Camunda 8.9 APIs & Tools migration guide

<PageDescription />

## About

This guide details the API and SDK changes introduced in Camunda 8.9 that require customer action, including breaking changes, deprecations, and step-by-step migration actions.

Details are provided for each integration type, including what changed, why, and what action you must take.

| Integration type       | Description                                               |
| :--------------------- | :-------------------------------------------------------- |
| Official SDK users     | Java client, TypeScript SDK, Python SDK, C# SDK.          |
| Generated-client users | Clients generated from the Camunda OpenAPI specification. |
| Custom integrations    | Custom code that calls the Camunda REST API directly.     |

:::info
For a full list of changes, see the [8.9 release announcements](/reference/announcements-release-notes/890/890-announcements.md) and [release notes](/reference/announcements-release-notes/890/890-release-notes.md).
:::

## Upgrade steps

Complete the following steps in this guide:

1. Upgrade to the latest official Camunda SDK versions.
1. If you generate clients from OpenAPI, regenerate them from the 8.9 specification.
1. Re-run compilation/type checks and address any errors.
1. Review and apply fixes for the breaking changes, deprecations, and supported environment changes below.

### API and SDK changes to migrate before Camunda 8.10

If you did not already migrate to the following APIs and SDKs during your 8.8 upgrade, Camunda recommends you perform these migrations before you upgrade to 8.9, as this must be performed before 8.10.

If you already performed these migrations during your 8.8 upgrade, proceed to [Camunda 8.9 breaking changes, deprecations, and supported environment changes](#camunda-89-breaking-changes-deprecations-and-supported-environment-changes).

| 8.9 status                                                 | Component/Use                                                                       | Migrate to                  | Migrate by          |
| :--------------------------------------------------------- | :---------------------------------------------------------------------------------- | :-------------------------- | :------------------ |
| Deprecated | [V1 component APIs](../migration-manuals/migrate-to-camunda-api.md)                 | Orchestration Cluster API   | Before Camunda 8.10 |
| Deprecated | [ZeebeClient](../migration-manuals/migrate-to-camunda-java-client.md)               | Camunda Java Client         | Before Camunda 8.10 |
| Deprecated | [Spring Zeebe SDK](../migration-manuals/migrate-to-camunda-spring-boot-starter.md)  | Camunda Spring Boot Starter | Before Camunda 8.10 |
| Deprecated | [Zeebe Process Test (ZPT)](../migration-manuals/migrate-to-camunda-process-test.md) | Camunda Process Test (CPT)  | Before Camunda 8.10 |
| Deprecated | [Job-based user tasks](../migration-manuals/migrate-to-camunda-user-tasks.md)       | Camunda user tasks          | Before Camunda 8.10 |

:::tip
Learn more about API changes in the blog post [Upcoming API Changes in Camunda 8: A Unified and Streamlined Experience](https://camunda.com/blog/2024/12/api-changes-in-camunda-8-a-unified-and-streamlined-experience/).
:::

### Camunda 8.9 breaking changes, deprecations, and supported environment changes

Review the actions required for the following 8.9 changes:

| Type                                                         | Change                                                                                                              |
| :----------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------ |
| Breaking change | [Bug fix: `FormResult.schema` type corrected from object to string](#form-schema-type)                              |
| Breaking change | [Document API response schemas now have explicit required and nullable annotations](#request-response-schema-split) |
| Breaking change | [MCP Client and MCP Remote Client connectors](#mcp)                                                                 |
| Breaking change | [OpenAPI enum extensions](#enum-extensions)                                                                         |
| Breaking change | [OpenAPI type-safety enhancements](#type-safety-enhancements)                                                       |
| Breaking change | [Resource deletion endpoint now returns a response body](#resource-deletion)                                        |
| Breaking change | [Search filter validation errors now return structured error collections](#search-filter-validation-errors)         |
| Breaking change | [Spring Boot 4.0 default for Camunda Spring Boot Starter](#spring-boot)                                             |
| Breaking change | [Type-safe pagination model in the Camunda Java client](#type-safe-pagination)                                      |
| Breaking change | [`versionTag` returns `null` instead of empty string when absent](#version-tag-null)                                |
| Deprecated   | [Deprecated: enum literals in Orchestration Cluster API v2](#deprecated-enum)                                       |

## Breaking changes

Review actions required for the following breaking changes:

### Bug fix: `FormResult.schema` type corrected from object to string {#form-schema-type}

#### Change

The `schema` property in `FormResult` was incorrectly specified as `type: object` in the OpenAPI contract. The server has always returned it as a JSON `string`. The specification is now corrected.

#### Why

This is a bug fix. The original specification was inaccurate and caused incorrect typing in generated clients.

#### Impact

This impacts the Java client as `io.camunda.client.api.search.response.Form::getSchema()` now returns `String` instead of `Object`.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. If you are a Java client user, update any calls to `Form::getSchema()` that cast or process the return value as `Object` — it is now `String`.

</TabItem>
<TabItem value='generated'>

Regenerate your client. If your generated code relied on the incorrect `object` typing for `FormResult.schema`, update it to handle `string`.

</TabItem>
<TabItem value='custom'>

No change needed if your code was already handling the actual `string` response from the server.

</TabItem>
</Tabs>

### Document API response schemas now have explicit required and nullable annotations {#request-response-schema-split}

#### Change

The OpenAPI specification now uses distinct schemas for document request and response payloads, and adds explicit `required` / `nullable` annotations to document response types.

#### Why

A shared `DocumentMetadata` schema was used for both creating and reading documents. Because response fields like `customProperties` are always populated by the server but optional in requests, a single schema could not accurately express both contracts. This caused incorrect required/optional behavior in generated clients.

#### Affected schemas

| Schema                               | Change                                                                                                                                                                                                                            |
| :----------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `DocumentMetadata`                   | Now request-only. Removed `required: [customProperties]` — `customProperties` is now optional in requests.                                                                                                                        |
| `DocumentMetadataResponse` (new)     | Response schema with required fields: `fileName`, `expiresAt`, `size`, `contentType`, `customProperties`, `processDefinitionId`, `processInstanceKey`. `expiresAt`, `processDefinitionId`, and `processInstanceKey` are nullable. |
| `DocumentReference`                  | `metadata` now references `DocumentMetadataResponse`. Added `required`: `camunda.document.type`, `storeId`, `documentId`, `contentHash`, `metadata`. `contentHash` is now nullable.                                               |
| `DocumentLink`                       | `url` and `expiresAt` are now explicitly required.                                                                                                                                                                                |
| `UserTaskResult.candidateGroups`     | Now marked as required in the response schema.                                                                                                                                                                                    |
| `UserTaskProperties.candidateGroups` | Now marked as required in the response schema.                                                                                                                                                                                    |

#### Impact

The Java client is impacted as `DocumentMetadataImpl` (both `io.camunda.client` and the deprecated `io.camunda.zeebe.client`) now uses `DocumentMetadataResponse` instead of `DocumentMetadata` internally.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. The updated response models are included automatically. Re-compile your application to verify.

</TabItem>
<TabItem value='generated'>

1. Regenerate your client from the 8.9 OpenAPI specification.
2. Update any code that references `DocumentMetadata` in response handling — the response type is now `DocumentMetadataResponse`.
3. Review nullable annotations: `DocumentReference.contentHash`, `DocumentMetadataResponse.expiresAt`, `.processDefinitionId`, and `.processInstanceKey` can be `null`.
4. Code that reads `candidateGroups` from user task or job responses can now rely on the field being present without null checks.

</TabItem>
<TabItem value='custom'>

No request-side changes are needed. Response fields listed above are now guaranteed to be present (though some may be `null`). If your code reads document metadata responses and checks for `customProperties` or `candidateGroups` presence, those fields are now always included.

</TabItem>
</Tabs>

### MCP Client and MCP Remote Client connectors {#mcp}

#### Change

Breaking changes were introduced in alpha 2 to the element templates and runtime configuration of the MCP Client.

#### Why

This improves the stability and configuration model of the MCP connectors.

#### Action

Update both the MCP Client and MCP Remote Client connectors to use element template version 1. See the [MCP documentation](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client.md) for details.

### OpenAPI enum extensions {#enum-extensions}

#### Change

New enum literals were added to support expanded 8.9 functionality.

#### Why

These additions enable new features such as decision instance deletion and user task authorization.

#### Enum members added

| Enum                                                          | New value                  |
| :------------------------------------------------------------ | :------------------------- |
| `BatchOperationTypeEnum` / `BatchOperationTypeFilterProperty` | `DELETE_DECISION_INSTANCE` |
| `ResourceTypeEnum`                                            | `USER_TASK`                |
| `PermissionTypeEnum`                                          | `COMPLETE`                 |

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version for full enum support. Re-compile your application — the compiler will signal any exhaustive match issues.

</TabItem>
<TabItem value='generated'>

1. Regenerate your client from the 8.9 OpenAPI specification.
2. Add fallback/default handling in enum parsing and deserialization.
3. Ensure exhaustive `switch` or pattern matches include a `default` branch.

</TabItem>
<TabItem value='custom'>

Review all code paths that handle these enum values. Add handling for the new values and ensure you have a fallback for unknown values in `switch`/`if-else` chains.

:::note
In Java, the compiler does not signal incomplete enum handling at compile time. Search your codebase for references to `BatchOperationTypeEnum`, `ResourceTypeEnum`, and `PermissionTypeEnum` and verify coverage manually.
:::

</TabItem>
</Tabs>

### OpenAPI type-safety enhancements {#type-safety-enhancements}

#### Change

Several request properties in the OpenAPI contract now use stronger domain types instead of plain `string`, and one schema type was renamed. This completes the type-safety work that began in 8.8.

#### Why

This increases compile-time safety and helps prevent semantic substitution errors — for example, accidentally passing a `tenantId` where a `documentId` is expected. Compilers can now reason about semantic correctness in addition to structural correctness for these fields.

#### Affected fields and types

| Field                                                                           | Old type | New type                                          |
| :------------------------------------------------------------------------------ | :------- | :------------------------------------------------ |
| `CreateDeploymentData.body.tenantId`                                            | `string` | `TenantId`                                        |
| `CreateDocumentData.query.documentId`                                           | `string` | `DocumentId`                                      |
| `SearchCorrelatedMessageSubscriptionsData.body.filter.processDefinitionKey.$eq` | `string` | `ProcessDefinitionKey`                            |
| `CorrelatedMessageSubscriptionFilter.processDefinitionKey`                      | `string` | `ProcessDefinitionKeyFilterProperty \| undefined` |
| `CorrelatedMessageSubscriptionSearchQuery.filter.processDefinitionKey.$eq`      | `string` | `ProcessDefinitionKey`                            |

#### Schema rename

| Old name                             | New name              |
| :----------------------------------- | :-------------------- |
| `ProcessInstanceIncidentSearchQuery` | `IncidentSearchQuery` |

**Example — message subscription filter payload**:

```json title="Before"
{
  "processDefinitionKey": "2251799813685251"
}
```

```json title="After (for example, using $eq)"
{
  "processDefinitionKey": { "$eq": "2251799813685251" }
}
```

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. The wire-type of these fields does not change, so most SDK users will not need code changes. Re-compile your application to verify.

</TabItem>
<TabItem value='generated'>

1. Regenerate your client from the 8.9 OpenAPI specification.
2. Update type imports and references — in particular, rename `ProcessInstanceIncidentSearchQuery` to `IncidentSearchQuery`.
3. Update request payload construction for `processDefinitionKey` fields to use the new filter property type.

</TabItem>
<TabItem value='custom'>

1. Update request payload construction for `processDefinitionKey` to use the filter object format.
2. Update any references to `ProcessInstanceIncidentSearchQuery` in your code.

</TabItem>
</Tabs>

### Resource deletion endpoint now returns a response body {#resource-deletion}

#### Change

The resource deletion endpoint `POST /resources/{resourceKey}/deletion` now returns a response body instead of an empty response.

#### Why

This provides explicit deletion feedback, making client-side confirmation, auditing, and follow-up workflow logic more reliable.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. The updated response model is included automatically.

</TabItem>
<TabItem value='generated'>

Regenerate your client from the 8.9 OpenAPI specification. Update any code that previously expected an empty `204` response to handle the new response body.

</TabItem>
<TabItem value='custom'>

Update your HTTP client code to parse the new JSON response body from the deletion endpoint, rather than treating it as a `204 No Content`.

</TabItem>
</Tabs>

### Spring Boot 4.0 default for Camunda Spring Boot Starter {#spring-boot}

#### Change

Starting with 8.9.0, the default [Camunda Spring Boot Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md) (`camunda-spring-boot-starter`) is bundled with and requires Spring Boot 4.0.x. A dedicated `camunda-spring-boot-3-starter` module is available for applications that are not yet ready to upgrade.

#### Action

- Migrate your application to Spring Boot 4.0.x and continue using `camunda-spring-boot-starter`.
- If you cannot migrate yet, switch your dependency to `camunda-spring-boot-3-starter`, which is bundled with Spring Boot 3.5.x. Camunda will continue to maintain this module beyond June 2026 (when Spring's own OSS support for Spring Boot 3.x ends). For Spring framework-level security patches after that date, consider commercial support from a third-party provider.
- See the [Spring Boot support timeline](https://spring.io/projects/spring-boot#support) for details.
- See the [dedicated Spring Boot 3 and 4 modules](/apis-tools/camunda-spring-boot-starter/getting-started.md#dedicated-spring-boot-3-and-4-modules) documentation for more information.

### `versionTag` returns `null` instead of empty string when absent {#version-tag-null}

#### Change

API response fields for `versionTag` now return `null` instead of an empty string `""` when no version tag is set.

#### Why

This properly signals absence instead of leaking an internal empty-string default. It aligns `versionTag` with how other optional fields like `businessId` are handled, simplifying absence-detection logic.

#### Action

<Tabs groupId="audience" defaultValue="sdk" queryString values={[
{label: 'Official SDK users', value: 'sdk'},
{label: 'Generated-client users', value: 'generated'},
{label: 'Custom integrations', value: 'custom'},
]}>

<TabItem value='sdk'>

Update to the latest SDK version. Review any code that checks for an empty string (`""`) to detect a missing version tag, and update it to check for `null`.

</TabItem>
<TabItem value='generated'>

Regenerate your client to pick up the updated nullable annotation. Update absence-detection logic from empty-string checks to null checks.

</TabItem>
<TabItem value='custom'>

Update your response-handling code:

```java title="Before"
if (versionTag != null && !versionTag.isEmpty()) {
    // version tag is present
}
```

```java title="After"
if (versionTag != null) {
    // version tag is present
}
```

</TabItem>
</Tabs>

### Search filter validation errors now return structured error collections {#search-filter-validation-errors}

#### Change

REST API search endpoints now collect all filter validation errors and return them together in a single `400 Bad Request` response. Previously, only the first conversion error was returned.

#### Why

This is a bug fix that improves error handling consistency across the REST API. Collecting all validation errors in a single response makes debugging easier.

#### Impact

Search filter validation error responses now contain a list of all validation issues instead of stopping at the first error. The error detail format has changed:

| Aspect                 | Before                                   | After                                                                                                    | Breaking?                              |
| :--------------------- | :--------------------------------------- | :------------------------------------------------------------------------------------------------------- | :------------------------------------- |
| HTTP status code       | `400`                                    | `400`                                                                                                    | No                                     |
| ProblemDetail `title`  | `"Bad Request"`                          | `"INVALID_ARGUMENT"`                                                                                     | Yes                                    |
| ProblemDetail `detail` | `"Failed to parse date-time: [invalid]"` | `"The provided evaluationDate 'invalid' cannot be parsed as a date according to RFC 3339, section 5.6."` | Yes                                    |
| Error collection       | Fails on first error                     | Collects all validation errors                                                                           | Yes (response may contain more errors) |

Affected search endpoints include all endpoints that accept advanced search filters with key fields (such as `processInstanceKey`, `processDefinitionKey`, `scopeKey`) or date fields (such as `startDate`, `endDate`, `creationDate`).

**Who is affected?**

- Customers parsing error response bodies (specifically `title` or `detail` fields) for validation errors → **affected**.
- Customers only checking HTTP status codes → **not affected**.
- Customers sending valid requests → **not affected** (happy path is unchanged).

#### Action

If your code parses error response bodies from search endpoints for specific validation error messages, update it to handle:

- The `title` field value changed from `"Bad Request"` to `"INVALID_ARGUMENT"`.
- The `detail` field now contains more descriptive, structured messages.
- A collection of validation errors in the response body (instead of a single error message).

### Type-safe pagination model in the Camunda Java client {#type-safe-pagination}

#### Change

The Camunda Java client now uses type-safe pagination interfaces (`AnyPage`, `OffsetPage`, `CursorForwardPage`, `CursorBackwardPage`) instead of the previous `SearchRequestPage` class. Each search or statistics endpoint exposes only the pagination methods it actually supports.

Direction methods on `AnyPage` now return style-specific interfaces: `from()` returns `OffsetPage`, `after()` returns `CursorForwardPage`, and `before()` returns `CursorBackwardPage`. This prevents mixing incompatible pagination styles at compile time.

#### Why

The previous API allowed mixing incompatible pagination styles (for example, `.page(p -> p.from(10).after("cursor"))`), which always resulted in a `400 Bad Request` at runtime. This change surfaces that restriction at compile time. The pattern mirrors the existing sort polymorphism design (`TypedSortableRequest`).

#### Impact

This change is **not binary-compatible**. Code compiled against the previous API will fail at runtime without recompilation, because the method signature changed from `page(Consumer<SearchRequestPage>)` to `page(Consumer<AnyPage>)`. All users must recompile their applications.

Additionally, `TypedSearchRequest` now has 4 generic type parameters (previously 3) and `TypedPageableRequest` now has 2 (previously 1), which is a source-breaking change for custom implementations of these interfaces.

#### Migration reference

| Before (8.8)                                       | After (8.9)                                                 |
| :------------------------------------------------- | :---------------------------------------------------------- |
| `import ...search.request.SearchRequestPage`       | `import ...search.page.AnyPage`                             |
| `import ...search.request.SearchRequestOffsetPage` | `import ...search.page.OffsetPage`                          |
| `Consumer<SearchRequestPage>`                      | `Consumer<AnyPage>`                                         |
| `Consumer<SearchRequestOffsetPage>`                | `Consumer<OffsetPage>`                                      |
| `SearchRequestBuilders.searchRequestPage(fn)`      | `SearchRequestBuilders.anyPage(fn)` (old method deprecated) |
| `implements TypedSearchRequest<F, S, Self>`        | `implements TypedSearchRequest<F, S, AnyPage, Self>`        |
| `implements TypedPageableRequest<Self>`            | `implements TypedPageableRequest<AnyPage, Self>`            |
| `SearchRequestPage r = p.from(10)`                 | `OffsetPage r = p.from(10)`                                 |
| `SearchRequestPage r = p.after("c")`               | `CursorForwardPage r = p.after("c")`                        |

#### Action

Update to the latest Java client version and **recompile your application**. If you use inline lambdas with valid pagination patterns (for example, `.page(p -> p.from(5).limit(10))`), your source code does not require changes — but recompilation is mandatory.

If you have explicit references to `SearchRequestPage`, replace them with `AnyPage`. If you store the return value of direction methods (for example, `SearchRequestPage r = p.from(10)`), update the variable type to `OffsetPage`, `CursorForwardPage`, or `CursorBackwardPage` as appropriate.

:::note
This change is specific to the Camunda Java client. Generated clients and custom REST API integrations are not affected.
:::

## Deprecations

Review the actions required for the following deprecations:

### Deprecated: enum literals in Orchestration Cluster API v2 {#deprecated-enum}

The following enum literals are now marked as deprecated:

- `UNSPECIFIED` in `DecisionDefinitionTypeEnum`
- `UNKNOWN` in `DecisionInstanceStateFilterProperty`
- `UNKNOWN` in `DecisionInstanceStateEnum`

These values were reintroduced to preserve backward compatibility but are planned for removal in a future release. Removal will be signaled as a breaking change at that time.

#### Action

Avoid using these values in new integrations. If your code references them, plan to remove these references before the 8.10 release.

## Next steps

Once you have completed the [upgrade steps](#upgrade-steps) in this guide, you should:

1. Re-compile and run your test suite against the 8.9 API.
1. Review [8.9 release announcements](/reference/announcements-release-notes/890/890-announcements.md) for additional context on each change.

---

## Migrate to the Orchestration Cluster API

<PageDescription />

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide is retained to help customers migrate before upgrading from 8.9 to 8.10. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

This guide covers how to migrate to the V2 [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) before upgrading to Camunda 8.10, where the V1 component REST APIs are removed. It covers all public endpoints in the component REST APIs and their Orchestration Cluster API counterparts or required migration changes.

- Camunda is streamlining the developer experience by creating a unified REST API for Zeebe, Operate, Tasklist, and the Identity components with endpoint parity. This is the single Orchestration Cluster REST API.
- Individual component APIs (starting with the former Operate and Tasklist APIs) were deprecated before their removal in 8.10. Use this guide to complete the migration before upgrading.

:::info
To learn more about the unified REST API, see [the official blog announcement](https://camunda.com/blog/2024/12/api-changes-in-camunda-8-a-unified-and-streamlined-experience/).
:::

:::note
The Administration and Web Modeler APIs are not part of the Orchestration Cluster REST API, as these are platform APIs outside the cluster’s scope.
:::

## Migration steps

To successfully migrate to the V2 Orchestration Cluster API, perform the following steps:

1. **Identify your current V1 endpoints**: Audit your application to catalog all V1 API calls currently in use.
1. **Map V1 endpoints to V2 equivalents**: Use the tables in this guide to find the corresponding V2 endpoints for each request.
1. **Update request and response structure**: Adapt your code to handle the new formats, renamed attributes, and data type changes as outlined in this guide.
1. **Update pagination logic**: Replace old pagination parameters with the new `page` object structure and cursor-based navigation.

## General endpoint changes

<Tabs groupId="endpoints" defaultValue="all-endpoints" queryString values={
[
{label: 'All endpoints', value: 'all-endpoints', },
{label: 'Endpoints querying for data', value: 'query-endpoints', },
]
}>

<TabItem value='all-endpoints'>

- The new API can be found at `<cluster>/v2/…>` instead of `<cluster>/v1/…>`.
- All endpoints are no longer separated by component concerns and all endpoints receive similar support. For example, process definitions, user tasks, and user authorizations were previously spread across separate Tasklist, Operate, and Identity APIs.
- All endpoints support the [authorization-based access control model](../../components/concepts/access-control/authorizations.md). Component endpoints only support the configuration of full (wildcard) access or no access.
- Naming, response codes, and type handling have been streamlined for all endpoints to provide a consistent UX.
- Endpoints with similar concerns (variable search, for example) have been consolidated into single endpoints.
- The request and response payload of every new endpoint might contain new attributes that are not necessarily needed for a migration from a V1 endpoint to V2 but might still be useful. Please consult the V2 API guides for access to all new attributes.

</TabItem>

<TabItem value='query-endpoints'>

- Unified search request structure.
  - Attributes `filter`, `page`, and `sort` on root level.
  - Endpoint-specific filter attributes in the filter object, not at the root level.
  - Pagination information in the `page` object. For example, the attributes `from`, `limit`, `before`, and `after`.
  - Sorting configuration in sort object array, each object containing the field name and order (descending or ascending).

- Unified search response structure.
  - Attributes `items` and `page` on root level.
  - List of endpoint-specific response items in `items` attribute.
  - Page information in `page` attribute, for example the attributes `totalItems`, `startCursor`, and `endCursor` to use in `before` and `after` in follow-up requests.

</TabItem>

</Tabs>

<!--- TBD since currently in progress: Filter attributes can use Advanced Search capabilities depending on their type. TBD: We need to see how much of this we manage to implement with 8.7 (which endpoints, which attributes, which types). --->

## Name changes and mappings

The following table shows key attribute name changes from V1 to V2:

| **V1**           | **V2**                  | **Notes**                                                                           |
| ---------------- | ----------------------- | ----------------------------------------------------------------------------------- |
| `id`             | `[entity]Id`            | Keys now include entity prefix (for example, `userTaskKey`, `processDefinitionId`). |
| `key`            | `[entity]Key`           | Converted from `int64` to `string` with entity prefix.                              |
| `bpmnProcessId`  | `processDefinitionId`   | Unified naming convention.                                                          |
| `processName`    | `processDefinitionId`   | Unified naming convention.                                                          |
| `decisionKey`    | `decisionDefinitionKey` | Unified naming convention.                                                          |
| `dmnDecisionKey` | `decisionDefinitionKey` | Unified naming convention.                                                          |
| `decisionId`     | `decisionDefinitionId`  | Unified naming convention.                                                          |
| `dmnDecisionId`  | `decisionDefinitionId`  | Unified naming convention.                                                          |

**General naming conventions:**

- Keys and IDs contain the full entity name as prefix to avoid confusion (for example, `processDefinitionKey` instead of `processKey`).
- Entity attributes have no prefix within their own entity, but use prefixes when referenced from other entities.
- All key fields are now `string` type instead of `int64`.

<!--- Insert Operate section with V1 endpoint and V2 endpoint to use with input/output adjustments --->

## Tasklist REST API

### Form

#### Get a form

V1
V2

GET `/v1/forms/{formId}`

GET [`/v2/user-tasks/{userTaskKey}/form`](../orchestration-cluster-api-rest/specifications/get-user-task-form.api.mdx)
GET [`/v2/process-definitions/{processDefinitionKey}/form`](../orchestration-cluster-api-rest/specifications/get-start-process-form.api.mdx)

<Tabs groupId="get-form" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- You cannot fetch forms directly anymore. Instead, fetch them by user task or process definition to get the respective form data.
- The respective endpoint only takes the key of the resource the form is related to as input parameter.

</TabItem>

<TabItem value='output-adjustments'>

Embedded forms are no longer returned as Camunda user tasks don't support them.

| **Field**              | **Change Type** | **Notes**                                                   |
| ---------------------- | --------------- | ----------------------------------------------------------- |
| `id`                   | Renamed         | Now `formKey` (unique system identifier of the form).       |
| `title`                | Renamed         | Now `formId` (aligns with form schema attribute).           |
| `isDeleted`            | Removed         | No longer provided by endpoint.                             |
| `processDefinitionKey` | Removed         | Can be identified from endpoint resource and key parameter. |

</TabItem>
</Tabs>

### Task

#### Save task draft variables

V1
V2

POST `/v1/tasks/{taskId}/variables`

This feature is not supported in V2 anymore. Use [setting variables][] as `local` to the user task's `elementInstanceKey` as a replacement.

#### Search task variables

V1
V2

POST `/v1/tasks/{taskId}/variables/search`

POST [`/v2/user-tasks/{userTaskKey}/variables/search`](../orchestration-cluster-api-rest/specifications/search-user-task-variables.api.mdx)

<Tabs groupId="search-vars-by-task" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**          | **Change Type** | **Notes**                                                                    |
| ------------------ | --------------- | ---------------------------------------------------------------------------- |
| `variableNames`    | Renamed         | Now `name` in `filter` object (plain string or `{ "$in": [ "xyz", ... ] }`). |
| `includeVariables` | Removed         | Endpoint returns all variables associated with the user task.                |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**          | **Change Type** | **Notes**                                                                |
| ------------------ | --------------- | ------------------------------------------------------------------------ |
| `id`               | Renamed         | Now `variableKey` (unique system identifier of the variable).            |
| `previewValue`     | Renamed         | Now `value` (always represents variable value, may be truncated).        |
| `isValueTruncated` | Renamed         | Now `isTruncated` (see get variable endpoint for full value if needed).  |
| `draft`            | Removed         | Draft variables not supported in V2 (see save draft variables endpoint). |

For completed tasks, the V1 API returned snapshot variable values as they existed at completion time. The V2 API always returns the current runtime value of variables.

</TabItem>
</Tabs>

#### Search tasks

V1
V2

POST `/v1/tasks/search`

POST [`/v2/user-tasks/search`](../orchestration-cluster-api-rest/specifications/search-user-tasks.api.mdx)

<Tabs groupId="tasklist" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments', },
{label: 'Output adjustments', value: 'output-adjustments', },
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**                 | **Change Type** | **Notes**                                                       |
| ------------------------- | --------------- | --------------------------------------------------------------- |
| `pageSize`                | Renamed         | Now `limit` in the `page` object.                               |
| `searchAfter`             | Renamed         | Now `after` in the `page` object.                               |
| `searchBefore`            | Renamed         | Now `before` in the `page` object.                              |
| `taskDefinitionId`        | Renamed         | Now `elementId` (user-provided identifier of the BPMN element). |
| `assigned`                | Renamed         | Now `assignee` with `{ "$exists": false }`.                     |
| `assignees`               | Renamed         | Now `assignee` with `{ "$in": [ "xyz", ... ] }`.                |
| `candidateGroups`         | Renamed         | Now `candidateGroup` with `{ "$in": [ "xyz", ... ] }`.          |
| `candidateUsers`          | Renamed         | Now `candidateUser` with `{ "$in": [ "xyz", ... ] }`.           |
| `tenantIds`               | Renamed         | Now `tenantId` with `{ "$in": [ "xyz", ... ] }`.                |
| `followUpDate`, `dueDate` | Changed         | Use `$gte` and `$lte` instead of `from` and `to`.               |
| `priority`                | Changed         | Filter keys need `$` prefix, supports new comparison options.   |
| `taskVariables`           | Split           | Now `localVariables` and `processInstanceVariables`.            |
| `searchAfterOrEqual`      | Removed         | No longer supported.                                            |
| `searchBeforeOrEqual`     | Removed         | No longer supported.                                            |
| `includeVariables`        | Removed         | Use separate search task variables endpoint.                    |
| `implementation`          | Removed         | V2 API supports only Camunda user tasks.                        |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**          | **Change Type** | **Notes**                                                                             |
| ------------------ | --------------- | ------------------------------------------------------------------------------------- |
| `sortValues`       | Removed         | No longer exist per result item - use `startCursor` and `endCursor` in `page` object. |
| `id`               | Renamed         | Now `userTaskKey` (unique system identifier of the user task).                        |
| `taskDefinitionId` | Renamed         | Now `elementId` (user-provided identifier of the BPMN element).                       |
| `taskState`        | Renamed         | Now `state` (user task's current state).                                              |
| `processName`      | Renamed         | Now `processDefinitionId` (user-provided identifier of the process).                  |
| `formKey`          | Changed         | Now unique system identifier referencing linked Camunda form in specific version.     |
| `isFirst`          | Removed         | No longer identifies if task was first in process.                                    |
| `variables`        | Removed         | Use search user task variables endpoint.                                              |
| `implementation`   | Removed         | V2 API supports only Camunda user tasks.                                              |
| `isFormEmbedded`   | Removed         | V2 API does not support embedded forms.                                               |
| `formVersion`      | Removed         | Use get user task form endpoint.                                                      |
| `formId`           | Removed         | Use get user task form endpoint.                                                      |

</TabItem>

</Tabs>

#### Unassign a task

V1
V2

PATCH `/v1/tasks/{taskId}/unassign`

DELETE [`/v2/user-tasks/{userTaskKey}/assignee`](../orchestration-cluster-api-rest/specifications/unassign-user-task.api.mdx)

<Tabs groupId="unassign-user-task" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Response object removed - The V2 API returns a 204 status, indicating that the task was unassigned. Fetching the updated data of the user task should be done through the respective API since the data can change concurrently at any time.

</TabItem>
</Tabs>

#### Complete a task

V1
V2

PATCH `/v1/tasks/{taskId}/complete`

POST [`/v2/user-tasks/{userTaskKey}/completion`](../orchestration-cluster-api-rest/specifications/complete-user-task.api.mdx)

<Tabs groupId="complete-user-task" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- Adjusted attributes
  - `variables` - Provide the variables as a proper JSON object instead of an array of objects with a `name` and a serialized JSON string `value`.

</TabItem>

<TabItem value='output-adjustments'>

- Response object removed - The V2 API returns a 204 status, indicating that the task was completed. Fetching the updated data of the user task should be done through the respective API since the data can change concurrently at any time.

</TabItem>
</Tabs>

#### Assign a task

V1
V2

PATCH `/v1/tasks/{taskId}/assign`

POST [`/v2/user-tasks/{userTaskKey}/assignment`](../orchestration-cluster-api-rest/specifications/assign-user-task.api.mdx)

<Tabs groupId="assign-user-task" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- Renamed attributes
  - `allowOverrideAssignment` - Use `allowOverride`, this still refers to allowing to override any existing assignee.

</TabItem>

<TabItem value='output-adjustments'>

- Response object removed - The V2 API returns a 204 status, indicating that the task was assigned. Fetching the updated data of the user task should be done through the respective API since the data can change concurrently at any time.

</TabItem>
</Tabs>

#### Get a task

V1
V2

GET `/v1/tasks/{taskId}`

GET [`/v2/user-tasks/{userTaskKey}`](../orchestration-cluster-api-rest/specifications/get-user-task.api.mdx)

<Tabs groupId="get-user-task" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search tasks](#search-tasks) apply.

</TabItem>
</Tabs>

### Variables

#### Get a variable

V1
V2

GET `/v1/variables/{variableId}`

GET [`/v2/variables/{variableKey}`](../orchestration-cluster-api-rest/specifications/get-variable.api.mdx)

<Tabs groupId="get-a-variable" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- `variableId` - Use `variableKey` as this refers to the unique system identifier of the variable.

</TabItem>

<TabItem value='output-adjustments'>

- Renamed attributes
  - `id` - Use `variableKey` as this refers to the unique system identifier of the variable.
- Removed attributes
  - `draft` - Draft variables are not supported in V2 anymore, see also the [save draft variables](#save-task-draft-variables) endpoint for further details.

</TabItem>
</Tabs>

## Operate REST API

### Decision definition

#### Search decision definitions

V1
V2

POST `/v1/decision-definitions/search`

POST [`/v2/decision-definitions/search`](../orchestration-cluster-api-rest/specifications/search-decision-definitions.api.mdx)

<Tabs groupId="search-decision-definitions" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**                     | **Change Type** | **Notes**                                                       |
| ----------------------------- | --------------- | --------------------------------------------------------------- |
| `searchAfter`                 | Renamed         | Now `after` in the `page` object.                               |
| `size`                        | Renamed         | Now `limit` in the `page` object.                               |
| `id`                          | Renamed         | Now `decisionDefinitionKey` in filter object.                   |
| `key`                         | Renamed         | Now `decisionDefinitionKey` (changed from `int64` to `string`). |
| `decisionId`                  | Renamed         | Now `decisionDefinitionId` in filter object.                    |
| `decisionRequirementsKey`     | Changed         | Now `string` type instead of `int64`.                           |
| `decisionRequirementsName`    | Removed         | Can no longer be used for filtering.                            |
| `decisionRequirementsVersion` | Removed         | Can no longer be used for filtering.                            |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**                     | **Change Type** | **Notes**                                                       |
| ----------------------------- | --------------- | --------------------------------------------------------------- |
| `total`                       | Moved           | Now `totalItems` in `page` object.                              |
| `sortValues`                  | Replaced        | Now use `endCursor` in `page` object.                           |
| `id`                          | Renamed         | Now `decisionDefinitionKey`.                                    |
| `key`                         | Renamed         | Now `decisionDefinitionKey` (changed from `int64` to `string`). |
| `decisionId`                  | Renamed         | Now `decisionDefinitionId`.                                     |
| `decisionRequirementsKey`     | Changed         | Now `string` type instead of `int64`.                           |
| `decisionRequirementsName`    | Removed         | Fetch using get decision requirements endpoint.                 |
| `decisionRequirementsVersion` | Removed         | Fetch using get decision requirements endpoint.                 |

</TabItem>
</Tabs>

#### Get decision definition by key

V1
V2

GET `/v1/decision-definitions/{key}`

GET [`/v2/decision-definitions/{decisionDefinitionKey}`](../orchestration-cluster-api-rest/specifications/get-decision-definition.api.mdx)

<Tabs groupId="get-decision-definition" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search decision definitions](#search-decision-definitions) apply.

</TabItem>
</Tabs>

#### Search decision instances

V1
V2

POST `/v1/decision-instances/search`

POST [`/v2/decision-instances/search`](../orchestration-cluster-api-rest/specifications/search-decision-instances.api.mdx)

<Tabs groupId="search-decision-instances" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**              | **Change Type** | **Notes**                                                     |
| ---------------------- | --------------- | ------------------------------------------------------------- |
| `searchAfter`          | Renamed         | Now `after` in the `page` object.                             |
| `size`                 | Renamed         | Now `limit` in the `page` object.                             |
| `id`                   | Renamed         | Now `decisionInstanceId` in filter object.                    |
| `key`                  | Renamed         | Now `decisionInstanceKey` (changed from `int64` to `string`). |
| `processDefinitionKey` | Changed         | Now `string` type instead of `int64`.                         |
| `processInstanceKey`   | Changed         | Now `string` type instead of `int64`.                         |
| `decisionId`           | Renamed         | Now `decisionDefinitionId`.                                   |
| `decisionName`         | Renamed         | Now `decisionDefinitionName`.                                 |
| `decisionVersion`      | Renamed         | Now `decisionDefinitionVersion`.                              |
| `decisionType`         | Renamed         | Now `decisionDefinitionType`.                                 |
| `result`               | Removed         | Can no longer be used for filtering.                          |
| `evaluatedInputs`      | Removed         | Can no longer be used for filtering.                          |
| `evaluatedOutputs`     | Removed         | Can no longer be used for filtering.                          |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**              | **Change Type** | **Notes**                                                     |
| ---------------------- | --------------- | ------------------------------------------------------------- |
| `total`                | Moved           | Now `totalItems` in `page` object.                            |
| `sortValues`           | Replaced        | Now use `endCursor` in `page` object.                         |
| `id`                   | Renamed         | Now `decisionInstanceId`.                                     |
| `key`                  | Renamed         | Now `decisionInstanceKey` (changed from `int64` to `string`). |
| `processDefinitionKey` | Changed         | Now `string` type instead of `int64`.                         |
| `processInstanceKey`   | Changed         | Now `string` type instead of `int64`.                         |
| `decisionId`           | Renamed         | Now `decisionDefinitionId`.                                   |
| `decisionName`         | Renamed         | Now `decisionDefinitionName`.                                 |
| `decisionVersion`      | Renamed         | Now `decisionDefinitionVersion`.                              |
| `decisionType`         | Renamed         | Now `decisionDefinitionType`.                                 |
| `evaluatedInputs`      | Removed         | No longer provided by endpoint.                               |
| `evaluatedOutputs`     | Removed         | No longer provided by endpoint.                               |

</TabItem>
</Tabs>

#### Get decision instance by id

V1
V2

GET `/v1/decision-instances/{id}`

GET [`/v2/decision-instances/{decisionInstanceId}`](../orchestration-cluster-api-rest/specifications/search-decision-instances.api.mdx)

<Tabs groupId="get-decision-instance-by-id" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

The adjustments from [search decision instances](#search-decision-instances) apply, with the following exceptions: `evaluatedInputs` and `evaluatedOutputs` are present in the response payload (with `evaluatedOutputs` moved under `matchedRules`).

| **Field**                   | **Change Type** | **Notes**                               |
| --------------------------- | --------------- | --------------------------------------- |
| **evaluatedInputs object**  |                 |                                         |
| `id`                        | Renamed         | Now `inputId`.                          |
| `name`                      | Renamed         | Now `inputName`.                        |
| `value`                     | Renamed         | Now `inputValue`.                       |
| **evaluatedOutputs object** |                 |                                         |
| `id`                        | Renamed         | Now `outputId`.                         |
| `name`                      | Renamed         | Now `outputName`.                       |
| `value`                     | Renamed         | Now `outputValue`.                      |
| `ruleId`                    | Moved           | Now under `matchedRules` array objects. |
| `ruleIndex`                 | Moved           | Now under `matchedRules` array objects. |

</TabItem>
</Tabs>

#### Search decision requirements

V1
V2

POST `/v1/drd/search`

POST [`/v2/decision-requirements/search`](../orchestration-cluster-api-rest/specifications/search-decision-requirements.api.mdx)

<Tabs groupId="search-decision-requirements" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**     | **Change Type** | **Notes**                                                         |
| ------------- | --------------- | ----------------------------------------------------------------- |
| `searchAfter` | Renamed         | Now `after` in the `page` object.                                 |
| `size`        | Renamed         | Now `limit` in the `page` object.                                 |
| `id`          | Renamed         | Now `decisionRequirementsKey` in filter object.                   |
| `key`         | Renamed         | Now `decisionRequirementsKey` (changed from `int64` to `string`). |
| `name`        | Renamed         | Now `decisionRequirementsName`.                                   |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**    | **Change Type** | **Notes**                                                         |
| ------------ | --------------- | ----------------------------------------------------------------- |
| `total`      | Moved           | Now `totalItems` in `page` object.                                |
| `sortValues` | Replaced        | Now use `endCursor` in `page` object.                             |
| `id`         | Renamed         | Now `decisionRequirementsKey`.                                    |
| `key`        | Renamed         | Now `decisionRequirementsKey` (changed from `int64` to `string`). |
| `name`       | Renamed         | Now `decisionRequirementsName`.                                   |

</TabItem>
</Tabs>

#### Get decision requirements by key

V1
V2

GET `/v1/drd/{key}`

GET [`/v2/decision-requirements/{decisionRequirementsKey}`](../orchestration-cluster-api-rest/specifications/get-decision-requirements.api.mdx)

<Tabs groupId="get-decision-requirements-by-key" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search decision requirements](#search-decision-requirements) apply.

</TabItem>
</Tabs>

#### Get decision requirements as XML by key

V1
V2

GET `/v1/drd/{key}/xml`

GET [`/v2/decision-requirements/{decisionRequirementsKey}/xml`](../orchestration-cluster-api-rest/specifications/get-decision-requirements-xml.api.mdx)

<Tabs groupId="get-decision-requirements-by-key" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- No output adjustments.

</TabItem>
</Tabs>

### Variable

#### Search variables for process instances

V1
V2

POST `/v1/variables/search`

POST [`/v2/variables/search`](../orchestration-cluster-api-rest/specifications/search-variables.api.mdx)

<Tabs groupId="search-variables-for-process-instances" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**            | **Change Type** | **Notes**                                             |
| -------------------- | --------------- | ----------------------------------------------------- |
| `searchAfter`        | Renamed         | Now `after` in the `page` object.                     |
| `size`               | Renamed         | Now `limit` in the `page` object.                     |
| `key`                | Renamed         | Now `variableKey` (changed from `int64` to `string`). |
| `processInstanceKey` | Changed         | Now `string` type instead of `int64`.                 |
| `scopeKey`           | Changed         | Now `string` type instead of `int64`.                 |
| `truncated`          | Renamed         | Now `isTruncated`.                                    |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**            | **Change Type** | **Notes**                                             |
| -------------------- | --------------- | ----------------------------------------------------- |
| `total`              | Moved           | Now `totalItems` in `page` object.                    |
| `sortValues`         | Replaced        | Now use `endCursor` in `page` object.                 |
| `key`                | Renamed         | Now `variableKey` (changed from `int64` to `string`). |
| `processInstanceKey` | Changed         | Now `string` type instead of `int64`.                 |
| `scopeKey`           | Changed         | Now `string` type instead of `int64`.                 |
| `truncated`          | Renamed         | Now `isTruncated`.                                    |

</TabItem>
</Tabs>

#### Get variable by key

V1
V2

GET `/v1/variables/{key}`

GET [`/v2/variables/{variableKey}`](../orchestration-cluster-api-rest/specifications/get-variable.api.mdx)

<Tabs groupId="get-variable-by-key" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- All adjustments from [search variables for process instances](#search-variables-for-process-instances) apply, with the following exceptions:
  - Response structure changes.
  - `truncated` is removed because this endpoint always returns the full variable value.

</TabItem>
</Tabs>

<!--- TODO: open questions and related resources --->

<!--- TODO: insert link to C8 REST API guidelines --->

[setting variables]: /apis-tools/orchestration-cluster-api-rest/specifications/create-element-instance-variables.api.mdx
[general changes]: #general-endpoint-changes
[multi-tenancy]: /components/concepts/multi-tenancy.md

### Process definition

#### Search process definitions

V1
V2

POST `/v1/process-definitions/search`

POST [`/v2/process-definitions/search`](../orchestration-cluster-api-rest/specifications/search-process-definitions.api.mdx)

<Tabs groupId="search-process-definitions" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**       | **Change Type** | **Notes**                                                      |
| --------------- | --------------- | -------------------------------------------------------------- |
| `searchAfter`   | Renamed         | Now `after` in the `page` object.                              |
| `size`          | Renamed         | Now `limit` in the `page` object.                              |
| `key`           | Renamed         | Now `processDefinitionKey` (changed from `int64` to `string`). |
| `bpmnProcessId` | Renamed         | Now `processDefinitionId`.                                     |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**       | **Change Type** | **Notes**                                                      |
| --------------- | --------------- | -------------------------------------------------------------- |
| `total`         | Moved           | Now `totalItems` in `page` object.                             |
| `sortValues`    | Replaced        | Now use `endCursor` in `page` object.                          |
| `key`           | Renamed         | Now `processDefinitionKey` (changed from `int64` to `string`). |
| `bpmnProcessId` | Renamed         | Now `processDefinitionId`.                                     |

</TabItem>
</Tabs>

#### Get process definition by key

V1
V2

GET `/v1/process-definitions/{key}`

GET [`/v2/process-definitions/{processDefinitionKey}`](../orchestration-cluster-api-rest/specifications/get-process-definition.api.mdx)

<Tabs groupId="get-process-definition" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search process definitions](#search-process-definitions) apply.

</TabItem>
</Tabs>

#### Get process definition as XML by key

V1
V2

GET `/v1/process-definitions/{key}/xml`

GET [`/v2/process-definitions/{processDefinitionKey}/xml`](../orchestration-cluster-api-rest/specifications/get-process-definition-xml.api.mdx)

<Tabs groupId="get-process-definition-xml" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- No output adjustments.

</TabItem>
</Tabs>

### Process instance

#### Search process instances

V1
V2

POST `/v1/process-instances/search`

POST [`/v2/process-instances/search`](../orchestration-cluster-api-rest/specifications/search-process-instances.api.mdx)

<Tabs groupId="search-process-instances" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**                   | **Change Type** | **Notes**                                                    |
| --------------------------- | --------------- | ------------------------------------------------------------ |
| `searchAfter`               | Renamed         | Now `after` in the `page` object.                            |
| `size`                      | Renamed         | Now `limit` in the `page` object.                            |
| `key`                       | Renamed         | Now `processInstanceKey` (changed from `int64` to `string`). |
| `processVersion`            | Renamed         | Now `processDefinitionVersion`.                              |
| `processVersionTag`         | Renamed         | Now `processDefinitionVersionTag`.                           |
| `bpmnProcessId`             | Renamed         | Now `processDefinitionId`.                                   |
| `parentFlowNodeInstanceKey` | Renamed         | Now `parentElementInstanceKey` (changed to `string`).        |
| `parentKey`                 | Renamed         | Now `parentProcessInstanceKey` (changed to `string`).        |
| `state`                     | Changed         | Use `TERMINATED` instead of `CANCELED`.                      |
| `incident`                  | Renamed         | Now `hasIncident`.                                           |
| `parentProcessInstanceKey`  | Changed         | Now `string` type instead of `int64`.                        |
| `processDefinitionKey`      | Changed         | Now `string` type instead of `int64`.                        |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**                   | **Change Type** | **Notes**                                                    |
| --------------------------- | --------------- | ------------------------------------------------------------ |
| `total`                     | Moved           | Now `totalItems` in `page` object.                           |
| `sortValues`                | Replaced        | Now use `endCursor` in `page` object.                        |
| `key`                       | Renamed         | Now `processInstanceKey` (changed from `int64` to `string`). |
| `processVersion`            | Renamed         | Now `processDefinitionVersion`.                              |
| `processVersionTag`         | Renamed         | Now `processDefinitionVersionTag`.                           |
| `bpmnProcessId`             | Renamed         | Now `processDefinitionId`.                                   |
| `parentFlowNodeInstanceKey` | Renamed         | Now `parentElementInstanceKey` (changed to `string`).        |
| `parentKey`                 | Renamed         | Now `parentProcessInstanceKey` (changed to `string`).        |
| `state`                     | Changed         | Use `TERMINATED` instead of `CANCELED`.                      |
| `incident`                  | Renamed         | Now `hasIncident`.                                           |
| `parentProcessInstanceKey`  | Changed         | Now `string` type instead of `int64`.                        |
| `processDefinitionKey`      | Changed         | Now `string` type instead of `int64`.                        |

</TabItem>
</Tabs>

#### Get process instance by key

V1
V2

GET `/v1/process-instances/{key}`

GET [`/v2/process-instances/{processInstanceKey}`](../orchestration-cluster-api-rest/specifications/get-process-instance.api.mdx)

<Tabs groupId="get-process-instance-by-key" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search process instances](#search-process-instances) apply.

</TabItem>
</Tabs>

#### Delete process instance and all dependant data by key

V1
V2

DELETE `/v1/process-instances/{key}`

This feature is not yet available in V2. It will be added in a future version.

#### Get flow node statistic by process instance key

V1
V2

GET `/v1/process-instances/{key}/statistics`

GET [`/v2/process-instances/{processInstanceKey}/statistics/element-instances`](../orchestration-cluster-api-rest/specifications/get-process-instance-statistics.api.mdx)

<Tabs groupId="get-process-instance-statistics" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes.

| **Field**      | **Change Type** | **Notes**               |
| -------------- | --------------- | ----------------------- |
| Response items | Moved           | Now under `items` array |
| `activityId`   | Renamed         | Now `elementId`         |

</TabItem>
</Tabs>

#### Get sequence flows of process instance by key

V1
V2

GET `/v1/process-instances/{key}/sequence-flows`

GET [`/v2/process-instances/{processInstanceKey}/sequence-flows`](../orchestration-cluster-api-rest/specifications/get-process-instance-sequence-flows.api.mdx)

<Tabs groupId="get-process-instance-sequence-flows" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes.

| **Field**      | **Change Type** | **Notes**                                                                         |
| -------------- | --------------- | --------------------------------------------------------------------------------- |
| Response items | Changed         | Now type `object` instead of `string`.                                            |
| Response items | Moved           | Now under `items` array.                                                          |
| V1 recreation  | Info            | Collect `sequenceFlowId` of type `string` from all objects to recreate V1 result. |

</TabItem>
</Tabs>

### Flownode instances

#### Search flownode instances

V1
V2

POST `/v1/flownode-instances/search`

POST [`/v2/element-instances/search`](../orchestration-cluster-api-rest/specifications/search-element-instances.api.mdx)

<Tabs groupId="search-flownode-instances" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**              | **Change Type** | **Notes**                                                    |
| ---------------------- | --------------- | ------------------------------------------------------------ |
| `searchAfter`          | Renamed         | Now `after` in the `page` object.                            |
| `size`                 | Renamed         | Now `limit` in the `page` object.                            |
| `key`                  | Renamed         | Now `elementInstanceKey` (changed from `int64` to `string`). |
| `flowNodeId`           | Renamed         | Now `elementId`.                                             |
| `flowNodeName`         | Renamed         | Now `elementName`.                                           |
| `incident`             | Renamed         | Now `hasIncident`.                                           |
| `processInstanceKey`   | Changed         | Now `string` type instead of `int64`.                        |
| `processDefinitionKey` | Changed         | Now `string` type instead of `int64`.                        |
| `incidentKey`          | Changed         | Now `string` type instead of `int64`.                        |
| `startDate`            | Removed         | Can no longer be used for filtering.                         |
| `endDate`              | Removed         | Can no longer be used for filtering.                         |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**              | **Change Type** | **Notes**                                                    |
| ---------------------- | --------------- | ------------------------------------------------------------ |
| `total`                | Moved           | Now `totalItems` in `page` object.                           |
| `sortValues`           | Replaced        | Now use `endCursor` in `page` object.                        |
| `key`                  | Renamed         | Now `elementInstanceKey` (changed from `int64` to `string`). |
| `flowNodeId`           | Renamed         | Now `elementId`.                                             |
| `flowNodeName`         | Renamed         | Now `elementName`.                                           |
| `incident`             | Renamed         | Now `hasIncident`.                                           |
| `processInstanceKey`   | Changed         | Now `string` type instead of `int64`.                        |
| `processDefinitionKey` | Changed         | Now `string` type instead of `int64`.                        |
| `incidentKey`          | Changed         | Now `string` type instead of `int64`.                        |

</TabItem>
</Tabs>

#### Get flownode instance by key

V1
V2

GET `/v1/flownode-instances/{key}`

GET [`/v2/element-instances/{elementInstanceKey}`](../orchestration-cluster-api-rest/specifications/get-element-instance.api.mdx)

<Tabs groupId="get-flownode-instance-by-key" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search flownode instances](#search-flownode-instances) apply.

</TabItem>
</Tabs>

### Incidents

#### Search incidents

V1
V2

POST `/v1/incidents/search`

POST [`/v2/incidents/search`](../orchestration-cluster-api-rest/specifications/search-incidents.api.mdx)

<Tabs groupId="search-incidents" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

Request structure changes as outlined in [general changes][].

| **Field**              | **Change Type** | **Notes**                                             |
| ---------------------- | --------------- | ----------------------------------------------------- |
| `searchAfter`          | Renamed         | Now `after` in the `page` object.                     |
| `size`                 | Renamed         | Now `limit` in the `page` object.                     |
| `key`                  | Renamed         | Now `incidentKey` (changed from `int64` to `string`). |
| `type`                 | Renamed         | Now `errorType`.                                      |
| `message`              | Renamed         | Now `errorMessage`.                                   |
| `processInstanceKey`   | Changed         | Now `string` type instead of `int64`.                 |
| `processDefinitionKey` | Changed         | Now `string` type instead of `int64`.                 |
| `jobKey`               | Changed         | Now `string` type instead of `int64`.                 |

</TabItem>

<TabItem value='output-adjustments'>

Response structure changes as outlined in [general changes][].

| **Field**              | **Change Type** | **Notes**                                             |
| ---------------------- | --------------- | ----------------------------------------------------- |
| `total`                | Moved           | Now `totalItems` in `page` object.                    |
| `sortValues`           | Replaced        | Now use `endCursor` in `page` object.                 |
| `key`                  | Renamed         | Now `incidentKey` (changed from `int64` to `string`). |
| `type`                 | Renamed         | Now `errorType`.                                      |
| `message`              | Renamed         | Now `errorMessage`.                                   |
| `processInstanceKey`   | Changed         | Now `string` type instead of `int64`.                 |
| `processDefinitionKey` | Changed         | Now `string` type instead of `int64`.                 |
| `jobKey`               | Changed         | Now `string` type instead of `int64`.                 |

</TabItem>
</Tabs>

#### Get incident by key

V1
V2

GET `/v1/incidents/{key}`

GET [`/v2/incidents/{incidentKey}`](../orchestration-cluster-api-rest/specifications/get-incident.api.mdx)

<Tabs groupId="get-incident-by-key" defaultValue="input-adjustments" queryString values={
[
{label: 'Input adjustments', value: 'input-adjustments'},
{label: 'Output adjustments', value: 'output-adjustments'},
]
}>

<TabItem value='input-adjustments'>

- No input adjustments.

</TabItem>

<TabItem value='output-adjustments'>

- Except for the response structure changes, all adjustments from [search incidents](#search-incidents) apply.

</TabItem>
</Tabs>

---

## Migrate to the Camunda Java Client

<PageDescription />

:::note Using Spring Boot?
If you are migrating from the Spring Zeebe SDK, use [migrate to Camunda Spring Boot Starter](migrate-to-camunda-spring-boot-starter.md) instead. This guide covers migrations from the Zeebe Java Client to the Camunda Java Client.
:::

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide remains in the 8.9 documentation for customers who did not perform this migration during their 8.8 upgrade. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

This guide provides an overview of the process for migrating to the Camunda Java Client.

- The [Camunda Java Client](../java-client/getting-started.md) is the official Java library for connecting to Orchestration Cluster, automating processes, and implementing job workers.
- The Zeebe Java Client remains available until Camunda 8.10.

:::tip
Plan and start your migration early to ensure compatibility, access to latest features, and future support.
:::

## Before you begin

- Review project dependencies and identify where `io.camunda.zeebe:zeebe-client-java` is used.
- Catalog code referencing Zeebe classes, interfaces, and APIs (for example, ZeebeClient, Zeebe workers).

## Update Maven/Gradle dependencies

Replace the Zeebe Java Client dependency with the Camunda Java Client dependency in your `pom.xml` or `build.gradle` file.

Maven:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-client-java</artifactId>
  <version>${camunda.version}</version>
</dependency>
```

Gradle:

```groovy
implementation 'io.camunda:camunda-client-java:${camunda.version}'
```

## Update imports

Update all imports statement in your Java files to use the new Camunda Java Client package structure.

Change from:

```java

```

to:

```java

```

## Configuration and environment variable changes

- All old Java client property names are refactored to more general ones. For example, `zeebe.client.tenantId` to `camunda.client.tenantId`.
- Environment variables are also updated accordingly. For example, `ZEEBE_CLIENT_TENANT_ID` to `CAMUNDA_CLIENT_TENANT_ID`.
- The former deprecated `gatewayAddress` property and `usePlainText` have been **removed and superseded by `restAddress` and `grpcAddress` which require explicit URI schemes** (for example, `http://` or `https://`).

## Update client initialization

Update the client initialization code to use the new `CamundaClient` class.

For example, change:

```java
ZeebeClient client = ZeebeClient.newClientBuilder()
    .gatewayAddress("localhost:26500")
    .usePlaintext()
    .build();
```

to:

```java
CamundaClient client = CamundaClient.newClientBuilder()
    .grpcAddress(URI.create("http://localhost:26500"))
    .restAddress(URI.create("http://localhost:8080"))
    .build();
```

:::info

- Refer to the [CamundaClientBuilder documentation](https://javadoc.io/doc/io.camunda/camunda-client-java/latest/io/camunda/client/CamundaClientBuilder.html) for more details on available configuration options.
- The construction for OAuth, Basic Auth, or custom providers remains conceptually the same, but you must ensure you use the classes from the new package. Refer to the [Camunda Java Client bootstrapping](../java-client/getting-started.md#bootstrapping) for more details.

:::

## Renamed API classes and commands

The following API classes have been changed in the Camunda Java Client:

| Old                             | New                               |
| :------------------------------ | :-------------------------------- |
| `ZeebeClientBuilder`            | `CamundaClientBuilder`            |
| `ZeebeClientClouldBuilderStep1` | `CamundaClientClouldBuilderStep1` |
| `ZeebeClientConfiguration`      | `CamundaClientConfiguration`      |
| `ZeebeFuture`                   | `CamundaFuture`                   |

The following commands have been renamed in the Camunda Java Client:

| Old                            | New                            |
| :----------------------------- | :----------------------------- |
| `newClockPinCommand()`         | `newPinClockCommand()`         |
| `newClockResetCommand()`       | `newResetClockCommand()`       |
| `newUserCreateCommand()`       | `newCreateUserCommand()`       |
| `newUserTaskAssignCommand()`   | `newAssignUserTaskCommand()`   |
| `newUserTaskCompleteCommand()` | `newCompleteUserTaskCommand()` |
| `newUserTaskUnassignCommand()` | `newUnassignUserTaskCommand()` |
| `newUserTaskUpdateCommand()`   | `newUpdateUserTaskCommand()`   |

## Protocol and connection: REST vs gRPC selection

Zeebe Java Client used **gRPC by default**. The Camunda Java Client uses **REST by default**. If you want to use gRPC, you need to explicitly set the `grpcAddress` in the client builder and configure `preferRestOverGrpc=false` to make gRPC the default.

To use gRPC, add the following to your client builder:

```java
CamundaClient client = CamundaClient.newClientBuilder()
        .grpcAddress(URI.create("http://localhost:26500"))
        .restAddress(URI.create("http://localhost:8080"))
        .preferRestOverGrpc(false)
    .build();
```

---

## Migrate to Camunda Process Test

<PageDescription />

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide remains in the 8.9 documentation for customers who did not perform this migration during their 8.8 upgrade. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

[Camunda Process Test](/apis-tools/testing/getting-started.md) (CPT) is a library to test your BPMN processes and your process applications.

- It is the successor to Zeebe Process Test (ZPT).
- Starting with version **8.8**, ZPT is deprecated and was removed in version **8.10**. See [release announcement](https://camunda.com/blog/2025/04/camunda-process-test-the-next-generation-testing-library/).

This guide walks you through migrating your existing test cases from ZPT to CPT step-by-step.

### Key differences

There are key differences between ZPT and CPT in both API and behavior, which may increase migration effort depending on your existing test cases.

| Aspect                       | Zeebe Process Test (ZPT)                                                        | Camunda Process Test (CPT)                                                                            |
| :--------------------------- | :------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------- |
| **Underlying engine**        | Uses only Camunda's workflow engine (Zeebe) with access to internal components. | Runs the full Camunda distribution and interacts with the Orchestration Cluster API.                  |
| **Assertions and utilities** | Uses specific naming conventions.                                               | Uses different names to align with the API; not all ZPT assertions/utilities have equivalents in CPT. |
| **Startup time**             | Faster startup.                                                                 | Takes longer to start as it runs the full Orchestration Cluster distribution.                         |

### Key advantages of CPT

- Access to Camunda’s Orchestration Cluster API and Connectors
- Support for Camunda user tasks
- Blocking assertions for asynchronous processing
- Enhanced mocking utilities

## Update your dependency

First, update your Maven dependency.

- **If you use ZPT with Camunda Spring Boot Starter integration**  
  (`artifactId: spring-boot-starter-camunda-test` or `spring-boot-starter-camunda-test-testcontainer`),  
  replace it with **CPT’s Spring integration module**.

- **If you use ZPT without Spring**  
  (`artifactId: zeebe-process-test-extension` or `zeebe-process-test-extension-testcontainer`),  
  replace it with **CPT’s Java module**.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

In your Maven `pom.xml`, add the dependency:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-process-test-spring</artifactId>
  <scope>test</scope>
</dependency>
```

</TabItem>

<TabItem value='java-client'>

In your Maven `pom.xml`, add the dependency:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-process-test-java</artifactId>
  <scope>test</scope>
</dependency>
```

</TabItem>
</Tabs>

## Choose your runtime

Next, choose how you want to run CPT, considering your environment. CPT can be used in two modes:

- CPT with Testcontainers (as equivalent to ZPT with Testcontainers)
- CPT with remote engine (as equivalent to ZPT's embedded runtime)

### ZPT with Testcontainers

If you use ZPT with Testcontainers (
`artifactId: zeebe-process-test-extension-testcontainer` or `spring-boot-starter-camunda-test-testcontainer`), then you can
use CPT's default [Testcontainers runtime](/apis-tools/testing/configuration.md#testcontainers-runtime) without
additional changes.

### ZPT's embedded runtime

If you use ZPT’s embedded runtime (`artifactId: zeebe-process-test-extension` or `spring-boot-starter-camunda-test`),
switch to CPT’s [remote runtime](/apis-tools/testing/configuration.md#remote-runtime). Choose this option only if you
cannot install a Docker-API compatible container runtime (e.g., Docker on Linux or Docker Desktop).

In this mode, CPT connects to a remote runtime, such as a local Camunda 8 Run running on your machine.
Prepare your remote runtime:

1. **Install Camunda 8 Run**  
   Follow the [installation guide](/self-managed/quickstart/developer-quickstart/c8run/install-start.md#install-and-start-camunda-8-run) on your machine.

2. **Enable the management clock endpoint**  
   See [prerequisites](/apis-tools/testing/configuration.md#prerequisites-1):
   - Create an `application.yaml` file in the root `/c8run` directory.
   - Add:
     ```yaml
     zeebe.clock.controlled: true
     ```

3. **Start Camunda 8 Run**.

4. **Switch CPT’s runtime mode** to `remote` in your project configuration.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    runtime-mode: remote
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```
runtimeMode=remote
```

</TabItem>
</Tabs>

## Migrate your process tests

Now, it's time to migrate your process tests.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

First, migrate the general test class structure:

1. **Replace annotations and types**
   - Replace `@ZeebeSpringTest` with `@CamundaSpringProcessTest`
   - Replace the type `ZeebeTestEngine` with `CamundaProcessTestContext`

2. **Remove record stream fields**  
   CPT does not provide direct access to records. Instead, use the SDK to request data from the [API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).

Below is an example of a ZPT test class:

```java

@SpringBootTest
@ZeebeSpringTest
class MyProcessTest {

    @Autowired private CamundaClient client;
    @Autowired private ZeebeTestEngine engine;
    @Autowired private RecordStream recordStream;

    @Test
    void shouldCompleteProcess() {
      // given
      final ProcessInstanceEvent processInstance = client
              .newCreateInstanceCommand()
              .bpmnProcessId("my-process")
              .latestVersion()
              .send()
              .join();

      // when: drive the process forward

      // then
      BpmnAssert.assertThat(processInstance)
              .hasPassedElementsInOrder("start", "task1", "task2", "task3", "end")
              .isCompleted();
    }

}
```

This is the equivalent CPT test class:

```java

@SpringBootTest
@CamundaSpringProcessTest
class MyProcessTest {

    @Autowired private CamundaClient client;
    @Autowired private CamundaProcessTestContext processTestContext;

    @Test
    void shouldCompleteProcess() {
      // given
      final ProcessInstanceEvent processInstance = client
              .newCreateInstanceCommand()
              .bpmnProcessId("my-process")
              .latestVersion()
              .send()
              .join();

      // when: drive the process forward

      // then
      CamundaAssert.assertThat(processInstance)
              .hasCompletedElementsInOrder("start", "task1", "task2", "task3", "end")
              .isCompleted();
    }

}
```

</TabItem>

<TabItem value='java-client'>

First, migrate the general test class structure:

1. **Replace annotations and types**
   - Replace `@ZeebeProcessTest` with `@CamundaProcessTest`
   - Replace the type `ZeebeTestEngine` with `CamundaProcessTestContext`

2. **Remove record stream fields**  
   CPT does not provide direct access to records. Instead, use the SDK to request data from the [API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).

Below is an example of a ZPT test class:

```java

@ZeebeProcessTest
class MyProcessTest {

    private CamundaClient client;
    private ZeebeTestEngine engine;
    private RecordStream recordStream;

    @Test
    void shouldCompleteProcess() {
      // given: the processes are deployed
      final ProcessInstanceEvent processInstance = client
              .newCreateInstanceCommand()
              .bpmnProcessId("my-process")
              .latestVersion()
              .send()
              .join();

      // when: drive the process forward

      // then
      BpmnAssert.assertThat(processInstance)
              .hasPassedElementsInOrder("start", "task1", "task2", "task3", "end")
              .isCompleted();
    }
}
```

This is the equivalent CPT test class:

```java

@CamundaProcessTest
class MyProcessTest {

    private CamundaClient client;
    private CamundaProcessTestContext processTestContext;

    @Test
    void shouldCompleteProcess() {
      // given: the processes are deployed
      final ProcessInstanceEvent processInstance = client
              .newCreateInstanceCommand()
              .bpmnProcessId("my-process")
              .latestVersion()
              .send()
              .join();

      // when: drive the process forward

      // then
      CamundaAssert.assertThat(processInstance)
              .hasCompletedElementsInOrder("start", "task1", "task2", "task3", "end")
              .isCompleted();
    }
}
```

</TabItem>
</Tabs>

Then, review all test methods and migrate the assertions and utilities. See the following sections for detailed
instructions.

### Process instance assertions

ZPT has assertions for a process instance using `BpmnAssert.assertThat()` with the `ProcessInstanceEvent` or the
`ProcessInstanceResult`.

CPT has equivalent assertions using `CamundaAssert.assertThat()`.

```java
// given
ProcessInstanceEvent processInstance = //

// ZPT:
BpmnAssert.assertThat(processInstance).isCompleted();

// CPT:
CamundaAssert.assertThat(processInstance).isCompleted();
```

Some of CPT's assertions have different method names or signatures. Check the following list for the equivalent CPT
assertion:

    
        
            ZPT: BpmnAssert.assertThat(processInstance)
        
        
            CPT: CamundaAssert.assertThat(processInstance)
        
    
    
        <code>isStarted()</code>
        [isCreated()](/apis-tools/testing/assertions.md#iscreated)
    
    
        <code>isActive()</code>
        [isActive()](/apis-tools/testing/assertions.md#isactive)
    
    
        <code>isCompleted()</code>
        [isCompleted()](/apis-tools/testing/assertions.md#iscompleted)
    
    
        <code>isNotCompleted()</code>
        
            Not supported
            <small>
                Instead, use [isActive()](/apis-tools/testing/assertions.md#isactive) or [isTerminated()](/apis-tools/testing/assertions.md#isterminated).
            </small>
        
    
    
        <code>isTerminated()</code>
        [isTerminated()](/apis-tools/testing/assertions.md#isterminated)
    
    
        <code>isNotTerminated()</code>
        
            Not supported
            <small>
                Instead, use [isActive()](/apis-tools/testing/assertions.md#isactive) or [isCompleted()](/apis-tools/testing/assertions.md#iscompleted).
            </small>
        
    
    
        <code>isWaitingAtElements()</code>
        [hasActiveElements()](/apis-tools/testing/assertions.md#hasactiveelements)
    
    
        <code>isWaitingExactlyAtElements()</code>
        [hasActiveElementsExactly()](/apis-tools/testing/assertions.md#hasactiveelementsexactly)
    
    
        <code>isNotWaitingAtElements()</code>
        [hasNoActiveElements()](/apis-tools/testing/assertions.md#hasnoactiveelements)
    
    
        <code>hasPassedElement()</code>
        [hasCompletedElement()](/apis-tools/testing/assertions.md#hascompletedelement)
    
    
        <code>hasPassedElementsInOrder()</code>
        [hasCompletedElementsInOrder()](/apis-tools/testing/assertions.md#hascompletedelementsinorder)
    
    
        <code>hasNotPassedElement()</code>
        [hasNotActivatedElements()](/apis-tools/testing/assertions.md#hasnotactivatedelements)
    
    
        <code>hasVariable()</code>
        [hasVariableNames()](/apis-tools/testing/assertions.md#hasvariablenames)
    
    
        <code>hasVariableWithValue()</code>
        [hasVariable()](/apis-tools/testing/assertions.md#hasvariable)
    
    
        <code>hasAnyIncidents()</code>
        [hasActiveIncidents()](/apis-tools/testing/assertions.md#hasactiveincidents)
    
    
        <code>hasNoIncidents()</code>
        [hasNoActiveIncidents()](/apis-tools/testing/assertions.md#hasnoactiveincidents)
    
    
        <code>isWaitingForMessages()</code>
        [isWaitingForMessage()](/apis-tools/testing/assertions.md#iswaitingformessage)
    
    
        <code>isNotWaitingForMessages()</code>
        [isNotWaitingForMessage()](/apis-tools/testing/assertions.md#isnotwaitingformessage)
    
    
        <code>hasCorrelatedMessageByName()</code>
        [hasCorrelatedMessage()](/apis-tools/testing/assertions.md#hascorrelatedmessage)
    
    
        <code>hasCorrelatedMessageByCorrelationKey()</code>
        [hasCorrelatedMessage()](/apis-tools/testing/assertions.md#hascorrelatedmessage)
    
    
        <code>hasCalledProcess()</code>
        
            Not supported
            <small>
                Instead, use a [ProcessInstanceSelector](/apis-tools/testing/assertions.md#with-process-instance-selector) to assert the child process instance.
            </small>
        
    
    
        <code>hasNotCalledProcess()</code>
        
            Not supported
            <small>
                Instead, assert the call activity or the child process instance.
            </small>
        
    

### Deployment assertions

ZPT has assertions for a deployment using `BpmnAssert.assertThat()` with the `DeploymentEvent`.

CPT has no equivalent assertions. Instead, you could write
a [custom assertion](/apis-tools/testing/assertions.md#custom-assertions) with AssertJ to verify the properties of the
deployment event.

```java
// given
DeploymentEvent deploymentEvent = //

// ZPT:
BpmnAssert.assertThat(deploymentEvent).containsProcessesByResourceName("my-process.bpmn");

// CPT:
Assertions.assertThat(deploymentEvent.getProcesses())
    .extracting(Process::getResourceName)
    .contains("my-process.bpmn");
```

### Job assertions

ZPT has assertions for an activated job using `BpmnAssert.assertThat()` with the `ActivatedJob`.

CPT has no equivalent assertions. Instead, you could write
a [custom assertion](/apis-tools/testing/assertions.md#custom-assertions) with AssertJ to verify the properties of the
activated job.

```java
// given
ActivatedJob activatedJob = //

// ZPT:
BpmnAssert.assertThat(activatedJob).hasElementId("elementId");

// CPT:
Assertions.assertThat(activatedJob.getElementId()).isEqualTo("elementId");
```

### Message assertions

ZPT has assertions for a published message using `BpmnAssert.assertThat()` with the `PublishMessageResponse`.

CPT has no equivalent assertions. Instead, you could use
a [ProcessInstanceSelector](/apis-tools/testing/assertions.md#with-process-instance-selector) to find the correlated
process instance and verify the correlation using
a [message subscription assertion](/apis-tools/testing/assertions.md#hascorrelatedmessage).

Alternatively, you could use
the [correlate message API](/apis-tools/orchestration-cluster-api-rest/specifications/correlate-message.api.mdx) that
returns the process instance key in the response.

```java
// ZPT:
final PublishMessageResponse publishMessageResponse = //

BpmnAssert.assertThat(publishMessageResponse)
    .hasCreatedProcessInstance()
    .extractingProcessInstance()
    .isCompleted();

// CPT:
final CorrelateMessageResponse correlateMessageResponse = //

// The correlate command would fail if the message could not be correlated
CamundaAssert.assertThatProcessInstance(byKey(correlateMessageResponse.getProcessInstanceKey()))
    .isCompleted();
```

### Inspection utilities

ZPT provides the `InspectionUtility` to locate process instances and pass them to assertions. Some assertions also include methods to extract related entities, such as `extractingProcessInstance()` or `extractingLatestIncident()`.

CPT offers a similar utility via the [ProcessInstanceSelector](/apis-tools/testing/assertions.md#with-process-instance-selector), which can be used with `CamundaAssert.assertThatProcessInstance()`. For other entities, you can use the Camunda client to search for the entity and implement a [custom assertion](/apis-tools/testing/assertions.md#custom-assertions).

```java
// ZPT:
InspectedProcessInstance childProcessInstance = InspectionUtility.findProcessInstances()
    .withBpmnProcessId("child-process")
    .findFirstProcessInstance()
    .get();

BpmnAssert.assertThat(childProcessInstance).isCompleted();

// CPT:
CamundaAssert.assertThatProcessInstance(byProcessId("child-process"))
    .isCompleted();
```

### ZeebeTestEngine utilities

ZPT provides the `ZeebeTestEngine` utilities to interact with the runtime, for example, to advance time.

CPT offers a similar utility via the [CamundaProcessTestContext](/apis-tools/testing/utilities.md), but the following utilities are **not supported**:

- `waitForIdleState(duration)`
- `waitForBusyState(duration)`

CPT does not require these utilities because it provides [blocking assertions](/apis-tools/testing/assertions.md) that wait until the expected condition is fulfilled.

```java
// ZPT
engine.waitForIdleState(duration);
engine.increaseTime(Duration.ofDays(1));

// CPT:
assertThat(processInstance).hasActiveElements("timer_event");

processTestContext.increaseTime(Duration.ofDays(1));
```

## Next steps

Congratulations! Your process tests should now be fully migrated to CPT and running successfully.

When you’re ready, take the next steps to continue your journey:

- Explore new [assertions](/apis-tools/testing/assertions.md).
- Simplify your tests with new [utilities](/apis-tools/testing/utilities.md).
- Generate [process test coverage reports](/apis-tools/testing/getting-started.md#process-test-coverage).
- Refer to the [API documentation](https://javadoc.io/doc/io.camunda/camunda-process-test-java/latest/io/camunda/process/test/api/package-summary.html) for details.

## Troubleshooting

If you encounter issues with the migration or notice missing features, please report them in the [Camunda GitHub repository](https://github.com/camunda/camunda/issues).

---

## Migrate to Camunda Spring Boot Starter

<PageDescription />

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide remains in the 8.9 documentation for customers who did not perform this migration during their 8.8 upgrade. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

This guide provides an overview of the process for migrating to the Camunda Spring Boot Starter.

- The [Camunda Spring Boot Starter](../camunda-spring-boot-starter/getting-started.md) is the official Spring library for connecting to Orchestration Cluster, automating processes, and implementing job workers.

:::tip
Plan and start your migration early to ensure compatibility, access to latest features, and future support.
:::

## Maven/Gradle dependencies

Replace the Zeebe Spring SDK dependency with the Camunda Spring Boot Starter dependency in your `pom.xml` or `build.gradle` file.

Maven:

```xml
<dependency>
    <groupId>io.camunda</groupId>
    <artifactId>camunda-spring-boot-starter</artifactId>
    <version>8.8.x</version>
</dependency>
```

Gradle:

```groovy
implementation 'io.camunda:camunda-spring-boot-starter:${8.8.x}'
```

## Deprecated classes and methods

Please refer to the [Camunda Java Client migration guide](migrate-to-camunda-java-client.md) for details on deprecated classes and methods.

---

## Migrate to Camunda user tasks

<PageDescription />

:::note Have you already migrated?
You do not need to perform this migration again if you already did this when upgrading to version 8.8. This guide remains in the 8.9 documentation for customers who did not perform this migration during their 8.8 upgrade. See [API and SDK changes to migrate before Camunda 8.10](../migration-manuals/migrate-to-89.md#api-and-sdk-changes-to-migrate-before-camunda-810).
:::

## About

Camunda 8.7 introduced a new [user task](/components/modeler/bpmn/user-tasks/user-tasks.md) implementation type: Camunda user task ([formerly named Zeebe user task](/reference/announcements-release-notes/870/870-release-notes.md#zeebe-user-tasks-modeling-migration-support-saasself-managedmodeler)).

Camunda user tasks have several benefits compared to Job worked-based user tasks, including:

- Running directly on the automation engine for high performance.
- Removing dependencies and round trips to Tasklist.
- A powerful API that supports the full task lifecycle.

In this guide, you will learn:

- Under which circumstances and when you should migrate.
- How to estimate the impact on a project.
- Steps you need to take for a successful migration without interrupting your operations.

## Decide on your migration path

Camunda user tasks require migration of the user tasks in both your diagrams and the task API.

With this in mind, you can migrate at your own pace. If you should migrate now or later, and what is required to migrate depends on your current setup and future plans.

### Task type differences

To make an informed decision, you should understand the differences between both task types and the new capabilities of Camunda user tasks. Refer to this table for important high-level differences between the two task types:

    
        
        
            Camunda user tasks
            <TableTextSmall>Recommended for new and existing projects</TableTextSmall>
        
        
            Job worker-based user tasks
            <TableTextSmall>Existing implementation</TableTextSmall>
        
    
    
        Implementation location
        
            Zeebe
            <TableTextSmall>Does not require Tasklist to run</TableTextSmall>
        
        Tasklist
    
    
        Compatible versions
        8.5 +
        8.0 +
    
    
        Supports Tasklist UI
        <YesItem />
        <YesItem />
    
    
        API
    
    
        Supports Orchestration Cluster REST API
        
            <YesItem />
            <TableTextSmall>Full support</TableTextSmall>
        
        <NoItem />
    
    
        Supports Tasklist API (deprecated)
        
            Partially
            <TableTextSmall>Queries, GET tasks, forms, variables</TableTextSmall>
            <TableTextSmall>ℹ  You must use Zeebe and Tasklist APIs to manage Camunda user tasks</TableTextSmall>
        
        
            <YesItem />
            <TableTextSmall>Full support</TableTextSmall>
        
    
    
        Supports job workers
        <NoItem />
        <YesItem />
    
    
        Supports task lifecycle events
        
            <YesItem />
            <TableTextSmall>Full lifecycle events including custom actions</TableTextSmall>
        
        
            <NoItem />
            <TableTextSmall>Basic only: created/completed/canceled</TableTextSmall>
        
    
    
        Supports task listeners
        
            <YesItem />
        
        <NoItem />
    
    
        Extras
    
    
        Custom actions/outcomes
        
            <YesItem />
            <TableTextSmall>Custom actions can be defined on any operation excluding unassign (DELETE assignment, send update beforehand)</TableTextSmall>
        
        <NoItem />
    
    
        Supports task reports in Optimize
        <YesItem />
        <NoItem />
    
    
        Recommendations
        
            <TableTextSmall>Recommended for existing and new projects when you run Tasklist.</TableTextSmall>
            <TableTextSmall>Migrate existing projects and task applications/clients to this task type when you require one of the features above, or the following use cases:</TableTextSmall>
            <TableTextSmall>
                
                    Implement a full task lifecycle
                    React on any change/events in tasks, such as assignments, escalations, due date updates, or any custom actions
                    Send notifications
                    Track task or team performance
                    Build an audit log on task events
                    Enrich tasks with business data
                
            </TableTextSmall>
        
        
            <TableTextSmall>You can continue to use this task type on existing projects when you have a custom task application running on it and do not require any of the above features.</TableTextSmall>
        
    

## Change the implementation type of user tasks

We recommend you migrate process-by-process, allowing you to thoroughly test the processes in your test environments or via your [CI/CD](/components/hub/workspace/modeler/integrate-modeler-in-ci-cd.md). To do this, take the following steps:

1. Open a diagram you want to migrate.
2. Click on a user task.
3. Check if the task has an embedded form.
   - If a form is embedded, [transform it into a linked form](/components/modeler/bpmn/user-tasks/user-tasks.md#camunda-form-linked) before you change the task type implementation. Press `Ctrl+Z` or `⌘+Z` to undo if you accidentally removed your embedded form.
4. Open the **Implementation** section in the properties panel.
5. Click the **Type** dropdown and select **Camunda user task**. The linked form or external form reference will be preserved.

Repeat these steps for all user tasks in the process. Then, deploy the process to your development cluster and test it by running the process and ensuring your custom task applications work.

## How Tasklist API (V1) compares to Orchestration Cluster REST API (V2)

:::note
The Tasklist REST API is [deprecated with the 8.8 release and will be deleted with the 8.10 release](/reference/announcements-release-notes/880/880-announcements.md#deprecated-operate-and-tasklist-v1-rest-apis).
:::

The following table provides a breakdown of which operations are supported in which API, and for which user tasks.

    
        Operation
        Tasklist API
        Orchestration Cluster REST API
    
    
        Query tasks
        ✔ All types
        ✔ Camunda user tasks
    
    
        Get task
        ✔ All types
        ✔ Camunda user tasks
    
    
        Retrieve task variables
        ✔ All types
        ✔ Camunda user tasks
    
    
        Get task form
        ✔ All types
        ✔ Camunda user tasks
    
    
        Change task assignment
        ✔ Job worker-based tasks
        ✔ Camunda user tasks
    
    
        Complete task
        ✔ Job worker-based tasks
        ✔ Camunda user tasks
    
    
        Update task
        Not supported
        ✔ Camunda user tasks
    
    
        Safe and retrieve draft variables
        ✔ Job worker-based tasks
        Not supported
    

The following table outlines the respective endpoints. Click the endpoints to follow to the API documentation and inspect the differences in the request and response objects.

    
        Operation
        Tasklist API
        Orchestration Cluster REST API
    
    
        Query user tasks
        
            <code>POST /tasks/search</code>
        
        
            
                <code>POST /user-tasks/search</code>
            
        
    
    
        Get user task
        
            <code>GET /tasks/:taskId</code>
        
        
            
                <code>GET /user-tasks/:userTaskKey</code>
            
        
    
    
        Retrieve task variables
        
            <code>GET /variables/:variableId</code>
        
        
            
                <code>POST /tasks/:taskId/variables/search</code>
            
        
    
    
        Get task form
        
            <code>GET /forms/:formId</code>
        
        
            
                <code>GET /user-tasks/:userTaskKey/form</code>
            
        
    
    
        Assign a task
        
            <code>PATCH /tasks/:taskId/assign</code>
        
        
            
                <code>POST /user-tasks/:userTaskKey/assignment</code>
            
        
    
    
        Unassign a task
        
            <code>PATCH /tasks/:taskId/unassign</code>
        
        
            
                <code>DELETE /user-tasks/:userTaskKey/assignee</code>
            
        
    
    
        Complete task
        
            <code>PATCH /tasks/:taskId/complete</code>
        
        
            
                <code>POST /user-tasks/:userTaskKey/completion</code>
            
        
    
    
        Update task
        Not supported
        
            
                <code>PATCH /user-tasks/:userTaskKey</code>
            
        
    
    
        Save and retrieve draft variables
        
            <code>POST /tasks/:taskId/variables</code>
        
        -
    

### Zeebe Java client

Use the Zeebe Java client when you are building your task application in Java. The client assists with managing authentication and request/response objects.

### API differences

<!-- TODO two cards to link to boh API docs, once available -->

Refer to the dedicated sections and API explorers to learn details about the APIs.

<DocCardList items={[
{
type:"link",
href:"/docs/next/apis-tools/migration-manuals/migrate-to-camunda-api/",
label: "Tasklist API migration guide",
docId:"apis-tools/migration-manuals/migrate-to-camunda-api"
},
{
type:"link",
href:"/docs/next/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview/",
label: "Orchestration Cluster API (REST)",
docId:"apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview"
}
]}/>

## Troubleshooting and common issues

If your task application does not work properly after migration, check the following:

- **The endpoints return specific error messages when you run them on the wrong task type**: Ensure to call the right endpoint for the right task type, c.f. above [table](#use-the-new-camunda-8-api).
- **Forms do not appear**: Ensure you have extracted embedded forms, if any, and [transformed them into linked forms](/components/modeler/bpmn/user-tasks/user-tasks.md#camunda-form-linked), before you change the task type implementation.
- **Task update operation does not work**: The update operation is only available to Camunda user tasks.

---

## SaaS orchestration architecture

<PageDescription />

## About

Camunda 8.9 introduces a streamlined SaaS orchestration architecture. The runtime for Operate, Tasklist, Identity (Admin), and the Zeebe REST API is unified into a single orchestration service. Zeebe brokers continue to run separately and execute workflows as before.

This is a topology change in SaaS only and does not affect Self-Managed deployments.

What's new:

- [Unified API domain for Orchestration Clusters](#unified-api-domain-for-orchestration-clusters). Legacy hostnames are deprecated but will remain available throughout 8.9 and are scheduled for removal in 8.10.
- [Client credentials for new clusters use unified API URLs.](#client-credentials-and-legacy-hostnames)
- [Cluster Metrics endpoint: `service` labels have changed on Orchestration Cluster metrics.](#service-label-changes)

What didn't change:

- The same UIs for Operate, Tasklist, and Admin/Identity and the REST API remain available as before.
- The Zeebe gRPC endpoint is unchanged.

## Unified API domain for Orchestration Clusters

Camunda 8.9 introduces a unified API domain for Orchestration Clusters. All services are now accessible under a single base URL:

| Service             | Unified URL (8.9)                                             |
| :------------------ | :------------------------------------------------------------ |
| Base / REST API     | `https://<region>.api.<camunda-domain>/<cluster-id>`          |
| Operate UI          | `https://<region>.api.<camunda-domain>/<cluster-id>/operate`  |
| Tasklist UI         | `https://<region>.api.<camunda-domain>/<cluster-id>/tasklist` |
| Admin (Identity) UI | `https://<region>.api.<camunda-domain>/<cluster-id>/admin`    |

Legacy hostnames (`*.zeebe.<camunda-domain>`, `*.operate.<camunda-domain>`, `*.tasklist.<camunda-domain>`, and `*.identity.<camunda-domain>`) continue to work in 8.9 and are internally routed to the unified service, but are deprecated and scheduled for removal in 8.10.

After the 8.10 release, only the Zeebe gRPC endpoint and the unified `*.api.*` endpoints will remain.

### Deprecation

Legacy hostnames are deprecated as of 8.9 and will be removed in 8.10. Migrate any hard-coded URLs for Operate, Tasklist, or Identity to the new unified `*.api.*` URLs during the 8.9 lifecycle to ensure readiness before the 8.10 release.

## Client credentials and legacy hostnames

Existing client credentials downloaded from Console for pre-8.9 clusters may reference legacy hostnames. Because those hostnames remain available in 8.9, existing credentials continue to work after a cluster is upgraded to 8.9. No immediate action is required.

### Recommended action

For long-lived automation and CI/CD systems, Camunda recommends updating credentials to use the new unified `*.api.*` URLs and corresponding token audience values before 8.10. You have two options:

- **Update existing credentials manually:** Edit the hostnames and token audience values in your existing credential configuration to reference the new unified URLs. For example:
  - **Legacy (pre-8.9):**
    - **Base URL:** `https://bru-2.operate.camunda.io/abc123-def456-ghi789`
    - **Audience:** `operate.camunda.io`
  - **New (from 8.9):**
    - **Base URL:** `https://bru-2.api.camunda.io/abc123-def456-ghi789/operate`
    - **Audience:** `api.camunda.io`
- **Create new credentials:** Create a fresh set of client credentials in Camunda Console, which will be generated with the unified API URLs and correct audience values by default.

## Service label changes

Breaking change

Due to the streamlined orchestration architecture introduced in 8.9, metrics previously emitted by the individual Operate, Tasklist, and Identity services are now emitted by the unified orchestration service. As a result, the `service` label on affected metrics will change to reflect the new source service.

This applies to Camunda 8 SaaS clusters using the [Cluster Metrics endpoint](/components/saas/monitoring/cluster-metrics-endpoint/set-up-cluster-metrics-endpoint.md).

### Impact

Monitoring dashboards, alerting rules, or queries that filter or group by the `service` label on Orchestration Cluster metrics may stop matching expected values after upgrading to 8.9, as some metrics will now be emitted by a different source service.

### Action required

After your cluster is upgraded to 8.9, review your dashboards and alerting rules and verify which `service` label values your metrics return. Update any Prometheus queries or alert definitions that no longer match.

## Upgrade behavior and expected downtime

When a Camunda 8 SaaS Orchestration Cluster is upgraded from 8.8 to 8.9:

1. The existing Operate and Tasklist components are shut down.
2. The unified orchestration service starts in their place.
3. Endpoint routing is updated so legacy hostnames continue to resolve while the new `*.api.*` endpoints become active.

### Impact during upgrade

- **Web UIs and REST API:** You should expect a short interruption while the old services are removed and the unified service becomes ready. This affects all services, but not the Zeebe brokers.
- **Workflow execution (Zeebe brokers):** Designed to remain running throughout the upgrade. The primary impact is limited to UI and API availability, not to engine execution state.

To upgrade, initiate the cluster upgrade to 8.9 from Camunda Console. No additional steps are required beyond the URL and credential recommendations above.

---

## Migrate from the removed Operate API

:::warning
The Operate API was removed in Camunda 8.10 and is no longer part of the current documentation set.
:::

For the release-level summary of this removal, see the [8.10 release announcement](/reference/announcements-release-notes/8100/8100-announcements.md#removal-of-legacy-apis-tasklist-v1-dependent-features-and-zeebe-process-test).

Use the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) for current integrations, and review [migrating to the Orchestration Cluster REST API](/apis-tools/migration-manuals/migrate-to-camunda-api.md) if you still have clients that call the removed Operate API.

If you need legacy Operate API behavior as migration context, use the migration manuals in the current docs rather than building new integrations against the removed endpoints.

---

## Disable sharing

This API allows users to disable the sharing functionality for all reports and dashboards in Optimize. Note that this setting will be permanently persisted in memory and will take precedence over any other previous configurations (e.g. configuration files).

When sharing is disabled, previously shared URLs will no longer be accessible. Upon re-enabling sharing, the previously shared URLs will work once again under the same address as before. Calling this endpoint when sharing is already disabled will have no effect.

## Method & HTTP target resource

POST `api/public/share/disable`

## Request headers

The following request headers must be provided with every request:

| Header         | Constraints | Value                                                   |
| -------------- | ----------- | ------------------------------------------------------- |
| Authentication | REQUIRED    | See [authentication](../optimize-api-authentication.md) |

## Query parameters

No query parameters necessary.

## Request body

An empty request body should be sent.

## Response codes

Possible HTTP Response Status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Disable sharing

POST `api/public/share/disable`

#### Request header

`Authorization: Bearer mySecret`

#### Response

Status 204 (Successful)

#### Response content

```
no content
```

---

## Enable sharing

This API allows users to enable the sharing functionality for all reports and dashboards in Optimize. Note that this setting will be permanently persisted in memory and will take precedence over any other previous configurations (e.g. configuration files).

If sharing had been previously enabled and then disabled, re-enabling sharing will allow users to access previously shared URLs under the same address as before. Calling this endpoint when sharing is already enabled will have no effect.

## Method & HTTP target resource

POST `api/public/share/enable`

## Request headers

The following request headers must be provided with every request:

| Header         | Constraints | Value                                                   |
| -------------- | ----------- | ------------------------------------------------------- |
| Authentication | REQUIRED    | See [authentication](../optimize-api-authentication.md) |

## Query parameters

No query parameters necessary.

## Request body

An empty request body should be sent.

## Response codes

Possible HTTP Response Status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Enable sharing

POST `api/public/share/enable`

#### Request header

`Authorization: Bearer mySecret`

#### Response

Status 204 (Successful)

#### Response content

```
no content
```

---

## Delete dashboards

The dashboards deletion API allows you to delete dashboards by ID from Optimize.

:::note Heads up!
The deletion of a dashboard does not affect the referenced reports.
:::

## Method & HTTP target resource

DELETE `/api/public/dashboard/{dashboard-ID}`

Where `dashboard-ID` is the ID of the dashboard you wish to delete.

## Request headers

The following request headers have to be provided with every delete request:

| Header         | Constraints | Value                                                   |
| -------------- | ----------- | ------------------------------------------------------- |
| Authentication | REQUIRED    | See [authentication](../optimize-api-authentication.md) |

## Query parameters

No query parameters available.

## Request body

No request body is required.

## Result

No response body.

## Response codes

Possible HTTP Response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 404  | The requested dashboard was not found, please check the provided dashboard-ID.                                              |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Delete a dashboard

Let's assume you want to delete a dashboard with the ID `e6c5abb1-6a18-44e7-8480-d562d511ba62`, this is what it would look like:

DELETE `/api/public/dashboard/e6c5aaa1-6a18-44e7-8480-d562d511ba62`

#### Request header

`Authorization: Bearer mySecret`

#### Response

Status 204.

---

## Export dashboard definitions

This API allows users to export dashboard definitions which can later be imported into another Optimize system. Note that exporting a dashboard also exports all reports contained within the dashboard. The dashboards to be exported may be within a Collection or private entities, the API has access to both.

The obtained list of entity exports can be imported into other Optimize systems either using the dedicated [import API](../import-entities.md) or [via UI](components/optimize/userguide/additional-features/export-import.md#importing-entities).

## Method & HTTP target resource

POST `/api/public/export/dashboard/definition/json`

## Request headers

The following request headers have to be provided with every request:

| Header         | Constraints | Value                                               |
| -------------- | ----------- | --------------------------------------------------- |
| Authentication | REQUIRED    | [Authentication](../optimize-api-authentication.md) |

## Query parameters

No query parameters available.

## Request body

The request body should contain a JSON array of dashboard IDs to be exported.

## Result

The response contains a list of exported dashboard definitions as well as all report definitions contained within the dashboards.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 404  | At least one of the given dashboard IDs does not exist.                                                                     |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Export two dashboards

Assuming you want to export the two dashboards with IDs `123` and `456` and have configured the accessToken `mySecret`, this is what it would look like:

POST `/api/public/export/dashboard/definition/json`

#### Request header

`Authorization: Bearer mySecret`

#### Request body

```
[ "123", "456" ]
```

#### Response

Status 200.

#### Response content

The response contains the two exported dashboard definitions as well as all three process reports contained within the two dashboards.

```
[
    {
        "id": "61ae2232-51e1-4c35-b72c-c7152ba264f9",
        "exportEntityType": "single_process_report",
        "name": "Number: Process instance duration",
        "description": "This report shows the average instance duration",
        "sourceIndexVersion": 11,
        "collectionId": null,
        "data": {...}
    },
    {
        "id": "625c2411-b95f-4442-936b-1976b9511d4a",
        "exportEntityType": "single_process_report",
        "name": "Heatmap: Flownode count",
        "description": "This report shows a heatmap of the number of instances",
        "sourceIndexVersion": 11,
        "collectionId": null,
        "data": {...}
    },
    {
        "id": "94a7252e-d5c3-45ea-9906-75271cc0cac2",
        "exportEntityType": "single_process_report",
        "name": "Data Table: User task count",
        "description": "This report shows number of user tasks",
        "sourceIndexVersion": 11,
        "collectionId": null,
        "data": {...}
    },
    {
        "id": "123",
        "exportEntityType": "dashboard",
        "name": "Dashboard 1",
        "description": "A dashboard showing possible automation candidates",
        "sourceIndexVersion": 8,
        "reports": [
            {
                "id": "61ae2232-51e1-4c35-b72c-c7152ba264f9",
                ...
            },
            {
                "id": "625c2411-b95f-4442-936b-1976b9511d4a",
                ...
            }
        ],
        "availableFilters": [...],
        "collectionId": null
    },
    {
        "id": "456",
        "exportEntityType": "dashboard",
        "name": "Dashboard 2",
        "description": "A dashboard showing user task data",
        "sourceIndexVersion": 8,
        "reports": [
            {
                "id": "94a7252e-d5c3-45ea-9906-75271cc0cac2",
                ...
            }
        ],
        "availableFilters": [...],
        "collectionId": null
    }
]
```

---

## Get dashboard IDs

This API allows users to retrieve all dashboard IDs from a given collection.

## Method & HTTP target resource

GET `/api/public/dashboard`

## Request headers

The following request headers have to be provided with every request:

| Header         | Constraints | Value                                               |
| -------------- | ----------- | --------------------------------------------------- |
| Authentication | REQUIRED    | [Authentication](../optimize-api-authentication.md) |

## Query parameters

The following query parameters have to be provided with every request:

| Parameter    | Constraints | Value                                                             |
| ------------ | ----------- | ----------------------------------------------------------------- |
| collectionId | REQUIRED    | The ID of the collection for which to retrieve the dashboard IDs. |

## Request body

No request body is required.

## Result

The response contains a list of IDs of the dashboards existing in the collection with the given collection ID.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 200  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Retrieve all dashboard IDs from a collection

Assuming you want to retrieve all dashboard IDs in the collection with the ID `1234` and have configured the accessToken `mySecret`, this is what it would look like:

GET `/api/public/dashboard?collectionId=1234`

#### Request header

`Authorization: Bearer mySecret`

#### Response

Status 200.

#### Response content

```
[
    {
        "id": "9b0eb845-e8ed-4824-bd85-8cd69038f2f5"
    },
    {
        "id": "1a866c7c-563e-4f6b-adf1-c4648531f7d4"
    }
]
```

---

## External variable ingestion

With the external variable ingestion API, variable data held in external systems can be ingested into Optimize directly,
without the need for these variables to be present in your Camunda platform data. This can be useful when external
business data, which is relevant for process analysis in Optimize, is to be associated with specific process instances.

Especially if this data changes over time, it is advisable to use this REST API to persist external variable updates to Optimize, as otherwise Optimize may not be aware of data changes in the external system.

## Functionality

The external variable ingestion API allows users to ingest batches of variable data which Optimize stores in a dedicated
index. All variable data includes a reference to the process instance each variable belongs to, this reference then
enables Optimize to import external variable data from the dedicated index to their respective process instances at
regular intervals. Once Optimize has updated the process instance data, the external variables are available for report
evaluations in Optimize.

## Limitations

Note that external variables should be treated as separate from engine variables. If you ingest variables that are already present in the engine, engine imports may override the ingested data and vice versa, leading to unreliable report results.

Similarly, if the same ingested batch contains variables with duplicate IDs, you may experience unexpected report results because Optimize will assume only one of the updates per ID and batch to be the most up to date one.

Additionally, ensure the reference information (process instance ID and process definition key) is accurate, as otherwise Optimize will not be able to correctly associate variables with instance data and may create new instance indices, resulting in data which will not be usable in reports. External variables can only be ingested for process instances and will not be affected by any configured variable plugin.

## Configuration

Refer to
the [configuration section](../../self-managed/components/optimize/configuration/system-configuration.md) to learn more
about how to set up external variable ingestion.

## Method & HTTP target resource

POST `/api/ingestion/variable`

## Request headers

The following request headers have to be provided with every variable ingestion request:

| Header         | Constraints | Value                                                 |
| -------------- | ----------- | ----------------------------------------------------- |
| Authentication | REQUIRED\*  | See [authentication](../optimize-api-authentication). |
| Content-Type   | REQUIRED    | `application/json`                                    |

- Only required if not set as a query parameter

## Query parameters

The following query parameters have to be provided with every delete request:

| Parameter    | Constraints | Value                                                |
| ------------ | ----------- | ---------------------------------------------------- |
| access_token | REQUIRED\*  | See [authentication](../optimize-api-authentication) |

- Only required if not set as a request header

## Request body

The request body contains an array of variable JSON Objects:

| Name                 | Type   | Constraints | Description                                                                                       |
| -------------------- | ------ | ----------- | ------------------------------------------------------------------------------------------------- |
| id                   | String | REQUIRED    | The unique identifier of this variable.                                                           |
| name                 | String | REQUIRED    | The name of the variable.                                                                         |
| type                 | String | REQUIRED    | The type of the variable. Must be one of: String, Short, Long, Double, Integer, Boolean, or Date. |
| value                | String | REQUIRED    | The current value of the variable.                                                                |
| processInstanceId    | String | REQUIRED    | The ID of the process instance this variable is to be associated with.                            |
| processDefinitionKey | String | REQUIRED    | The definition key of the process instance this variable is to be associated with.                |

## Result

This method returns no content.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                            |
| ---- | ------------------------------------------------------------------------------------------------------ |
| 204  | Request successful.                                                                                    |
| 400  | Returned if some properties in the request body are invalid or missing.                                |
| 401  | Secret incorrect or missing. See [authentication](../optimize-api-authentication) on how to authorize. |

## Example

### Request

POST `/api/ingestion/variable`

Request Body:

```
     [
      {
          "id": "7689fced-2639-4408-9de1-cf8f72769f43",
          "name": "address",
          "type": "string",
          "value": "Main Street 1",
          "processInstanceId": "c6393461-02bb-4f62-a4b7-f2f8d9bbbac1",
          "processDefinitionKey": "shippingProcess"
      },
      {
          "id": "993f4e73-7f6a-46a6-bd45-f4f8e3470ba1",
          "name": "amount",
          "type": "integer",
          "value": "500",
          "processInstanceId": "8282ed49-2243-44df-be5e-1bf893755d8f",
          "processDefinitionKey": "orderProcess"
      }
    ]
```

### Response

Status 204.

---

## Health readiness

The purpose of Health-Readiness REST API is to return information indicating whether Optimize is ready to be used.

:::note
The Health-Readiness REST API does not require an [`Authorization` header](./optimize-api-authentication.md), and rejects requests that include one.
:::

## Method & HTTP target resource

GET `/api/readyz`

## Response

The response is an empty body with the status code indicating the readiness of Optimize. The following responses are available:

- `200`: This indicates that Optimize is ready to use. It is connected to both Elasticsearch and at least one of its configured engines.
- `503`: This indicates that Optimize is not ready to use. It cannot connect to either Elasticsearch or any of its configured engines.

---

## Import entities

This API allows users to import entity definitions such as reports and dashboards into existing collections. These entity definitions may be obtained either using the [report](../report/export-report-definitions/) or [dashboard](../dashboard/export-dashboard-definitions) export API or [via the UI](components/optimize/userguide/additional-features/export-import.md#exporting-entities).

## Prerequisites

For importing via API, the following prerequisites must be met:

- All definitions the entities require exist in the target Optimize.
- The target collection, identified using the `collectionId` query parameter, must exist in the target system.
- The collection data sources must include all relevant definitions for the entities.
- The entity data structures match. To ensure matching data structures, confirm that the Optimize version of the source is the same as the version of the target Optimize.

If any of the above conditions are not met, the import will fail with an error response; refer to the error message in the response for more information.

## Method & HTTP target resource

POST `/api/public/import`

## Request headers

The following request headers have to be provided with every request:

| Header         | Constraints | Value                                              |
| -------------- | ----------- | -------------------------------------------------- |
| Authentication | REQUIRED    | [Authentication](./optimize-api-authentication.md) |

## Query parameters

The following query parameters have to be provided with every request:

| Parameter    | Constraints | Value                                                          |
| ------------ | ----------- | -------------------------------------------------------------- |
| collectionId | REQUIRED    | The ID of the collection for which to retrieve the report IDs. |

## Request body

The request body should contain a JSON array of entity definitions to be imported. These entity definitions may be obtained by using the [report](../report/export-report-definitions) or [dashboard](../dashboard/export-dashboard-definitions) export APIs or by [manually exporting entities](components/optimize/userguide/additional-features/export-import.md#exporting-entities) via the Optimize UI.

## Result

The response contains a list of DTOs that specify the ID and entity type (`report` or `dashboard`) of each newly created entity in the target system.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                                                                                              |
| ---- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 200  | Request successful.                                                                                                                                                                                      |
| 400  | The provided list of entities is invalid. This can occur if any of the above listed [prerequisites](#prerequisites) are not met. Check the `detailedMessage` of the error response for more information. |
| 401  | Secret incorrect or missing in HTTP header. See [authentication](./optimize-api-authentication.md) on how to authenticate.                                                                               |
| 404  | The given target collection ID does not exist.                                                                                                                                                           |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                                                                                                           |

## Example

### Import two entities

Assuming you want to import a report and a dashboard into the collection with ID `123`, this is what it would look like:

POST `/api/public/import?collectionId=123`

#### Request header

`Authorization: Bearer mySecret`

#### Request body

```
[
    {
        "id": "61ae2232-51e1-4c35-b72c-c7152ba264f9",
        "exportEntityType": "single_process_report",
        "name": "Number: Process instance duration",
        "description": "This report shows the average instance duration",
        "sourceIndexVersion": 11,
        "collectionId": null,
        "data": {...}
    },
    {
        "id": "b0eb845-e8ed-4824-bd85-8cd69038f2f5",
        "exportEntityType": "dashboard",
        "name": "Dashboard 1",
        "description": "This dashboard displays reports relating to process durations",
        "sourceIndexVersion": 8,
        "reports": [
            {
                "id": "61ae2232-51e1-4c35-b72c-c7152ba264f9",
                ...
            }
        ],
        "availableFilters": [...],
        "collectionId": null
    }
]
```

#### Response

Status 200.

#### Response Content

```
[
    {
        "id": "e8ca18b9-e637-45c8-87da-0a2b08b34d6e",
        "entityType": "dashboard"
    },
    {
        "id": "290b3425-ba33-4fbb-b20b-a4f236036847",
        "entityType": "report"
    }
]
```

---

## Authentication(Optimize-api)

All Optimize API requests except [the health readiness](./health-readiness.md) endpoint require authentication. To authenticate, generate a [JSON Web Token (JWT)](https://jwt.io/introduction/) and include it in each request.

## Generate a token

<Tabs groupId="environment" defaultValue="saas" queryString values={
[
{label: 'SaaS', value: 'saas' },
{label: 'Self-Managed', value: 'self-managed' },
]}>
<TabItem value='saas'>

1. [Create client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the **Clusters > Cluster name > API** tab of [Camunda Console](https://console.camunda.io/).
2. Add permissions to this client for **Optimize**.
3. Once you have created the client, capture the following values required to generate a token:
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   | Name                     | Environment variable name        | Default value                                |
   | ------------------------ | -------------------------------- | -------------------------------------------- |
   | Client ID                | `ZEEBE_CLIENT_ID`                | -                                            |
   | Client Secret            | `ZEEBE_CLIENT_SECRET`            | -                                            |
   | Authorization Server URL | `ZEEBE_AUTHORIZATION_SERVER_URL` | `https://login.cloud.camunda.io/oauth/token` |
   | Optimize REST Address    | `CAMUNDA_OPTIMIZE_BASE_URL`      | -                                            |
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   :::caution
   When client credentials are created, the `Client Secret` is only shown once. Save this `Client Secret` somewhere safe.
   :::
4. Execute an authentication request to the token issuer:
   ```bash
   curl --request POST ${ZEEBE_AUTHORIZATION_SERVER_URL} \
       --header 'Content-Type: application/x-www-form-urlencoded' \
       --data-urlencode 'grant_type=client_credentials' \
       --data-urlencode 'audience=optimize.camunda.io' \
       --data-urlencode "client_id=${ZEEBE_CLIENT_ID}" \
       --data-urlencode "client_secret=${ZEEBE_CLIENT_SECRET}"
   ```
   A successful authentication response looks like the following:
   ```json
   {
     "access_token": "<TOKEN>",
     "expires_in": 300,
     "refresh_expires_in": 0,
     "token_type": "Bearer",
     "not-before-policy": 0
   }
   ```
5. Capture the value of the `access_token` property and store it as your token.

</TabItem>

<TabItem value='self-managed'>

1. [Configure the `api.audience` setting](/self-managed/components/optimize/configuration/system-configuration.md#public-api) in your Optimize installation to match the audience property of the **Optimize API** in [Management Identity](/self-managed/components/management-identity/access-management/access-management-overview.md).
2. [Add an M2M application in Management Identity](/self-managed/components/management-identity/application-user-group-role-management/applications.md).
3. [Add permissions to this application](/self-managed/components/management-identity/application-user-group-role-management/applications.md) for **Optimize API**.
4. Capture the `Client ID` and `Client Secret` from the application in Management Identity.
5. [Generate a token](/self-managed/components/management-identity/authentication.md) to access the Optimize REST API. Provide the `client_id` and `client_secret` from the values you previously captured in Management Identity.
   ```shell
   curl --location --request POST 'http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token' \
   --header 'Content-Type: application/x-www-form-urlencoded' \
   --data-urlencode "client_id=${CLIENT_ID}" \
   --data-urlencode "client_secret=${CLIENT_SECRET}" \
   --data-urlencode 'grant_type=client_credentials'
   ```
   A successful authentication response looks like the following:
   ```json
   {
     "access_token": "<TOKEN>",
     "expires_in": 300,
     "refresh_expires_in": 0,
     "token_type": "Bearer",
     "not-before-policy": 0
   }
   ```
6. Capture the value of the `access_token` property and store it as your token.

:::note
The Optimize API can also be configured in a Self-Managed environment to authenticate using a single shared access token. See [External API Configuration](/self-managed/components/optimize/configuration/system-configuration.md#external-api) for the configuration required to access the public API using a specific token.
:::

</TabItem>

</Tabs>

## Use a token

Include the previously captured token as an authorization header in each request: `Authorization: Bearer <TOKEN>`.

For example, to send a request to the Optimize API's ["Get dashboard IDs"](./dashboard/get-dashboard-ids.md) endpoint:

<Tabs groupId="environment" defaultValue="saas" queryString values={
[
{label: 'SaaS', value: 'saas' },
{label: 'Self-Managed', value: 'self-managed' },
]}>

<TabItem value='saas'>

:::tip
The `${CAMUNDA_TASKLIST_BASE_URL}` variable below represents the URL of the Optimize API. You can capture this URL when creating an API client. You can also construct it as `https://${REGION}.optimize.camunda.io/${CLUSTER_ID}`.
:::

</TabItem>

<TabItem value='self-managed'>

:::tip
The `${CAMUNDA_OPTIMIZE_BASE_URL}` variable below represents the URL of the Optimize API. You can configure this value in your Self-Managed installation. The default value is `http://localhost:8083`.
:::

</TabItem>

</Tabs>

```shell
curl --header "Authorization: Bearer ${TOKEN}" \
     -G --data-urlencode "collectionId=${COLLECTION_ID}" \
     ${CAMUNDA_OPTIMIZE_BASE_URL}/api/public/dashboard
```

A successful response includes [dashboard IDs](./dashboard/get-dashboard-ids.md). For example:

```json
[
  {
    "id": "11111111-1111-1111-1111-111111111111"
  },
  {
    "id": "22222222-2222-2222-2222-222222222222"
  }
]
```

## Token expiration

Access tokens expire according to the `expires_in` property of a successful authentication response. After this duration, in seconds, you must request a new access token.

---

## Optimize API

<PageDescription />

## About

You can use the Optimize API to:

- Retrieve, create, update, and delete reports and dashboards
- Export dashboards and reports for sharing or backup
- Enable or disable sharing links

## Authentication

All Optimize API requests, except [the health readiness](./health-readiness.md) endpoint, require authentication. To authenticate, generate a [JSON Web Token (JWT)](https://jwt.io/introduction/) and include it in each request.

For more details, see the [Authentication](./optimize-api-authentication.md) section.

## API Postman collection

To get started quickly, consider using the [Postman collection](https://www.postman.com/camundateam/workspace/camunda-8-postman/collection/24684262-a1103c05-7ed8-4fd4-8716-9005583ce23a?action=share&creator=11465105).

## Usage notes

Deleting a file, folder, or project via the API is immediate and cannot be undone. Use caution.

## Further resources

- [Authentication](./optimize-api-authentication.md)
- [Camunda Optimize documentation](/components/optimize/what-is-optimize.md)
- [Postman collection](https://www.postman.com/camundateam/workspace/camunda-8-postman/collection/24684262-a1103c05-7ed8-4fd4-8716-9005583ce23a?action=share&creator=11465105)

---

## Delete reports

The report deletion API allows you to delete reports by ID from Optimize.

:::note Heads up!
During deletion a report will get removed from any dashboard or combined process report it is referenced by. In case a report is referenced by an alert, the corresponding alert will get deleted too.
:::

## Method & HTTP target resource

DELETE `/api/public/report/{report-ID}`

Where `report-ID` is the ID of the report you wish to delete.

## Request headers

The following request headers have to be provided with every delete request:

| Header         | Constraints | Value                                                   |
| -------------- | ----------- | ------------------------------------------------------- |
| Authentication | REQUIRED    | See [authentication](../optimize-api-authentication.md) |

## Query parameters

No query parameters available.

## Request body

No request body is required.

## Result

No response body.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 404  | The requested report was not found, please check the provided report-ID.                                                    |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Delete a report

Let's assume you want to delete a report with the ID `e6c5abb1-6a18-44e7-8480-d562d511ba62`, this is what it would look like:

DELETE `/api/public/report/e6c5aaa1-6a18-44e7-8480-d562d511ba62`

#### Request header

`Authorization: Bearer mySecret`

#### Response

Status 204.

---

## Export report definitions

This API allows users to export report definitions which can later be imported into another Optimize system. The reports to be exported may be within a collection or private entities, the API has access to both.

The obtained list of entity exports can be imported into other Optimize systems either using the dedicated [import API](../import-entities.md) or [via UI](components/optimize/userguide/additional-features/export-import.md#importing-entities).

## Method & HTTP target resource

POST `/api/public/export/report/definition/json`

## Request headers

The following request headers have to be provided with every request:

| Header         | Constraints | Value                                               |
| -------------- | ----------- | --------------------------------------------------- |
| Authentication | REQUIRED    | [Authentication](../optimize-api-authentication.md) |

## Query parameters

No query parameters available.

## Request body

The request body should contain a JSON array of report IDs to be exported.

## Result

The response contains a list of exported report definitions.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 404  | At least one of the given report IDs does not exist.                                                                        |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Export two reports

Assuming you want to export the two reports with IDs `123` and `456` and have configured the accessToken `mySecret`, this is what it would look like:

POST `/api/public/export/report/definition/json`

#### Request header

`Authorization: Bearer mySecret`

#### Request body

```
[ "123", "456" ]
```

#### Response

Status 200.

#### Response content

```
[
    {
        "id": "123",
        "exportEntityType": "single_process_report",
        "name": "Number: Process instance duration",
        "sourceIndexVersion": 8,
        "collectionId": "40cb3657-bdcb-459d-93ce-06877ac7244a",
        "data": {...}
    },
    {
        "id": "456",
        "exportEntityType": "single_process_report",
        "name": "Heatmap: Flownode count",
        "sourceIndexVersion": 8,
        "collectionId": "40cb3657-bdcb-459d-93ce-06877ac7244a",
        "data": {...}
    }
]
```

---

## Export report result data

The data export API allows users to export large amounts of data in a machine-readable format (JSON) from Optimize.

## Functionality

Users can export all report types (except combined process reports) from `Optimize` using the Data Export API. Moreover, raw data reports will include additional data relating to the executed flow nodes and can be exported in a paginated fashion, so that large amounts of data can be consumed in chunks by the client.

### Pagination

The simplest way to paginate through the results is to perform a search request with all the `REQUIRED` header/query parameters as described in the sections below (but without `searchRequestId`), then pass the `searchRequestId` returned in each response to the next request, until no more documents are returned. Note that it's often the case, but not guaranteed, that the `searchRequestId` remains stable through the entire pagination, so always use the `searchRequestId` from the most current response to make your next request.

## Method & HTTP target resource

GET `/api/public/export/report/{report-ID}/result/json`

Where `report-ID` is the ID of the report you wish to export.

## Request headers

The following request headers have to be provided with every data export request:

| Header         | Constraints | Value                                               |
| -------------- | ----------- | --------------------------------------------------- |
| Authentication | REQUIRED    | [Authentication](../optimize-api-authentication.md) |

## Query parameters

The following query parameters have to be provided with every data export request:

| Parameter         | Constraints | Value                                                                                                                                                                                                                                                              |
| ----------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| limit             | REQUIRED    | Maximum number of records per page. Please note that the limit will only be considered when performing the request for the first page of a raw data report. The following requests for a given searchRequestId will have the same page size as the first request.  |
| paginationTimeout | REQUIRED    | The amount of time (in seconds) for which a search context will be held in memory, so that the remaining pages of the result can be retrieved. For more information on how to paginate through the results, please refer to the section [Pagination](#pagination). |
| searchRequestId   | Optional    | The ID of a previous search for which you wish to retrieve the next page of results. For more information on how to get and use a searchRequestId please refer to the section [Pagination](#pagination).                                                           |

## Request body

No request body is required.

## Result

| Content                   | Value                                                                                                                                                                                          |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| searchRequestId           | The ID of the performed search. The following pages from this search can be retrieved by using this ID. For more information please refer to the section [Pagination](#pagination).            |
| numberOfRecordsInResponse | Number of records in the JSON Response. This is a number between [0, limit]                                                                                                                    |
| totalNumberOfRecords      | The total number of records (from all pages) for this report export                                                                                                                            |
| reportId                  | The ID of the exported report                                                                                                                                                                  |
| message                   | In case there is additional information relevant to this request, this field will contain a message describing it. The response will only contain this field if there is a message to be shown |
| data [Array]              | An array containing numberOfRecordsInResponse report data records in JSON Format                                                                                                               |

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 200  | Request successful.                                                                                                         |
| 400  | Returned if some of the properties from the request are invalid or missing.                                                 |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 404  | The requested report was not found, please check the provided report-ID.                                                    |
| 500  | Some error occurred while processing the export request, best check the Optimize log.                                       |

## Example

### Export a raw data report

Let's assume you want to export a report with the ID `e6c5abb1-6a18-44e7-8480-d562d511ba62`, with a maximum of two records per page, an access token `mySecret` and a pagination timeout of 60s, this is what it would look like

#### Initial API call

GET `/api/public/export/report/e6c5aaa1-6a18-44e7-8480-d562d511ba62/result/json? paginationTimeout=60&limit=2`

##### Request header

`Authorization: Bearer mySecret`

##### Response content

```
    {
      "searchRequestId": "FGluY2x1ZGVfY29udGV4dF91dWlkDXF1ZXJ",
      "numberOfRecordsInResponse": 2,
      "totalNumberOfRecords": 11,
      "reportId": "e6c5abb1-6a18-44e7-8480-d562d511ba62",
      "data": [
          {
              "processDefinitionKey": "aProcess",
              "processDefinitionId": "aProcess:1:1801",
              "processInstanceId": "1809",
              "businessKey": "aBusinessKey",
              "startDate": "2021-12-02T17:21:49.330+0200",
              "endDate": "2021-12-02T17:21:49.330+0200",
              "duration": 0,
              "engineName": "camunda-bpm",
              "tenantId": null,
              "variables": {}
          },
          {
              "processDefinitionKey": "aProcess",
              "processDefinitionId": "aProcess:1:1801",
              "processInstanceId": "1804",
              "businessKey": "aBusinessKey",
              "startDate": "2021-12-02T17:21:49.297+0200",
              "endDate": "2021-12-02T17:21:49.298+0200",
              "duration": 1,
              "engineName": "camunda-bpm",
              "tenantId": null,
              "variables": {}
          }
      ]
    }
```

##### Response

Status 200.

#### Subsequent API calls

Note here the use of the query parameter `searchRequestId` to retrieve further pages from the initial search.

`GET /api/public/export/report/e6c5aaa1-6a18-44e7-8480-d562d511ba62/result/json?paginationTimeout=60&searchRequestId=FGluY2x1ZGVfY29udGV4dF91dWlkDXF1ZXJ&limit=2`

##### Request header

`Authorization: Bearer mySecret`

##### Response content

```
    {
      "searchRequestId": "FGluY2x1ZGVfY29udGV4dF91dWlkDXF1ZXJ",
      "numberOfRecordsInResponse": 2,
      "totalNumberOfRecords": 11,
      "reportId": "e6c5abb1-6a18-44e7-8480-d562d511ba62",
      "data": [
          {
              "processDefinitionKey": "aProcess",
              "processDefinitionId": "aProcess:1:1bc9474d-5762-11ec-8b2c-0242ac120003",
              "processInstanceId": "1bdafab8-5762-11ec-8b2c-0242ac120003",
              "businessKey": "aBusinessKey",
              "startDate": "2021-12-07T15:32:22.739+0200",
              "endDate": "2021-12-07T15:32:22.740+0200",
              "duration": 1,
              "engineName": "camunda-bpm",
              "tenantId": null,
              "variables": {}
          },
          {
              "processDefinitionKey": "aProcess",
              "processDefinitionId": "aProcess:1:1bc9474d-5762-11ec-8b2c-0242ac120003",
              "processInstanceId": "1bda3763-5762-11ec-8b2c-0242ac120003",
              "businessKey": "aBusinessKey",
              "startDate": "2021-12-07T15:32:22.735+0200",
              "endDate": "2021-12-07T15:32:22.735+0200",
              "duration": 0,
              "engineName": "camunda-bpm",
              "tenantId": null,
              "variables": {}
          }
      ]
    }
```

##### Response

Status 200.

---

## Get report IDs

This API allows users to retrieve all report IDs from a given collection.

## Method & HTTP target resource

GET `/api/public/report`

## Request headers

The following request headers have to be provided with every request:

| Header         | Constraints | Value                                               |
| -------------- | ----------- | --------------------------------------------------- |
| Authentication | REQUIRED    | [Authentication](../optimize-api-authentication.md) |

## Query parameters

The following query parameters have to be provided with every request:

| Parameter    | Constraints | Value                                                          |
| ------------ | ----------- | -------------------------------------------------------------- |
| collectionId | REQUIRED    | The ID of the Collection for which to retrieve the report IDs. |

## Request body

No request body is required.

## Result

The response contains a list of IDs of the reports existing in the collection with the given collection ID.

## Response codes

Possible HTTP response status codes:

| Code | Description                                                                                                                 |
| ---- | --------------------------------------------------------------------------------------------------------------------------- |
| 200  | Request successful.                                                                                                         |
| 401  | Secret incorrect or missing in HTTP Header. See [authentication](../optimize-api-authentication.md) on how to authenticate. |
| 500  | Some error occurred while processing the request, best check the Optimize log.                                              |

## Example

### Retrieve all report IDs from a collection

Assuming you want to retrieve all report IDs in the collection with the ID `1234` and have configured the accessToken `mySecret`, this is what it would look like:

GET `/api/public/report?collectionId=1234`

#### Request header

`Authorization: Bearer mySecret`

##### Response

Status 200.

##### Response content

```
[
    {
        "id": "9b0eb845-e8ed-4824-bd85-8cd69038f2f5"
    },
    {
        "id": "1a866c7c-563e-4f6b-adf1-c4648531f7d4"
    }
]
```

---

## Tutorial(Optimize-api)

In this tutorial, we'll step through examples to highlight the capabilities of the Optimize API, such as listing your existing dashboard IDs, or deleting a dashboard.

## Prerequisites

- If you haven't done so already, [create a cluster](/components/hub/organization/manage-clusters/create-cluster.md).
- Upon cluster creation, [create your first client](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client). Ensure you check the `Optimize` client scope box.

:::note
Make sure you keep the generated client credentials in a safe place. The **Client secret** will not be shown again. For your convenience, you can also download the client information to your computer.
:::

- In this tutorial, we utilize a JavaScript-written [GitHub repository](https://github.com/camunda/camunda-api-tutorials) to write and run requests. Clone this repo before getting started.
- Ensure you have [Node.js](https://nodejs.org/en/download) installed as this will be used for methods that can be called by the CLI (outlined later in this guide). Run `npm install` to ensure you have updated dependencies.

## Getting started

- You need authentication to access the API endpoints. Find more information [here](./optimize-api-authentication.md).
- To properly execute the commands to list existing dashboard IDs and delete a dashboard, ensure you have [created a collection](/components/optimize/userguide/collections-dashboards-reports.md) containing a [dashboard](/components/optimize/userguide/creating-dashboards.md).

## Set up authentication

If you're interested in how we use a library to handle auth for our code, or to get started, examine the `auth.js` file in the GitHub repository. This file contains a function named `getAccessToken` which executes an OAuth 2.0 protocol to retrieve authentication credentials based on your client ID and client secret. Then, we return the actual token that can be passed as an authorization header in each request.

To set up your credentials, create an `.env` file which will be protected by the `.gitignore` file. You will need to add your `OPTIMIZE_CLIENT_ID`, `OPTIMIZE_CLIENT_SECRET`, `OPTIMIZE_BASE_URL`, and `OPTIMIZE_AUDIENCE`, which is `optimize.camunda.io` in a Camunda 8 SaaS environment. For example, your audience may be defined as `OPTIMIZE_AUDIENCE=optimize.camunda.io`.

These keys will be consumed by the `auth.js` file to execute the OAuth protocol, and should be saved when you generate your client credentials in [prerequisites](#prerequisites).

:::tip Can't find your environment variables?
When you create new client credentials as a [prerequisite](#prerequisites), your environment variables appear in a pop-up window. Your environment variables may appear as `CAMUNDA_CLIENT_ID`, `CAMUNDA_CLIENT_SECRET`, and `CAMUNDA_OPTIMIZE_BASE_URL`.
:::

Examine the existing `.env.example` file for an example of how your `.env` file should look upon completion. Do not place your credentials in the `.env.example` file, as this example file is not protected by the `.gitignore`.

:::note

In this tutorial, we will execute arguments to list existing dashboard IDs and delete a dashboard. You can examine the framework for processing these arguments in the `cli.js` file before getting started.

:::

## GET a list of existing dashboard IDs

First, let's script an API call to list our existing dashboard IDs.

To do this, take the following steps:

1. In the file named `optimize.js`, outline the authentication and authorization configuration in the first few lines. This will pull in your `.env` variables to obtain an access token before making any API calls:

```javascript
const authorizationConfiguration = {
  clientId: process.env.OPTIMIZE_CLIENT_ID,
  clientSecret: process.env.OPTIMIZE_CLIENT_SECRET,
  audience: process.env.OPTIMIZE_AUDIENCE,
};
```

2. Examine the function `async function listDashboards([collectionId])` below this configuration. This is where you will script out your API call.
3. Within the function, you must first apply an access token for this request, so your function should now look like the following:

```javascript
async function listDashboards([collectionId]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
}
```

4. Using your generated client credentials from [prerequisites](#prerequisites), capture your Optimize API URL beneath your call for an access token by defining `optimizeApiUrl`:

`const optimizeApiUrl = process.env.OPTIMIZE_BASE_URL;`

5. On the next line, script the API endpoint to list your existing dashboard IDs for a particular collection:

```javascript
const url = `${optimizeApiUrl}/api/public/dashboard?collectionId=${collectionId}`;
```

6. Configure your GET request to the appropriate endpoint, including an authorization header based on the previously acquired `accessToken`:

```javascript
const options = {
  method: "GET",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

7. Call the collection's endpoint, process the results from the API call, emit the dashboard IDs to output, and emit an error message from the server if necessary:

```javascript
try {
  const response = await axios(options);
  const results = response.data;

  results.forEach((x) => console.log(`ID: ${x.id}`));
} catch (error) {
  // Emit an error from the server.
  console.error(error.message);
}
```

8. In your terminal, run `node cli.js optimize list <collection ID>`, where `<collection ID>` is where you can paste the ID of your collection for a list of your existing dashboard IDs within this particular collection. If you have any existing dashboards within a collection, you will see an output similar to the following:

`ID: 12345`

:::note
This `list` command is connected to the `listDashboards` function at the bottom of the `optimize.js` file, and executed by the `cli.js` file. While we will view dashboard IDs and delete a dashboard in this tutorial, you may add additional arguments depending on the API calls you would like to make.
:::

If you have any existing dashboards, the `ID: ${x.id}` will now output. If you have an invalid API name or action name, or no arguments provided, or improper/insufficient credentials configured, an error message will output as outlined in the `cli.js` file.

## DELETE a dashboard

To delete a dashboard, capture its ID from the previous exercise and take the following steps:

1. Outline your function, similar to the steps above. Note that the URL endpoint will look different, as you are accessing a different endpoint in this request (using a dashboard ID) than in the prior request (using a collection ID):

```javascript
async function deleteDashboard([dashboardId]) {
  console.log(`deleting dashboard ${dashboardId}`);

  const accessToken = await getAccessToken(authorizationConfiguration);

  const optimizeApiUrl = process.env.OPTIMIZE_BASE_URL;
  const url = `${optimizeApiUrl}/api/public/dashboard/${dashboardId}`;
}
```

2. Configure the API call using the DELETE method:

```javascript
const options = {
  method: "DELETE",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results from the API call. For example:

```javascript
try {
  // Call the delete endpoint.
  const response = await axios(options);

  // Process the results from the API call.
  if (response.status === 204) {
    console.log(`Dashboard ${clientId} was deleted!`);
  } else {
    // Emit an unexpected error message.
    console.error("Unable to delete dashboard!");
  }
} catch (error) {
  // Emit an error from the server.
  console.error(error.message);
}
```

4. In your terminal, run `node cli.js optimize delete <dashboard ID>`, where `<dashboard ID>` is where you can paste the ID of the dashboard you would like to delete. You will see a response similar to the following:

`Dashboard 12345 was deleted!`

## If you get stuck

Having trouble configuring your API calls or want to examine an example of the completed tutorial? Navigate to the `completed` folder in the [GitHub repository](https://github.com/camunda/camunda-api-tutorials/tree/main/completed), where you can view an example `optimize.js` file.

## Next steps

You can script several additional API calls as outlined in the [Optimize API reference material](./overview.md).

---

## Variable labeling

With the variable labeling endpoint, variable labels can be added, updated, and deleted from Optimize.

## Functionality

The variable labeling API allows users to add, update, and delete batches of variable label data, which Optimize stores in a dedicated
index. All variable label data includes a reference to the process definition each variable belongs to, which allows Optimize to display a variable's label instead of its original name anywhere the given process definition is being used. Some examples of that would be in reports, configuring filters, report grouping, dashboard filters, and event-based processes.

## Limitations

Note that this feature is currently not supported in task analysis. This means that during task analysis, the original name of a variable will be displayed.

## Authentication

Every request requires [authentication](./optimize-api-authentication.md).

## Method & HTTP target resource

POST `/api/public/variables/labels`

## Request headers

The following request headers must be provided with every variable labeling request:

| Header         | Constraints | Value                                              |
| -------------- | ----------- | -------------------------------------------------- |
| Authentication | REQUIRED\*  | [Authentication](./optimize-api-authentication.md) |

## Request body

The request body should contain a reference to the process definition using its key, as well as an array of variable labels. Each variable label object in the array must specify the name and type of the variable for which a label is being added, as well as the value of the label itself.

## Result

This method returns no content.

## Response codes

Possible HTTP Response Status codes:

| Code | Description                                                                             |
| ---- | --------------------------------------------------------------------------------------- |
| 204  | Request successful.                                                                     |
| 400  | Returned if some of the properties in the request body are invalid or missing.          |
| 401  | Secret incorrect or missing. See [authentication](#authentication) on how to authorize. |
| 404  | The process definition with the given definition key doesn't exist.                     |

## Example 1

Insert three labels for three variable for a given process definition

:::note
If the label exists already in the index, its value will be overridden.
:::

### Request

POST `/api/public/variables/labels`

Request Body:

```
        {
          "definitionKey": "bookrequest-1-tenant",
          "labels" : [
            {
              "variableName": "bookAvailable",
              "variableType": "Boolean",
              "variableLabel": "book availability"
            },
            {
              "variableName": "person.name",
              "variableType": "String",
              "variableLabel": "first and last name"
            },
            {
              "variableName": "person.hobbies._listSize",
              "variableType": "Long",
              "variableLabel": "amount of hobbies"
            }
          ]
        }
```

### Response

Status 204.

## Example 2

Delete a label for a variable belonging to a given process definition by inputting an empty
string for its value. If there is no label for the given variable in Elasticsearch, no operation is being conducted.

### Request

POST `/api/public/variables/labels`

Request Body:

```
      {
        "definitionKey": "bookrequest-1-tenant",
        "labels" : [
          {
            "variableName": "bookAvailable",
            "variableType": "Boolean",
            "variableLabel": ""
          }
        ]
      }
```

### Response

Status 204.

## Example 3

Insert and delete labels for two variables belonging to a given process definition. The following example adds a label for the variable with name **bookAvailable** and deletes a label for the variable with name **person.name**.

### Request

POST `/api/public/variables/labels`

Request Body:

```
      {
        "definitionKey": "bookrequest-1-tenant",
         "labels" : [
           {
             "variableName": "bookAvailable",
             "variableType": "Boolean",
             "variableLabel": "book availability"
           },
           {
             "variableName": "person.name",
             "variableType": "String",
             "variableLabel": ""
           },
         ]
       }
```

### Response

Status 204.

## Example 4

Attempting to insert multiple labels for the same variable will result to a 400 response code.

### Request

POST `/api/public/variables/labels`

Request Body:

```
      {
        "definitionKey": "someProcessDefinitionKey",
        "labels" : [
          {
            "variableName": "bookAvailable",
            "variableType": "Boolean",
            "variableLabel": "book availability"
          },
          {
            "variableName": "bookAvailable",
            "variableType": "Boolean",
            "variableLabel": "is book available"
          },
        ]
      }
```

### Response

Status 400.

---

## Orchestration Cluster MCP Server

<PageDescription />

## About

The Orchestration Cluster MCP Server is an API surface of the Orchestration Cluster that exposes Camunda's operational capabilities through the [Model Context Protocol](https://modelcontextprotocol.io/) (MCP).

- It enables AI agents and LLM-powered applications to discover and invoke Camunda tools using a standardized interface, without custom API integration code.
- Similar to the [Orchestration Cluster API](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md), the MCP server is built into the Orchestration Cluster and shares the same [authentication](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md) and [authorization](/components/concepts/access-control/authorizations.md) model. It can be enabled independently.

:::important Camunda 8 public API
The Orchestration Cluster MCP Server is not part of the [Camunda 8 public API](/reference/public-api.md).
:::

:::note
This is the Orchestration Cluster MCP Server documentation. If you are looking to:

- Expose your own BPMN processes as callable MCP tools for AI agents, see the [Processes MCP Server](../processes-mcp/processes-mcp-overview.md).
- Connect an AI agent running in a BPMN process to an external MCP server, see the [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client.md).
  :::

### Key features

Building AI-powered applications that interact with Camunda traditionally requires writing custom client code to call REST APIs, handle authentication, parse responses, and format data for AI consumption. The MCP server removes this by providing:

| Benefit             | Description                                                                                                               |
| :------------------ | :------------------------------------------------------------------------------------------------------------------------ |
| Standardized access | AI agents discover and invoke Camunda capabilities through the MCP protocol, without bespoke integration code.            |
| Tool discovery      | MCP clients automatically discover available tools and their schemas at runtime.                                          |
| Broad compatibility | Works with any MCP-compliant client, including VS Code (GitHub Copilot), Claude Code, Cursor, and custom AI applications. |
| Consistent security | Inherits the same authentication and authorization model as the REST API.                                                 |

### Authentication

The MCP server uses the same authentication model as the [Orchestration Cluster REST API](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md). OAuth tokens obtained for the REST API work without changes.

For SaaS environments:

1. [Create API client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console. Ensure the **Orchestration Cluster API** scope is enabled.
2. Use the generated **Client ID**, **Client secret**, **OAuth token endpoint**, and **audience** to obtain an access token via the [OAuth 2.0 client credentials flow](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md#using-a-token-oidcjwt).
3. Pass the token in the `Authorization: Bearer <token>` header, or use [`c8ctl mcp-proxy`](./orchestration-cluster-api-mcp-setup.md#using-c8ctl-mcp-proxy) to handle this automatically.

For the full authentication reference, including Self-Managed OIDC and basic authentication setup, see [Authentication](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md).

### Transport

The MCP server uses the [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#streamable-http) transport and is served at the `/mcp/cluster` endpoint. It is stateless and no session management is required.

## Get started

:::important Camunda 8.9
The MCP server is only available from Camunda 8.9 onwards.
:::

If you have a local Orchestration Cluster running with [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) or [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md), the MCP server is enabled by default. Connect any MCP client using this configuration:

```json
{
  "servers": {
    "camunda": {
      "type": "http",
      "url": "http://localhost:8080/mcp/cluster"
    }
  }
}
```

For production environments and other deployment types, the MCP server must be explicitly enabled on your cluster before use. See [Enable and connect](./orchestration-cluster-api-mcp-setup.md) for more details.

## Available tools

The MCP server exposes tools across the following domains:

| Domain              | Capabilities                                                              |
| :------------------ | :------------------------------------------------------------------------ |
| Cluster             | Check cluster health and retrieve topology information.                   |
| Incidents           | Search, retrieve, and resolve incidents.                                  |
| Process definitions | Search process definitions and retrieve BPMN XML.                         |
| Process instances   | Search, retrieve, and create process instances.                           |
| User tasks          | Search, retrieve, assign, and complete user tasks. Search task variables. |
| Variables           | Search and retrieve variables.                                            |

For the full list of available tools, see [Available tools](./orchestration-cluster-api-mcp-tools.md).

---

## Enable and connect

Enable the Orchestration Cluster MCP Server and configure MCP clients to connect.

## Enable the Orchestration Cluster MCP Server

The MCP server is enabled by default in [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) and [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md). For other deployment types, it must be explicitly enabled before MCP clients can connect.
Depending on your deployment, enable it as follows:

<Tabs groupId="deployment" defaultValue="c8run" queryString values={[
{label: 'Camunda 8 Run', value: 'c8run' },
{label: 'Docker Compose', value: 'docker-compose' },
{label: 'Helm / Kubernetes', value: 'helm' },
{label: 'SaaS', value: 'saas' },
]}>

<TabItem value="c8run">

The MCP server is **enabled by default** in Camunda 8 Run. No additional configuration is needed.

</TabItem>

<TabItem value="docker-compose">

The MCP server is **enabled by default** in the Docker Compose distribution. No additional configuration is needed.

</TabItem>

<TabItem value="helm">

Set the following [`extraConfiguration`](/self-managed/deployment/helm/configure/application-configs.md#configuration-options) value in your Helm chart values:

```yaml
orchestration:
  extraConfiguration:
    - file: mcp-gateway.yaml
      content: |
        camunda:
          mcp:
            enabled: true
```

</TabItem>

<TabItem value="saas">

In the Camunda Console, navigate to your cluster, open **Cluster Settings**, and enable **MCP Support**.

:::info
MCP server support is available on SaaS clusters running Camunda 8.9.0 or later.
:::

</TabItem>

</Tabs>

For a full reference of MCP configuration properties, see [Property reference](/self-managed/components/orchestration-cluster/core-settings/configuration/properties.md#api---mcp).

## Connect an MCP client

Once the MCP server is enabled, you can connect any MCP-compliant client. The approach depends on your client's capabilities and authentication requirements.

:::important
When you [create API client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console, all required connection details, including the base URL, OAuth endpoint, client ID, and audience, are displayed on the credentials page.
:::

### MCP endpoint URL

The MCP server is served at `/mcp/cluster` on the Orchestration Cluster. The full endpoint URL depends on your deployment type:

| Deployment                 | MCP endpoint URL                                                                |
| :------------------------- | :------------------------------------------------------------------------------ |
| Camunda 8 Run              | `http://localhost:8080/mcp/cluster`                                             |
| Docker Compose             | `http://localhost:8080/mcp/cluster`                                             |
| SaaS – public connectivity | `https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/mcp/cluster`                 |
| SaaS – secure connectivity | `https://${CLUSTER_ID}.${REGION_ID}.privateconnectivity.camunda.io/mcp/cluster` |
| Self-Managed (custom)      | `https://<your-host>/mcp/cluster`                                               |

For SaaS, find your **Region Id** and **Cluster Id** in the Camunda Console under **Cluster Details**.

### Direct HTTP connection

If your Orchestration Cluster does not require authentication, for example, when running locally with [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) or [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md), you can connect directly to the MCP server endpoint without any additional tooling.

Any MCP client that supports [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#streamable-http) can be used. For authenticated environments, [use c8ctl `mcp-proxy`](#use-c8ctl-mcp-proxy) instead.

```json
{
  "servers": {
    "camunda": {
      "type": "http",
      "url": "http://localhost:8080/mcp/cluster"
    }
  }
}
```

### Use c8ctl `mcp-proxy`

Many MCP clients, such as VS Code (GitHub Copilot) and Claude Code, do not natively support the OAuth 2.0 client credentials flow required for authenticated environments. The [c8ctl](https://github.com/camunda/c8ctl) `mcp-proxy` command bridges this gap by providing a local STDIO-to-Remote HTTP proxy that handles authentication transparently.

The proxy authenticates to the MCP server using OAuth 2.0 client credentials, and exposes a local STDIO MCP interface that your client connects to.

#### Prerequisites

- [Node.js](https://nodejs.org/) 18 or later.
- [Client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) for your Camunda cluster with the **Orchestration Cluster API** scope enabled.

#### Configuration

Add the following to your MCP client configuration.
For example, use the following in `claude_desktop_config.json` for Claude Code:

```json
{
  "mcpServers": {
    "camunda-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@camunda8/cli", "mcp-proxy"],
      "env": {
        "CAMUNDA_BASE_URL": "https://<cluster-base-url>",
        "CAMUNDA_CLIENT_ID": "<client-id>",
        "CAMUNDA_CLIENT_SECRET": "<client-secret>",
        "CAMUNDA_OAUTH_URL": "https://<token-url>/oauth/token",
        "CAMUNDA_TOKEN_AUDIENCE": "<token-audience>"
      }
    }
  }
}
```

| Variable                 | Description                                                                                                                                                                                                    |
| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CAMUNDA_BASE_URL`       | Base URL of your Orchestration Cluster, **without** the `/mcp/cluster` path (for example, the public `api.camunda.io` URL or the private `privateconnectivity.camunda.io` URL when using Secure connectivity). |
| `CAMUNDA_CLIENT_ID`      | OAuth client ID from your API client credentials.                                                                                                                                                              |
| `CAMUNDA_CLIENT_SECRET`  | OAuth client secret from your API client credentials.                                                                                                                                                          |
| `CAMUNDA_OAUTH_URL`      | OAuth token endpoint URL.                                                                                                                                                                                      |
| `CAMUNDA_TOKEN_AUDIENCE` | Token audience for the Orchestration Cluster API.                                                                                                                                                              |

:::tip Where to find these values
When you [create API client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console, all required connection details are displayed on the credentials page. You can also copy a ready-to-use c8ctl configuration snippet directly from the **MCP** tab on the credentials screen.
:::

For the full list of supported environment variables, see the [c8ctl documentation](https://github.com/camunda/c8ctl).

### Use with the MCP Client connectors

You can also connect to the MCP server from within a BPMN process using Camunda's [MCP Client connectors](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client.md). This allows an AI agent running in an agentic orchestration workflow to interact with Camunda's own operational data. For example, you can query incidents or start processes as part of an automated workflow.

<Tabs groupId="mcp-connector" defaultValue="remote" queryString values={[
{label: 'MCP Remote Client connector', value: 'remote' },
{label: 'MCP Client connector', value: 'client' },
]}>

<TabItem value="remote">

The [MCP Remote Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-remote-client-connector.md) connects to remote MCP servers over HTTP. Configure it in the properties panel with the following settings:

- **Transport type**: Streamable HTTP.
- **URL**: Your MCP endpoint URL (see [above](#mcp-endpoint-url)).
- **Authentication**: OAuth 2.0.

| Field                    | Value                                                                                                                                                   |
| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------ |
| OAuth 2.0 token endpoint | Your OAuth token endpoint (`https://login.cloud.camunda.io/oauth/token` for SaaS).                                                                      |
| Client ID                | Your OAuth client ID.                                                                                                                                   |
| Client secret            | Your OAuth client secret. Use [secrets](/components/hub/organization/manage-clusters/manage-secrets.md) (for example, `{{secrets.MCP_CLIENT_SECRET}}`). |
| Audience                 | The audience for your cluster API (`zeebe.camunda.io` for SaaS).                                                                                        |
| Client authentication    | Send client credentials in body.                                                                                                                        |

For more details, see [MCP Remote Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-remote-client-connector.md).

</TabItem>

<TabItem value="client">

The [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client-connector.md) manages persistent MCP connections through the connector runtime. Configure the Camunda MCP server as a remote HTTP client in your connector runtime configuration (for example, `application.yml`):

```yaml
camunda:
  connector:
    agenticai:
      mcp:
        client:
          enabled: true
          clients:
            camunda-mcp:
              type: http
              http:
                url: https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/mcp/cluster
                authentication:
                  type: oauth
                  oauth:
                    oauth-token-endpoint: https://login.cloud.camunda.io/oauth/token
                    client-id: <your-client-id>
                    client-secret: <your-client-secret>
                    audience: zeebe.camunda.io
                    client-authentication: credentials-body
```

The example above shows a SaaS configuration using the public endpoint. For clusters with Secure connectivity (AWS PrivateLink), set `url` to the private MCP endpoint URL shown in Camunda Console instead of the public `zeebe.camunda.io` host (the path still ends with `/mcp/cluster`).

For local unauthenticated setups, you can omit the `authentication` block and use `http://localhost:8080/mcp/cluster` as the URL.

Reference the client ID `camunda-mcp` in the MCP Client connector element template in your BPMN process. For more details, see [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client-connector.md).

</TabItem>

</Tabs>

---

## Available tools

The following tools are available through the Orchestration Cluster MCP server, grouped by domain.

:::info
Tool names, parameters, and response schemas are fully discoverable by MCP clients at runtime. The exact tool signatures may evolve across versions.
:::

## Cluster

| Tool               | Description                                                                           |
| :----------------- | :------------------------------------------------------------------------------------ |
| `getClusterStatus` | Returns whether the cluster is healthy (at least one partition has a healthy leader). |
| `getTopology`      | Returns cluster topology including brokers, partitions, roles, health, and versions.  |

## Incidents

| Tool              | Description                                                                                                                                 |
| :---------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
| `searchIncidents` | Search incidents with filters such as state, error type, element ID, creation time range, process definition key, and process instance key. |
| `getIncident`     | Retrieve an incident by key.                                                                                                                |
| `resolveIncident` | Resolve an incident. For job-related incidents, job retries are automatically updated.                                                      |

## Process definitions

| Tool                       | Description                                                   |
| :------------------------- | :------------------------------------------------------------ |
| `searchProcessDefinitions` | Search process definitions with filters such as name and key. |
| `getProcessDefinition`     | Retrieve a process definition by key.                         |
| `getProcessDefinitionXml`  | Retrieve the BPMN XML of a process definition.                |

## Process instances

| Tool                     | Description                                                                      |
| :----------------------- | :------------------------------------------------------------------------------- |
| `searchProcessInstances` | Search process instances with filters.                                           |
| `getProcessInstance`     | Retrieve a process instance by key.                                              |
| `createProcessInstance`  | Create a new process instance, optionally with variables or awaiting completion. |

## User tasks

| Tool                      | Description                                                                         |
| :------------------------ | :---------------------------------------------------------------------------------- |
| `searchUserTasks`         | Search user tasks with filters such as assignee, state, and process definition key. |
| `getUserTask`             | Retrieve a user task by key.                                                        |
| `completeUserTask`        | Complete a user task, optionally providing variables or a custom action.            |
| `assignUserTask`          | Update the assignment of a user task.                                               |
| `searchUserTaskVariables` | Search variables scoped to a specific user task.                                    |

## Variables

| Tool              | Description                    |
| :---------------- | :----------------------------- |
| `searchVariables` | Search variables with filters. |
| `getVariable`     | Retrieve a variable by key.    |

---

## Intermediate tutorial

Intermediate

In this tutorial, we'll step through examples to highlight the capabilities of the Orchestration Cluster REST API, such as deploying resources, creating and starting a process instance, and viewing a process instance by its key.

This tutorial is intended for intermediate users of the Orchestration Cluster REST API, using more sophisticated API calls and multipart requests. If you are new to the Orchestration Cluster REST API, we recommend starting with the [beginner tutorial](/apis-tools/orchestration-cluster-api-rest/tutorial.md).

## Prerequisites

| Requirement                                                                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| :------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Create a cluster](/components/hub/organization/manage-clusters/create-cluster.md)                             | If you haven't done so already, create a cluster.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [Create your first client](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) | Upon cluster creation, create your first client. Ensure you check the `Orchestration Cluster API` client scope box. Make sure you keep the generated client credentials in a safe place. The **Client secret** will not be shown again. For your convenience, you can also download the client information to your computer.                                                                                                                                                                                                                                          |
| Clone the [GitHub repository](https://github.com/camunda/camunda-api-tutorials)                                | In this tutorial, we use a JavaScript-written [GitHub repository](https://github.com/camunda/camunda-api-tutorials) to write and run requests. Clone this repo before getting started.                                                                                                                                                                                                                                                                                                                                                                                |
| Prepare resources                                                                                              | The first request we will run is a request to deploy one or more resources (such as processes, decision models, or forms). For the purposes of this tutorial, we have preconfigured a BPMN diagram and converted this into XML. This diagram, `calculate-sales-tax.bpmn`, can be found in the GitHub repository above within the `resources` folder. The BPMN diagram itself represents a process to calculate the total sales tax for a given purchase. You can take a closer look at this diagram by opening it in [Modeler](/components/modeler/about-modeler.md). |
| [Node.js](https://nodejs.org/en/download)                                                                      | Ensure you have [Node.js](https://nodejs.org/en/download) installed as this will be used for methods that can be called by the CLI (outlined later in this guide). Run `npm install` to ensure you have updated dependencies.                                                                                                                                                                                                                                                                                                                                         |
| Authenticate                                                                                                   | You need authentication to access the API endpoints. Find more information in [Camunda 8 authentication](./orchestration-cluster-api-rest-authentication.md), and the section below.                                                                                                                                                                                                                                                                                                                                                                                  |

### Set up authentication

If you're interested in how we use a library to handle auth for our code, or to get started, examine the `auth.js` file in the GitHub repository. This file contains a function named `getAccessToken` which executes an OAuth 2.0 protocol to retrieve authentication credentials based on your client ID and client secret. Then, we return the actual token that can be passed as an authorization header in each request.

To set up your credentials, create an `.env` file which will be protected by the `.gitignore` file. Add the following environment variables:

- `CAMUNDA_CLIENT_ID`
- `CAMUNDA_CLIENT_SECRET`
- `CAMUNDA_REST_ADDRESS` (after creating a client and downloading the .env variables, this is reflected in the Console UI as `ZEEBE_REST_ADDRESS`)
- `CAMUNDA_TOKEN_AUDIENCE` (represented as `ZEEBE_TOKEN_AUDIENCE` in the Console UI), which is `zeebe.camunda.io` in a Camunda 8 SaaS environment. For example, your audience may be defined as `CAMUNDA_TOKEN_AUDIENCE=zeebe.camunda.io`.

These keys will be consumed by the `auth.js` file to execute the OAuth protocol, and should be saved when you generate your client credentials in [prerequisites](#prerequisites).

See the existing `.env.example` file for an example of how your `.env` file should look upon completion. Do not place your credentials in the `.env.example` file, as this example file is not protected by the `.gitignore`.

:::note

In this tutorial, we will execute arguments to deploy a resource, create and start a process instance, and view a process instance by its key. You can examine the framework for processing these arguments in the `cli.js` file before getting started.

:::

## Deploy resources (POST)

First, let's script an API call to deploy a resource.

To do this, take the following steps:

1. In the file named `camunda-process-instances.js`, outline the authentication and authorization configuration in the first few lines. This will pull in your `.env` variables to obtain an access token before making any API calls:

```javascript
const authorizationConfiguration = {
  clientId: process.env.CAMUNDA_CLIENT_ID,
  clientSecret: process.env.CAMUNDA_CLIENT_SECRET,
  // These settings come from your .env file. Note that CAMUNDA_TOKEN_AUDIENCE is represented by ZEEBE_TOKEN_AUDIENCE in the Console UI.
  audience: process.env.CAMUNDA_TOKEN_AUDIENCE,
};
```

2. Examine the function `async function deployResources()` below this configuration. This is where you will script out your API call.
3. Within the function, you must first generate an access token for this request, so your function should now look like the following:

```javascript
async function deployResources() {
  const accessToken = await getAccessToken(authorizationConfiguration);
}
```

4. Using your generated client credentials from [prerequisites](#prerequisites), capture your Orchestration Cluster REST API URL beneath your call for an access token by defining `camundaApiUrl`:

```javascript
const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
```

5. On the next line, script the API endpoint to deploy the resources:

```javascript
const url = `${camundaApiUrl}/deployments`;
```

6. We will now configure the variables representing the BPMN file and its form data. This may look different depending on which resources you choose to deploy, but reflects the block-scoped local variables and append method to insert a set of objects for the BPMN resource of this tutorial:

```javascript
const formData = new FormData();
// Read the BPMN file and add it to the form data
const bpmnFilePath = path.resolve("resources/calculate-sales-tax.bpmn");
const fileContent = fs.readFileSync(bpmnFilePath);
formData.append("resources", fileContent, {
  filename: "calculate-sales-tax.bpmn",
  contentType: "application/xml",
});
```

:::note
The `resources` name must be exact according to the API requirements, the path to the file (`const bpmnFilePath = path.resolve("resources/calculate-sales-tax.bpmn");`) must be correct, and `contentType` must be `application/xml` to ensure the upload will not fail.
:::

7. Call the endpoint, process the results from the API call, and emit an error message from the server if necessary:

```javascript
try {
  const response = await axios.post(url, formData, {
    headers: {
      Accept: "application/json",
      Authorization: `Bearer ${accessToken}`,
      ...formData.getHeaders(),
    },
  });

  const deployedResources = response.data.deployments || [];

  // Emit deployed resources
  deployedResources.forEach((x) =>
    console.log(
      `Process Definition Key: ${x.processDefinition.processDefinitionKey}; Process Definition Id: ${x.processDefinition.processDefinitionId}`
    )
  );
} catch (error) {
  // Emit an error from the server.
  console.error(`Error deploying resources: ${error.message}`);
}
```

8. In your terminal, run `node cli.js processInstances deploy`.

:::note
This `deploy` command is connected to the `deployResources` function at the bottom of the `camunda-process-instances.js` file, and executed by the `cli.js` file. While we will work with process instances in this tutorial, you may add additional arguments depending on the API requests you want to make.
:::

The existing process definition key and ID will now output. If you have an invalid API name or action name, or no arguments provided, or improper/insufficient credentials configured, an error message will output as outlined in the `cli.js` file.

## Create and start a process instance (POST)

To create and start a process instance based on the process instance key obtained in the request above, take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function createInstance([processDefinitionKey]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
  const url = `${camundaApiUrl}/process-instances`;
}
```

2. Build the payload you will send to the endpoint:

```javascript
const payload = {
  processDefinitionKey,
  variables: {
    total: 90.0,
  },
};
```

:::note
The request will succeed if the variable names are different, but the process instance itself will not function as expected.
:::

3. Call the endpoint, process the results from the API call, and emit an error message from the server if necessary:

```javascript
try {
  const response = await axios.post(url, payload, {
    headers: {
      Accept: "application/json",
      Authorization: `Bearer ${accessToken}`,
    },
  });

  const processInstance = response.data;

  console.log(`Process Instance Key: ${processInstance.processInstanceKey}`);
} catch (error) {
  console.error(`Error creating process instance: ${error.message}`);
}
```

4. In your terminal, run `node cli.js processInstances create <key>`, where `<key>` is the process definition key. The `processInstanceKey` will now display in the output. Capture this key for a future method.

## Retrieve a process instance (GET)

To retrieve a process instance by the process instance key, take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function viewInstance([processInstanceKey]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
  const url = `${camundaApiUrl}/process-instances/${processInstanceKey}`;
}
```

2. Call the endpoint, process the results from the API call, and emit an error message from the server if necessary:

```javascript
try {
  const response = await axios.get(url, {
    headers: {
      Accept: "application/json",
      Authorization: `Bearer ${accessToken}`,
    },
  });

  const results = response.data;

  console.log(
    `Process instance name: ${results.processDefinitionName}; State: ${results.state};`
  );
} catch (error) {
  console.error(`Error retrieving process instance: ${error.message}`);
}
```

3. In your terminal, run `node cli.js processInstances view <key>`, where `<key>` is the process instance key. The `processDefinitionName` and `state` will then display in the output.

## Troubleshooting

Having trouble configuring your API calls or want to examine an example of the completed tutorial? Navigate to the `completed` folder in the [GitHub repository](https://github.com/camunda/camunda-api-tutorials/tree/main/completed), where you can view an example `camunda-process-instances.js` file.

## Next steps

You can script several additional API calls as outlined in the [Orchestration Cluster REST API reference material](./orchestration-cluster-api-rest-overview.md).

---

## Authentication(Orchestration-cluster-api-rest)

This page explains how to authenticate requests to the Orchestration Cluster REST API across different deployment environments.

## Authentication support matrix

| Distribution                                                                      | Default Authentication | No auth support         | Basic auth support | OIDC-based auth support |
| --------------------------------------------------------------------------------- | ---------------------- | ----------------------- | ------------------ | ----------------------- |
| [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md)           | None                   | ✅ (default)            | ✅ (when enabled)  | ✅ (when configured)    |
| [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md) | None                   | ✅ (default)            | ✅ (when enabled)  | ✅ (when configured)    |
| [Helm](/self-managed/deployment/helm/install/quick-install.md)                    | Basic Auth             | ✅ (when auth disabled) | ✅ (default)       | ✅ (when configured)    |
| SaaS                                                                              | OIDC-based Auth        | ❌                      | ❌                 | ✅ (required)           |

:::info Authentication vs. authorization
Authentication establishes who is calling the Orchestration Cluster REST API (for example, using basic authentication or an OIDC access token). Authorization determines what that caller can do, based on authorizations configured in Admin.

To learn more about authorization resources, permissions, and precedence (including user task permissions), see [Orchestration Cluster authorization](../../components/concepts/access-control/authorizations.md).
:::

## Authenticate API calls

### No authentication (local development)

By default, Camunda 8 Run and Docker Compose expose the Orchestration Cluster REST API without authentication for local development. You can make API requests directly:

```shell
curl http://localhost:8080/v2/topology
```

### Basic Authentication

Basic Authentication uses username and password credentials.

**For Camunda 8 Run:**  
Enable Basic Auth by configuring authentication in your `application.yaml`. See [Camunda 8 Run documentation](/self-managed/quickstart/developer-quickstart/c8run/configuration.md#enable-authentication-and-authorization) for details.

**For Helm:**  
Basic Auth is enabled by default for the Orchestration Cluster API.

Include your username and password in each API request:

```shell
curl --user username:password \
     http://localhost:8080/v2/topology
```

:::note
Basic Authentication checks the password with every request, limiting the number of requests per second. It may not be suitable for production.  
See [Camunda components troubleshooting](/self-managed/operational-guides/troubleshooting.md)
:::

## Using a token (OIDC/JWT)

OIDC-based authentication is recommended for production and required for SaaS. Obtain an access token and pass it as an OAuth 2.0 Bearer Token in the `Authorization` header of each request. The token's subject (user or client) must also have the required authorizations. Otherwise, requests fail with `403 Forbidden` even if authentication succeeds.

<Tabs groupId="environment" defaultValue="saas" queryString values={[
{label: 'SaaS', value: 'saas' },
{label: 'Self-Managed', value: 'self-managed' },
]}>

<TabItem value="saas">

1. [Create client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console.
2. Request an access token using the credentials:

```shell
curl --request POST ${CAMUNDA_OAUTH_URL} \
    --header 'Content-Type: application/x-www-form-urlencoded' \
    --data-urlencode 'grant_type=client_credentials' \
    --data-urlencode "audience=${CAMUNDA_TOKEN_AUDIENCE}" \
    --data-urlencode "client_id=${CAMUNDA_CLIENT_ID}" \
    --data-urlencode "client_secret=${CAMUNDA_CLIENT_SECRET}"
```

3. Use the access token from the response in your API requests:

```shell
curl --header "Authorization: Bearer ${ACCESS_TOKEN}" \
     ${BASE_URL}/topology
```

</TabItem>

<TabItem value="self-managed">

**Prerequisites for OIDC-based authentication**

- Your Orchestration Cluster must already be configured with your Identity Provider. See [Set up OIDC-based Authentication](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md).
- You must have a registered client in your IdP with a **client ID**, **client secret**, and authorization endpoint.
- Note the configured **audience** and **scope** for token requests (variables `OC_AUDIENCE` and `SCOPE`). Depends on IdP configuration.

**Request an access token using client credentials**

Example for Keycloak; adjust the authorization URI and parameters for your IdP:

```shell
curl --location --request POST 'http://<IDP_HOST>/auth/realms/<REALM>/protocol/openid-connect/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode "client_id=${CLIENT_ID}" \
--data-urlencode "client_secret=${CLIENT_SECRET}" \
--data-urlencode "audience=${OC_AUDIENCE}" \
--data-urlencode "scope=${SCOPE}" \
--data-urlencode 'grant_type=client_credentials'
```

> **Microsoft Entra ID**: Use `scope=${SCOPE}/.default` instead of `scope=${SCOPE}`. The Authorization URI is typically `https://login.microsoftonline.com/<tenant_id>/oauth2/v2.0/token`.

**Use the access token in API requests**

```shell
curl --header "Authorization: Bearer ${ACCESS_TOKEN}" \
     ${BASE_URL}/topology
```

</TabItem>

</Tabs>

### OIDC-based authentication using X.509 client certificates

For advanced security scenarios, you can obtain OIDC access tokens using X.509 client certificates. This is typically required in Self-Managed environments where your IdP enforces mutual TLS (mTLS).

**For Java applications**  
The Java client supports automatic OIDC access token retrieval using X.509 client certificates. Configure the necessary keystore and truststore via code or environment variables. See [Java client authentication](../java-client/getting-started.md#oidc-access-token-authentication-with-x509-client-certificate) for details.

**For other clients**  
Refer to your IdP documentation for obtaining tokens using X.509 certificates.

### Automatic token management in official clients

Official Camunda clients (Java client or Spring Boot Starter) handle token acquisition and renewal automatically. You do not need to manually obtain or refresh tokens.

### Troubleshooting

- Check logs for authentication errors.
- Verify your access token includes the correct audience if audience validation is enabled.

### Learn more

- [Camunda Java client authentication and token management](../java-client/getting-started.md)
- [Camunda Spring Boot Starter: Configuring the Camunda 8 connection](../camunda-spring-boot-starter/getting-started.md#configuring-the-camunda-8-connection)
- [Orchestration Cluster authorization: Resources, permissions, and configuration](../../components/concepts/access-control/authorizations.md)

---

## Data fetching

The Orchestration Cluster REST API allows you to retrieve data from key resources like process definitions, user tasks, users, and tenants. Each search-enabled endpoint supports rich filtering, sorting, and pagination so you can quickly find the data that matters most.

The sections below explain how to structure a search request and interpret the response format.

## Searchable resources

The following examples support search via POST endpoints, each with its own set of filterable fields:

- Process instances (`POST /v2/process-instances/search`)
- User tasks (`POST /v2/user-tasks/search`)
- Users (`POST /v2/users/search`)
- Batch operations (`POST /v2/batch-operations/search`)

Refer to the [interactive Orchestration Cluster REST API Explorer](./specifications/orchestration-cluster-api.info.mdx) for the full attribute lists.

## Supported operations

Most searchable resources allow:

- Filtering based on properties or variables
- Sorting results
- Paginating with either offset or cursor methods
- Accessing nested resources (e.g., group users)

> Example: You can search for groups using `POST /v2/groups/search`, and for the users in a group using `POST /v2/groups/:groupId/users/search`.

You can also fetch single resources using `GET` endpoints with unique identifiers, such as:

```shell
GET /v2/user-tasks/:userTaskKey
```

## Data consistency

Endpoints in the Orchestration Cluster API are classified as either **strongly consistent** or **eventually consistent**.  
This distinction applies to the _data behind the endpoint_, not the endpoint's functionality itself.

- **Strongly consistent endpoints** return data that reflects the real-time state of the system.
- **Eventually consistent endpoints** return data exported by the [Camunda Exporter](../../self-managed/components/orchestration-cluster/zeebe/exporters/camunda-exporter.md). This data may lag behind the real-time state until the exporter processes it, so it becomes consistent only after a delay.

Each endpoint is clearly labeled with its consistency type so you can account for this behavior in your applications.

### Why consistency matters

If eventual consistency is not handled properly, it can lead to unexpected results.

For example:

1. A resource is created using a strongly consistent endpoint.
2. An _immediate_ request to an eventually consistent endpoint for the same resource might return:
   - `404 Not Found` for a `GET` request, or
   - an empty result set for a search request.

This happens because the eventually consistent endpoint has not yet synced the new data. A later request will return the correct result once the data export completes.

If your application does not account for eventual consistency, you may encounter **non-deterministic runtime behavior**. Code paths that work reliably during development or testing may fail intermittently in production, especially under load, if this characteristic is ignored.

## User task support

The Orchestration Cluster REST API only supports Camunda user tasks (previously referred to as [Zeebe user tasks](../migration-manuals/migrate-to-camunda-user-tasks.md), which may still appear as `zeebe:userTask` in your XML content).

## Search requests

Search requests consist of the components for **filter**, **sort**, and **page**.

### Filter

The filter object defines which fields should match. Only items that match the given fields will be returned. The available fields vary by object and are described in the respective search endpoint. Filtering by a unique identifier is usually available in filtering options. Beyond that, the filter options don’t have to comprise all the returned items’ attributes.

<details>
<summary>Example</summary>

```
POST /v2/user-tasks/search

{
  "filter": {
    "assignee": "demo",
    "processInstanceKey": "22456786958"
  }
}
```

This filters by the attributes `assignee` and `processInstanceKey`, looking for exact matches with the provided values.

</details>

### Sort

The sort array specifies by which `field`s to sort the result items and whether this happens in ascending (ASC) or descending (DESC) `order`.

<details>
<summary>Example</summary>

```
POST /v2/user-tasks/search

{
  "sort": [
    { "field": "state", "order": "ASC" }
  ]
}
```

This sorts the overall result set by the `state` attribute in ascending order.

</details>

### Page

The page object details how to slice the result set. An initial search request can omit the page object or define the `limit`. This specifies the maximum number of results to retrieve per request. Subsequent requests can either use **cursor** or **offset pagination** to iterate through the result set.

Cursor pagination bases on the value of the [search response's](#search-responses) `startCursor` and `endCursor`. Copy `startCursor` into `before` or `endCursor` into `after` to page through results respectively. The [search example](#search-example) showcases how to use these attributes for cursor pagination.

Offset pagination uses the `from` attribute to define the starting point of the next set of items in the overall result set.

:::note
Choosing the right pagination type depends on the specific use case. The expected result set size and intended usage of the results have the biggest influence. The expected reliability and performance of the search request affect this decision as well.

Consider using cursor pagination for larger result sets and displaying result list that scroll infinitely.
Paged result sets can be realized with offset pagination in a straightforward way but come with performance penalties for larger result sets.
:::

<details>
<summary>Example</summary>

```
POST /v2/user-tasks/search

{
  "page": {
    "limit": 3
  }
}
```

This limits the result set returned in the response to 3 items, no matter how many overall results exist.

</details>

### Advanced search filters

To provide an easy yet expressive way for users to search for and filter resources, search requests can contain more advanced filter criteria than fields being _equal_ to a target value.

For example, this allows searching using logical (and, in) and comparison operators (greater than, less than). The list of generally supported advanced filter operators is described below. The supported operators depend on the endpoint and the type of the filter attribute. All endpoints document available operators for each attribute in the Orchestration Cluster REST API specification.

#### Conditional Operators

| Operator  | Syntax                                         | Description                                                                                                                                                                                                                      |
| --------- | ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `$eq`     | `field: { "$eq": value }`                      | Filter where `field` is equal to `value`. Abbreviated form `field: value` is also allowed.                                                                                                                                       |
| `$neq`    | `field: { "$neq": value }`                     | Filter where `field` is not equal to `value`.                                                                                                                                                                                    |
| `$exists` | `field: { "$exists": value }`                  | Filter where `field` does or does not exist. The `value` is a boolean and can be either `true` or `false`.                                                                                                                       |
| `$gt`     | `field: { "$gt": value }`                      | Filter where `field` is greater than `value`.                                                                                                                                                                                    |
| `$gte`    | `field: { "$gte": value }`                     | Filter where `field` is greater than or equal to `value`.                                                                                                                                                                        |
| `$lt`     | `field: { "$lt": value }`                      | Filter where `field` is less than `value`.                                                                                                                                                                                       |
| `$lte`    | `field: { "$lte": value }`                     | Filter where `field` is less than or equal to `value`.                                                                                                                                                                           |
| `$like`   | `field: { "$like": value }`                    | Filter where `field` contains a string like `value`. The wildcard characters `*` (zero, one, or multiple characters) and `?` (a single character) are allowed in `value`. They can be escaped with a backslash, like in `my \*`. |
| `$in`     | `field: { "$in": [ value1, value2, ... ] }`    | Filter where `field` is equal to at least one of the `value`s in the provided array.                                                                                                                                             |
| `$notIn`  | `field: { "$notIn": [ value1, value2, ... ] }` | Filter where `field` is not equal to any one of the `value`s in the provided array.                                                                                                                                              |

<details>
<summary>Example</summary>

```
POST /v2/user-tasks/search

{
  "filter": {
    "candidateGroups": { "$like": "external-*", "$neq": "external-supervisor" }
  }
}
```

This filters by `candidateGroups` that start with `"external-"` but do not match `"external-supervisor"`.

</details>

#### Logical Operators

| Operator | Syntax                                                        | Description                                                                                                                   |
| -------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `$or`    | `"$or": [ { condition1 }, { condition2 }, ... ]`              | Filter where at least one of the conditions is true.                                                                          |
| and      | `{ field: { "$lt": value1 }, field: { "$gt": value2 }, ... }` | All conditions outside of `$or` operators will be considered as combined by an `AND` operator. There is no explicit operator. |

<details>
<summary>Example</summary>

```
POST /v2/user-tasks/search

{
  "filter": {
    "assignee": "demo",
    "processInstanceKey": "22456786958",
    "candidateGroups": { "$neq": "external-supervisor", "$like": "external-*" }
  }
}
```

The top-level filters `assignee`, `processInstanceKey`, and `candidateGroups` are connected by an AND operator. Likewise, the `$neq` and `$like` advanced filter operators inside the top-level `candidateGroups` filter are combined by an AND operator.

</details>

#### Variables

Search endpoints can support filtering by variable values. This allows querying for process-related resources based on the values of specific variables that exist in their respective scope. For example, user task search supports filtering using the `localVariables` array and defining filter criteria for specific variables.

For variable values, the advanced filter criteria outlined above for fields apply.

<details>
<summary>Example</summary>

```
POST /v2/user-tasks/search

{
  "filter": {
    "localVariables" :  [
      { "name": "orderVolume", "value": "10000" },
      { "name": "price", "value": { "$lt": "500" } },
      { "name": "skipped", "value": { "$exists": false } }
    ]
  }
}
```

This filters for user tasks containing at least the variables `orderVolume` with a value of `10000` and `price` with a value lower than `500`, not containing variable `skipped`.

</details>

## Search responses

Search responses consist of two components: **`items`** and **`page`**.

- The **`items`** array contains instances of the respective endpoint’s resource.  
  The structure and attributes of these instances vary by endpoint and are detailed in the corresponding endpoint documentation.

- The **`page`** object includes pagination details for navigating through results in subsequent search requests:
  - **`totalItems`**: Indicates the total number of results for the query.
    > **Note:** In Elasticsearch/OpenSearch, this value is capped at **10,000**, even if more results are available.
  - **`startCursor`**: A reference to the **first** entry on the current page.  
    Use this value in the `before` parameter to page **backward** in a subsequent [search request](#search-requests).
  - **`endCursor`**: A reference to the **last** entry on the current page.  
    Use this value in the `after` parameter to page **forward** in a subsequent [search request](#search-requests).

<details>
<summary>Example</summary>

```
{
  "items": [
    {
      "state": "CREATED",
      "processInstanceKey": "22456786958",
      "userTaskKey": "22456786345",
      ...
    },
    {
      "state": "CREATED",
      "processInstanceKey": "22456786958",
      "userTaskKey": "22456786456",
      ...
    },
    {
      "state": "COMPLETED",
      "processInstanceKey": "22456786958",
      "userTaskKey": "22456786678",
      ...
    }
  ],
  "page": {
    "totalItems":  345,
    "startCursor": "jfenj8vhekgj98uzfafhu7",
    "endCursor": "negbkjeh84tzh4gk0kwegj"
  }
}
```

</details>

## Search example

Querying for the first three user tasks with certain criteria and sorted by state could look as follows:

```
POST /v2/user-tasks/search

{
  "filter": {
    "assignee": "demo",
    "processInstanceKey": "22456786958",
    "candidateGroups": { "$like": "external-*", "$neq": "external-supervisor" },
    "localVariables" :  [
      { "name": "orderVolume", "value": "10000" },
      { "name": "price", "value": { "$lt": "500" } },
      { "name": "skipped", "value": { "$exists": false } }
    ],
  },
  "sort": [
    { "field": "state", "order": "ASC" }
  ],
  "page": {
    "limit": 3
  }
}
```

This could yield the following example result:

```
200 OK

{
  "items": [
    {
      "state": "CREATED",
      "processInstanceKey": "22456786958",
      "userTaskKey": "22456786345",
      ...
    },
    {
      "state": "CREATED",
      "processInstanceKey": "22456786958",
      "userTaskKey": "22456786456",
      ...
    },
    {
      "state": "COMPLETED",
      "processInstanceKey": "22456786958",
      "userTaskKey": "22456786678",
      ...
    }
  ],
  "page": {
    "totalItems":  345,
    "startCursor": "jfenj8vhekgj98uzfafhu7",
    "endCursor": "negbkjeh84tzh4gk0kwegj"
  }
}
```

A follow-up request to receive the next three items could then look as follows:

```
POST /v2/user-tasks/search

{
  "filter": {
    "assignee": "demo",
    "processInstanceKey": "22456786958",
    "candidateGroups": { "$like": "external-*", "$neq": "external-supervisor" },
    "localVariables" :  [
      { "name": "orderVolume", "value": "10000" },
      { "name": "price", "value": { "$lt": "500" } },
      { "name": "skipped", "value": { "$exists": false } }
    ],
  },
  "sort": [
    { "field": "state", "order": "ASC" }
  ],
  "page": {
    "limit":  3,
    "after": "negbkjeh84tzh4gk0kwegj"
  }
}
```

This yields the next three user task instances after the last one from the first search request’s result.

---

## Orchestration Cluster REST API

<PageDescription />

## About

You can use the Orchestration Cluster REST API to interact programmatically with process orchestration capabilities in Camunda 8. For example, you can start, manage, and query process instances, complete user tasks, resolve incidents, and manage variables.

Use this API to:

| Use case                                    | Description                                                                       |
| :------------------------------------------ | :-------------------------------------------------------------------------------- |
| Build process-driven applications           | Create applications to orchestrate processes and integrate with existing systems. |
| Integrate user tasks into custom UIs        | Build task management interfaces that connect to Camunda's user task engine.      |
| Start and monitor external system processes | Trigger process instances and track progress from any application or service.     |

## Key features

This API is designed to make it easy to [find resources](./orchestration-cluster-api-rest-data-fetching.md#advanced-search-filters) with a consistent experience, while ensuring all endpoints are secure with [authentication](./orchestration-cluster-api-rest-authentication.md) and fine-grained [resource authorization](/components/concepts/access-control/authorizations.md).

Key features include:

| Feature                           | Description                                           |
| :-------------------------------- | :---------------------------------------------------- |
| Full process lifecycle management | Deploy, start, and monitor BPMN processes.            |
| User task operations              | Claim, complete, and manage human tasks.              |
| Variable management               | Read and update process variables.                    |
| Incident resolution               | Handle and resolve process incidents.                 |
| Advanced search and filtering     | Query process data with powerful search capabilities. |

:::info

- This API is part of the Camunda 8 [public API](/reference/public-api.md) and is covered by our SemVer stability guarantees (except for clearly marked alpha endpoints). You can rely on backward compatibility for production use.
- To learn more about the Orchestration Cluster, see [Orchestration Cluster](/components/orchestration-cluster.md).

:::

## Getting started

This section helps you get up and running in minutes.

### Prerequisites

- **A Camunda 8 Orchestration Cluster**
  - For local development, use [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) or [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md), which expose the API without requiring credentials or tokens by default.
  - For production or advanced development, use [Helm/Kubernetes](/self-managed/deployment/helm/install/quick-install.md) or [manual installation](/self-managed/deployment/manual/install.md).
  - Alternatively, sign up for a free [Camunda 8 SaaS trial](https://accounts.camunda.io/signup) to get a managed cluster with the API enabled.

- **A client to send API requests**
  - Quick testing: Use the [Swagger](../orchestration-cluster-api-rest-swagger) interface
  - Programmatic access: Use the [Java client](/apis-tools/java-client/getting-started.md) or [Camunda Spring Boot Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md)
  - Custom client: [Download the OpenAPI spec](https://github.com/camunda/camunda/blob/main/zeebe/gateway-protocol/src/main/proto/rest-api.yaml) to generate your own client
  - Universal client: [Postman collection](https://www.postman.com/camundateam/camunda-8-postman/collection/apl78x9/camunda-8-api-rest)

### Authentication

Authentication for the Orchestration Cluster REST API depends on your environment and how you deploy Camunda 8. Authenticate your Client requests based on your setup.

**Supported authentication methods**

- No authentication – For local development only
- Basic authentication – Username/password for simple setups
- OIDC-based authentication – Use OAuth2/OIDC tokens for production environments

**Quick reference**

- See the [authentication support matrix](./orchestration-cluster-api-rest-authentication.md#authentication-support-matrix) for details on supported methods by deployment type
- If you're using the Java or Spring clients, token management is handled automatically. See [client authentication configuration](../camunda-spring-boot-starter/getting-started.md#configuring-the-camunda-8-connection)

For detailed authentication setup, follow the step-by-step guide in [Authentication](./orchestration-cluster-api-rest-authentication.md) based on your deployment type.

### Test your connection

Once you're set up, verify your connection works by making your first API call:

#### Using curl

Local (Camunda 8 Run / Docker Compose):

```bash
curl http://localhost:8080/v2/topology
```

SaaS, public connectivity:

```bash
curl https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/v2/topology
```

SaaS, secure connectivity (AWS PrivateLink):

```bash
curl https://${CLUSTER_ID}.${REGION_ID}.privateconnectivity.camunda.io/api/v2/topology
```

Replace the placeholders with the values for your environment.
See [Base URLs](#base-urls) for details on SaaS (public and secure connectivity) and self-managed setups.

#### Using Postman

Try the [get cluster topology](https://www.postman.com/camundateam/camunda-8-postman/request/en495q6/get-cluster-typology) request or browse the full collection.

This request returns information about your cluster topology, confirming that your setup is working correctly.

### Try your first workflow

If you're just getting started with process automation, try this simple workflow:

1. **Model a process** – Create a simple BPMN process with a user task using [Camunda Modeler](https://camunda.com/download/modeler/)
2. **Deploy the process** – Use [`POST /deployments`](./specifications/create-deployment.api.mdx) to deploy your BPMN file
3. **Start a process instance** – Use [`POST /process-instances`](./specifications/create-process-instance.api.mdx) to create a new process instance
4. **Complete a user task** – Use [`POST /user-tasks/{userTaskKey}/completion`](./specifications/complete-user-task.api.mdx) to complete the task

For a complete walkthrough with code examples, see our [Getting Started Tutorial](/guides/getting-started-example.md).

### Explore the API

<ApiGrid items={apiExplorationCards} />

## API reference

This section covers the technical details and conventions you need to understand when working with the Orchestration Cluster REST API.

### Base URLs

#### SaaS

In the Camunda Console, go to your cluster, and in the Cluster Details, find your **Region Id** and **Cluster Id**.

- For public connectivity (default), use this pattern as your `${BASE_URL}`: `https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/v2/`

- For secure connectivity (AWS PrivateLink), use the private base URL shown in Console. For the Orchestration Cluster REST API, the pattern is:

  `${BASE_URL} = https://${CLUSTER_ID}.${REGION_ID}.privateconnectivity.camunda.io/api/v2/`

  For example: `https://b4102386-6818-43c6-a880-d21c968a883f.ork-1.privateconnectivity.camunda.io/api/v2/topology`

#### Self-Managed

Use the host and path defined for your [Zeebe Gateway](/reference/glossary.md#zeebe-gateway). For Ingress and routing details, see the [configuration guide](/self-managed/deployment/helm/configure/ingress/ingress-setup.md). If you're using the default setup, the `${BASE_URL}` is `http://localhost:8080/v2/`.

### Versioning

Camunda uses semantic versioning (SemVer) to ensure API changes are predictable and compatible. This helps you upgrade safely without unexpected breaking changes.

The API version is determined by the API version number (`v2`) and the product version—for example, `POST /v2/user-tasks/search` in Camunda 8.8.0.

Camunda versions the entire API rather than individual endpoints. If a breaking change occurs in any endpoint, the entire API is versioned. During migration periods, multiple API versions may coexist—for example, both `v2` and `v3` versions of `/user-tasks/search` may be available in the same release.

:::note
Adding new endpoints or attributes to existing responses is **not** considered a breaking change.
:::

### Request size limits

The default maximum request size for all requests (for example, to `POST /v2/deployments`) is 4MB. It can be configured in the Zeebe Gateway configuration using the `maxMessageSize` property. For more information, see the [Zeebe Gateway configuration reference](/self-managed/components/orchestration-cluster/zeebe/configuration/configuration.md#gateway-configuration).

### Naming conventions

Naming across the Orchestration Cluster REST API is simple, intuitive, and consistent to reduce friction when working with multiple endpoints.

The conventions include:

- **Nouns over verbs** – e.g., `assignment` instead of `assign`
- **Plural terms** for top-level resources – e.g., `user-tasks`
- **Kebab-case** for multiple words in path parameters – e.g., `user-tasks`
- **camelCase** for multiple words in query parameters – e.g., `userTaskKey`

These conventions are illustrated in the following endpoint example:

`POST /user-tasks/{userTaskKey}/assignment`

For IDs or similar short 2- or 3-letter words or acronyms, Camunda only capitalizes the first letter. If standalone, all letters are lowercase.

| Term | Usage                                      |
| ---- | ------------------------------------------ |
| ID   | `id` (standalone) or `processDefinitionId` |
| URL  | `url` (standalone) or `externalUrl`        |
| UUID | `uuid` (standalone) or `clusterUuid`       |

Identifiers follow a naming convention for parameters and data attributes alike:

- Unique technical identifiers are suffixed with **key**, for example, `userTaskKey`, `processInstanceKey`, or `userKey`. These are usually numeric values.
- Other identifiers, such as those copied from the BPMN XML, are typically suffixed with **id**, for example, `processDefinitionId`.
- Key and id fields contain the entity as a prefix, for example, `userTaskKey` or `processDefinitionId`. This applies when referencing other resources like `formKey` in the user task entity and the respective entities themselves like `userTaskKey` in the user task entity.
- The full entity name is used as the prefix to avoid confusion, for example, `processDefinitionKey` instead of `processKey`, which could be interpreted as a process instance or process definition.
- Other entity attributes do not have a prefix to avoid clutter, such as `version` in the process definition entity. However, references to other resources require a prefix, like `processDefinitionVersion` in the process instance entity.

### HTTP status codes & error handling

The Orchestration Cluster REST API uses standard HTTP status codes and returns error responses following the [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) format. Each error response includes the following fields:

- `type`: A URI identifier for the error type
- `status`: The HTTP status code (e.g., 400, 404)
- `title`: A short, human-readable summary of the error
- `detail`: A detailed explanation of the issue
- `instance`: A URI reference identifying the specific occurrence of the problem

#### Common error codes

| Error code | Meaning                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 200        | OK                                                                                                                                                                                                                                                                                                                                                                                                        |
| 204        | No content                                                                                                                                                                                                                                                                                                                                                                                                |
| 400        | Bad request. Generic error with further description in the problem detail.                                                                                                                                                                                                                                                                                                                                |
| 401        | Unauthorized. The client is not authenticated. Retry with a modified authorization header.                                                                                                                                                                                                                                                                                                                |
| 403        | Forbidden. The client has insufficient permissions for the request.                                                                                                                                                                                                                                                                                                                                       |
| 404        | Not found                                                                                                                                                                                                                                                                                                                                                                                                 |
| 409        | Conflict. The request attempts to modify a resource that is not in the correct state.                                                                                                                                                                                                                                                                                                                     |
| 412        | Precondition failed. The client should check the cluster status.                                                                                                                                                                                                                                                                                                                                          |
| 500        | Internal server error. Generic error with further description in the problem detail.                                                                                                                                                                                                                                                                                                                      |
| 503        | The service is currently unavailable. This may happen when the system signals backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism [here](../../components/zeebe/technical-concepts/internal-processing.md) |

### Date formats

Date values in the Orchestration Cluster REST API follow the [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339) notation. This applies to all requests and responses. The endpoints validate requests and transform responses accordingly.

### Variables

Variables in the Orchestration Cluster REST API are JSON objects, where `key` defines the variable name and `value` specifies the variable value.

For full details on variable filtering and structure, see [search requests](orchestration-cluster-api-rest-data-fetching.md#variables).

## What's next?

Now that you're familiar with the Orchestration Cluster REST API, here are some useful next steps:

- [Build a job worker using the Spring SDK](../camunda-spring-boot-starter/getting-started.md)
- [Test your process definitions using Camunda Process Test](../testing/getting-started.md)
- [Migrate from v1 component REST APIs to the v2 Orchestration Cluster REST API](../migration-manuals/migrate-to-camunda-api.md)
- [Download the OpenAPI spec](https://github.com/camunda/camunda/blob/main/zeebe/gateway-protocol/src/main/proto/rest-api.yaml) to generate a client or explore the raw schema

---

## Try with Swagger

The Orchestration Cluster REST API is documented using the [OpenAPI specification](https://github.com/camunda/camunda/blob/main/zeebe/gateway-protocol/src/main/proto/rest-api.yaml). You can explore, test, and interact with all API endpoints directly using [Swagger UI](https://swagger.io/tools/swagger-ui/) - an interactive documentation interface.

**Use Swagger UI to:**

- Explore available endpoints - Browse all REST API operations with detailed parameter descriptions
- Test API calls interactively - Execute real API requests directly from your browser
- Understand request/response formats - See example payloads and response schemas
- Authenticate and authorise - Test with your actual credentials in a secure environment

Swagger UI is particularly useful for API discovery, development, and testing workflows before integrating the API into your applications.

## Prerequisites

Before using Swagger UI, ensure you have:

- **A running Camunda 8 Orchestration Cluster:** SaaS or Self-Managed
- **Appropriate [access permissions](../../components/concepts/access-control/authorizations.md)** to the resources you want to manage via the API (if authorizations are enabled).

## Accessing Swagger UI

### SaaS

For SaaS clusters, Swagger UI is accessible through your cluster's dedicated endpoint.

1. In the Camunda Console, go to your cluster
2. In **Cluster Details**, find your **Region ID** and **Cluster ID**
3. Use this URL format: `https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/swagger`

:::note
Swagger UI is protected with CSRF. If you are logged into the Camunda Console, you can access Swagger UI directly. If not, you may need to log in first.
:::

**Example:**
If your Region ID is `bru-2` and Cluster ID is `abc123-def456-ghi789`, your Swagger UI URL would be:
`https://bru-2.api.camunda.io/abc123-def456-ghi789/swagger`

### Self-Managed

For Self-Managed deployments, Swagger UI is available at your configured [Zeebe Gateway](/reference/glossary.md#zeebe-gateway) endpoint.

**Default setup:**
`http://localhost:8080/swagger`

**Custom configuration:**
Use the host and path defined for your Zeebe Gateway in the [configuration guide](/self-managed/deployment/helm/configure/ingress/ingress-setup.md), then append `/swagger`.

**Example with custom domain:**
`https://your-zeebe-gateway.company.com/swagger`

## Authentication in Swagger UI

Swagger UI supports the same authentication methods as the REST API. Choose the method that matches your deployment:

### Automatic authentication

- **Session-based authentication**: If you're already logged into Camunda (for example, through Operate), Swagger UI automatically authenticates you using your session cookie

### Manual authentication

Click the **Authorize** button in Swagger UI to manually configure authentication:

#### Bearer Token (Recommended for production)

1. Click **Authorize** in Swagger UI
2. In the **Bearer** section, enter your JWT access token
3. Click **Authorize** to apply

**To obtain a Bearer token:**

- **SaaS**: Follow the [OIDC-based Authentication guide](./orchestration-cluster-api-rest-authentication.md#oidc-access-token-authentication-using-client-credentials) for SaaS
- **Self-Managed**: Follow the [OIDC-based Authentication guide](./orchestration-cluster-api-rest-authentication.md#oidc-access-token-authentication-using-client-credentials) for Self-Managed

#### Basic Authentication

1. Click **Authorize** in Swagger UI
2. In the **Basic** section, enter your username and password
3. Click **Authorize** to apply

**Note:** Basic Authentication is only available for Self-Managed deployments.

For detailed authentication setup instructions, see the [Authentication guide](./orchestration-cluster-api-rest-authentication.md).

## Using Swagger UI effectively

### Making your first API call

1. **Test connectivity**: Try the `GET /topology` endpoint to verify your connection and authentication
2. **Explore endpoints**: Browse the available operations organized by category (processes, user tasks, variables, etc.)
3. **Try sample requests**: Click "Try it out" on any endpoint to see the request form
4. **Execute requests**: Fill in parameters and click "Execute" to see real responses

### Understanding the interface

- **Endpoints are grouped by resource type** - Find process-related operations under "Process Instances", task operations under "User Tasks", etc.
- **Required parameters are marked** - Look for the red asterisk (\*) next to required fields
- **Example values are provided** - Use the "Example Value" links to populate request bodies quickly
- **Response schemas are documented** - Expand the response sections to understand the data structure

### Testing workflows

Use Swagger UI to test complete workflows:

1. **Deploy a process** - Use `POST /deployments` to upload a BPMN file
2. **Start a process instance** - Use `POST /process-instances` with your process definition
3. **Query and manage** - Use search endpoints to find and interact with your data
4. **Complete tasks** - Use `POST /user-tasks/{userTaskKey}/completion` to progress workflows

## Managing Swagger UI availability

### SaaS

Control Swagger UI access through the Camunda Console:

1. Navigate to your cluster in the Camunda Console
2. Go to **Cluster Settings**
3. Toggle **Enable Swagger** on or off
4. Changes apply automatically to your orchestration cluster

### Self-Managed

Configure Swagger UI availability using environment variables:

**Enable Swagger UI (default):**

```bash
CAMUNDA_REST_SWAGGER_ENABLED=true
```

**Disable Swagger UI:**

```bash
CAMUNDA_REST_SWAGGER_ENABLED=false
```

**Alternative property format:**

```yaml
camunda:
  rest:
    swagger:
      enabled: true
```

**Security consideration:** In production environments, consider disabling Swagger UI and using it only in development environments.

## Next steps

After exploring the API with Swagger UI:

- **Build production integrations** using the [Java client](/apis-tools/java-client/getting-started.md) or [Camunda Spring Boot Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md)
- **Review the complete API reference** in the [Overview](./orchestration-cluster-api-rest-overview.md)
- **Set up proper authentication** following the [Authentication guide](./orchestration-cluster-api-rest-authentication.md)
- **Learn advanced querying** with [Data Fetching and Search](./orchestration-cluster-api-rest-data-fetching.md)
- **Download the OpenAPI specification** for [custom client generation](https://github.com/camunda/camunda/blob/main/zeebe/gateway-protocol/src/main/proto/rest-api.yaml)

**Need help?** Try the [Getting Started Tutorial](/guides/getting-started-example.md) for a complete workflow walkthrough, or browse the [Postman collection](https://www.postman.com/camundateam/camunda-8-postman/collection/apl78x9/camunda-8-api-rest) for additional examples.

---

## Beginner tutorial

Beginner

In this tutorial, we'll step through examples to highlight the capabilities of the Orchestration Cluster REST API, such as listing all roles, creating a role, retrieving a role, and deleting a role.

## Prerequisites

- If you haven't done so already, [create a cluster](/components/hub/organization/manage-clusters/create-cluster.md).
- Upon cluster creation, [create your first client](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client). Ensure you check the `Orchestration Cluster API` client scope box.

:::note
Make sure you keep the generated client credentials in a safe place. The **Client secret** will not be shown again. For your convenience, you can download the client information to your computer.
:::

- In this tutorial, we utilize a JavaScript-written [GitHub repository](https://github.com/camunda/camunda-api-tutorials) to write and run requests. Clone this repo before getting started.
- Ensure you have [Node.js](https://nodejs.org/en/download) installed as this will be used for methods that can be called by the CLI (outlined later in this guide). Run `npm install` to ensure you have updated dependencies.

## Getting started

- You need authentication to access the API endpoints. Find more information [here](./orchestration-cluster-api-rest-authentication.md).

## Set up authentication

If you're interested in how we use a library to handle auth for our code, or to get started, examine the `auth.js` file in the GitHub repository. This file contains a function named `getAccessToken` which executes an OAuth 2.0 protocol to retrieve authentication credentials based on your client ID and client secret. Then, we return the actual token that can be passed as an authorization header in each request.

To set up your credentials, create an `.env` file which will be protected by the `.gitignore` file. You will need to add the following:

- `CAMUNDA_CLIENT_ID`
- `CAMUNDA_CLIENT_SECRET`
- `CAMUNDA_REST_ADDRESS` (after creating a client and downloading the .env variables, this is reflected in the Console UI as `ZEEBE_REST_ADDRESS`)
- `CAMUNDA_TOKEN_AUDIENCE` (represented as `ZEEBE_TOKEN_AUDIENCE` in the Console UI), which is `zeebe.camunda.io` in a Camunda 8 SaaS environment. For example, your audience may be defined as `CAMUNDA_TOKEN_AUDIENCE=zeebe.camunda.io`.

These keys will be consumed by the `auth.js` file to execute the OAuth protocol, and should be saved when you generate your client credentials in [prerequisites](#prerequisites).

Examine the existing `.env.example` file for an example of how your `.env` file should look upon completion. Do not place your credentials in the `.env.example` file, as this example file is not protected by the `.gitignore`.

:::note
In this tutorial, we will execute arguments to list all roles, create a role, retrieve a role, and delete a role. You can examine the framework for processing these arguments in the `cli.js` file before getting started.
:::

## List all roles (POST)

First, let's script an API call to list all existing roles.

To do this, take the following steps:

1. In the file named `camunda-8.js`, outline the authentication configuration in the first few lines. This will pull in your `.env` variables to obtain an access token before making any API calls:

```javascript
const authorizationConfiguration = {
  clientId: process.env.CAMUNDA_CLIENT_ID,
  clientSecret: process.env.CAMUNDA_CLIENT_SECRET,
  audience: process.env.CAMUNDA_TOKEN_AUDIENCE,
};
```

2. Examine the function `async function listRoles()` below this configuration. This is where you will script out your API call.

3. Within the function, you must first generate an access token for this request, so your function should now look like the following:

```javascript
async function listRoles() {
  const accessToken = await getAccessToken(authorizationConfiguration);
}
```

4. Using your generated client credentials from [prerequisites](#prerequisites), capture your Orchestration Cluster REST API URL beneath your call for an access token by defining `camundaApiUrl`:

```javascript
const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
```

On the next line, script the API endpoint to list the existing roles:

```javascript
const url = `${camundaApiUrl}/roles/search`;
```

5. Configure your POST request to the appropriate endpoint, including an authorization header based on the previously acquired `accessToken`:

```javascript
const options = {
  method: "POST",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
  data: {},
};
```

6. Call the endpoint, process the results from the API call, and emit an error message from the server if necessary:

```javascript
try {
  const response = await axios(options);
  const results = response.data;
  results.items.forEach((x) =>
    console.log(`Role Name: ${x.name}; key: ${x.key}`)
  );
} catch (error) {
  console.error(error.message);
}
```

7. In your terminal, run `node cli.js camunda8 list`.

:::note
This `list` command is connected to the `listRoles` function at the bottom of the `camunda-8.js` file, and executed by the `cli.js` file. While we will work with roles in this tutorial, you may add additional arguments depending on the API calls you would like to make.
:::

The existing roles (if any) will now output. If you have an invalid API name or action name, or no arguments provided, or improper/insufficient credentials configured, an error message will output as outlined in the `cli.js` file. If no action is provided, it will default to "assign" everywhere, except when unassigning a user.

## Create a role (POST)

1. Outline your function:

```javascript
async function createRole([roleName]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
  const url = `${camundaApiUrl}/roles`;
}
```

2. Configure the API call:

```javascript
const options = {
  method: "POST",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
  data: {
    name: roleName,
  },
};
```

3. Process the results:

```javascript
try {
  const response = await axios(options);
  const newRole = response.data;
  console.log(`Role added! Name: ${roleName}. Key: ${newRole.roleKey}.`);
} catch (error) {
  console.error(error.message);
}
```

4. Run in your terminal `node cli.js camunda8 create <name>`.

## Retrieve a role (GET)

1. Outline your function:

```javascript
async function getRole([roleKey]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
  const url = `${camundaApiUrl}/roles/${roleKey}`;
}
```

2. Configure the API call.

```javascript
const options = {
  method: "GET",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results:

```javascript
try {
  const response = await axios(options);
  const results = response.data;
  console.log(`Role Name: ${results.name}; Key: ${results.key};`);
} catch (error) {
  console.error(error.message);
}
```

4. Run in your terminal `node cli.js camunda8 view <role>`.

## Delete a role (DELETE)

1. Outline your function:

```javascript
async function deleteRole([roleKey]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const camundaApiUrl = process.env.CAMUNDA_REST_ADDRESS;
  const url = `${camundaApiUrl}/roles/${roleKey}`;
}
```

2. Configure the API call:

```javascript
const options = {
  method: "DELETE",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results:

```javascript
try {
  const response = await axios(options);
  if (response.status === 204) {
    console.log("Role deleted!");
  } else {
    console.error("Unable to delete this role!");
  }
} catch (error) {
  console.error(error.message);
}
```

4. Run in your terminal `node cli.js camunda8 delete <role>`.

## If you get stuck

Having trouble configuring your API calls or want to examine an example of the completed tutorial? Navigate to the `completed` folder in the [GitHub repository](https://github.com/camunda/camunda-api-tutorials/tree/main/completed), where you can view an example `camunda-8.js` file.

## Next steps

You can script several additional API calls as outlined in the [Orchestration Cluster REST API reference material](./orchestration-cluster-api-rest-overview.md).

---

## Processes MCP Server

<PageDescription />

## About

The Processes MCP Server is a capability of the Orchestration Cluster that exposes your deployed BPMN processes as callable tools through the [Model Context Protocol](https://modelcontextprotocol.io/) (MCP).

- Any process equipped with an [MCP start event](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-start-event.md) element template is automatically registered as an MCP tool when deployed.
- MCP clients discover these tools at runtime and invoke them by name. Each invocation starts a new process instance and returns the started process instance key immediately.
- The server shares the same [authentication](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md) and [authorization](/components/concepts/access-control/authorizations.md) model as the Orchestration Cluster REST API.

:::important Camunda 8 public API
The Processes MCP Server is not part of the [Camunda 8 public API](/reference/public-api.md).
:::

:::note
This is the Processes MCP Server documentation. If you are looking to:

- Give AI agents access to Camunda's operational capabilities, such as incidents, user tasks, and process instances, see the [Orchestration Cluster MCP Server](../orchestration-cluster-api-mcp/orchestration-cluster-api-mcp-overview.md).
- Connect an AI agent running inside a BPMN process to an external MCP server, see the [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client.md).
  :::

### Key features

| Feature                   | Description                                                                                                                                                  |
| :------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Process tool registration | Processes with an MCP start event are automatically registered as MCP tools on deployment.                                                                   |
| Tool discovery            | MCP clients discover available process tools and their schemas at runtime.                                                                                   |
| Static tools              | The server also exposes a set of [static tools](#static-tools) for inspecting running process instances.                                                     |
| Version binding           | Only the latest deployed version of a process is exposed. See [Version binding](./processes-mcp-version-binding.md).                                         |
| Standard transport        | Uses [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#streamable-http), compatible with any MCP-compliant client. |

### Authentication

The Processes MCP Server uses the same authentication model as the [Orchestration Cluster REST API](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md). OAuth tokens obtained for the REST API work without changes.

For the full authentication reference, including SaaS and Self-Managed setup, see [Authentication](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md).

### Transport

The Processes MCP Server uses [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#streamable-http) and is served at the `/mcp/processes` endpoint on the Orchestration Cluster. It is stateless; no session management is required.

### Audit logging for MCP operations

Operations triggered through the Processes MCP Server are recorded in the [audit log](/components/audit-log/overview.md), like any other operation. Because the tool call enters through MCP, each resulting record has an inbound channel of `MCP` and captures the name of the MCP tool that triggered it, so you can distinguish operations initiated by AI agents through MCP from those performed directly by users or clients.

See [inbound channel](/components/audit-log/overview/operation-structure.md#inbound-channel) for details on how this is presented in the applications and the REST API.

:::note
The Processes MCP Server uses the same authentication as the REST API, so a tool call is attributed to the authenticated user or client.

By default, [only user operations are recorded](/components/audit-log/overview/recorded-operations.md#limitations-and-constraints), not client operations. To capture MCP tool calls made by a client, configure the audit log to also track client operations.
:::

## Get started

:::important Camunda 8.10
The Processes MCP Server is only available from Camunda 8.10 onwards.
:::

To expose a BPMN process as an MCP tool, see [Expose a process as an MCP tool](/components/agentic-orchestration/expose-process-as-mcp-tool.md).

If you have a local Orchestration Cluster running with [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) or [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md), the Processes MCP Server is enabled by default. Connect any MCP client using this configuration:

```json
{
  "servers": {
    "camunda-processes": {
      "type": "http",
      "url": "http://localhost:8080/mcp/processes"
    }
  }
}
```

For production environments and other deployment types, the Processes MCP Server must be explicitly enabled before use. See [Enable and connect](./processes-mcp-setup.md) for more details.

## Static tools

In addition to dynamically registered process tools, the Processes MCP Server exposes a set of static tools for inspecting the process instances it starts.
See [static tools](./processes-mcp-static-tools.md) for more details.

---

## Enable and connect(Processes-mcp)

Enable the Processes MCP Server and configure MCP clients to connect.

## Enable the Processes MCP Server

The Processes MCP Server is enabled by default in [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) and [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md). For other deployment types, it must be explicitly enabled before MCP clients can connect.
Depending on your deployment, enable it as follows:

<Tabs groupId="deployment" defaultValue="c8run" queryString values={[
{label: 'Camunda 8 Run', value: 'c8run' },
{label: 'Docker Compose', value: 'docker-compose' },
{label: 'Helm / Kubernetes', value: 'helm' },
{label: 'SaaS', value: 'saas' },
]}>

<TabItem value="c8run">

The Processes MCP Server is **enabled by default** in Camunda 8 Run. No additional configuration is needed.

</TabItem>

<TabItem value="docker-compose">

The Processes MCP Server is **enabled by default** in the Docker Compose distribution. No additional configuration is needed.

</TabItem>

<TabItem value="helm">

Set the following [`extraConfiguration`](/self-managed/deployment/helm/configure/application-configs.md#configuration-options) value in your Helm chart values:

```yaml
orchestration:
  extraConfiguration:
    - file: mcp-gateway.yaml
      content: |
        camunda:
          mcp:
            enabled: true
```

</TabItem>

<TabItem value="saas">

In the Camunda Console, navigate to your cluster, open **Cluster Settings**, and enable **MCP Support**.

:::info
MCP server support is available on SaaS clusters running Camunda 8.10.0 or later.
:::

</TabItem>

</Tabs>

For a full reference of MCP configuration properties, see [Property reference](/self-managed/components/orchestration-cluster/core-settings/configuration/properties.md#api---mcp).

## Connect an MCP client

Once the Processes MCP Server is enabled, you can connect any MCP-compliant client. The approach depends on your client's capabilities and authentication requirements.

:::important
When you [create API client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console, all required connection details, including the base URL, OAuth endpoint, client ID, and audience, are displayed on the credentials page.
:::

### MCP endpoint URL

The Processes MCP Server is served at `/mcp/processes` on the Orchestration Cluster. The full endpoint URL depends on your deployment type:

| Deployment                 | MCP endpoint URL                                                                  |
| :------------------------- | :-------------------------------------------------------------------------------- |
| Camunda 8 Run              | `http://localhost:8080/mcp/processes`                                             |
| Docker Compose             | `http://localhost:8080/mcp/processes`                                             |
| SaaS – public connectivity | `https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/mcp/processes`                 |
| SaaS – secure connectivity | `https://${CLUSTER_ID}.${REGION_ID}.privateconnectivity.camunda.io/mcp/processes` |
| Self-Managed (custom)      | `https://<your-host>/mcp/processes`                                               |

For SaaS, find your **Region Id** and **Cluster Id** in the Camunda Console under **Cluster Details**.

### Direct HTTP connection

If your Orchestration Cluster does not require authentication, for example, when running locally with [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) or [Docker Compose](/self-managed/quickstart/developer-quickstart/docker-compose.md), you can connect directly to the MCP server endpoint without any additional tooling.

Any MCP client that supports [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports#streamable-http) can be used. For authenticated environments, [use c8ctl `mcp-proxy`](#use-c8ctl-mcp-proxy) instead.

```json
{
  "servers": {
    "camunda-processes": {
      "type": "http",
      "url": "http://localhost:8080/mcp/processes"
    }
  }
}
```

### Use c8ctl `mcp-proxy`

Many MCP clients, such as VS Code (GitHub Copilot) and Claude Code, do not natively support the OAuth 2.0 client credentials flow required for authenticated environments. The [c8ctl](https://github.com/camunda/c8ctl) `mcp-proxy` command bridges this gap by providing a local STDIO-to-Remote HTTP proxy that handles authentication transparently.

The proxy authenticates to the MCP server using OAuth 2.0 client credentials, and exposes a local STDIO MCP interface that your client connects to.

#### Prerequisites

- [Node.js](https://nodejs.org/) 18 or later.
- [Client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) for your Camunda cluster with the **Orchestration Cluster API** scope enabled.

#### Configuration

Add the following to your MCP client configuration.
For example, use the following in `claude_desktop_config.json` for Claude Code:

```json
{
  "mcpServers": {
    "camunda-processes": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@camunda8/cli", "mcp-proxy", "/mcp/processes"],
      "env": {
        "CAMUNDA_BASE_URL": "https://<cluster-base-url>",
        "CAMUNDA_CLIENT_ID": "<client-id>",
        "CAMUNDA_CLIENT_SECRET": "<client-secret>",
        "CAMUNDA_OAUTH_URL": "https://<token-url>/oauth/token",
        "CAMUNDA_TOKEN_AUDIENCE": "<token-audience>"
      }
    }
  }
}
```

| Variable                 | Description                                                                                                                                                                                                      |
| :----------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CAMUNDA_BASE_URL`       | Base URL of your Orchestration Cluster, **without** the `/mcp/processes` path (for example, the public `api.camunda.io` URL or the private `privateconnectivity.camunda.io` URL when using Secure connectivity). |
| `CAMUNDA_CLIENT_ID`      | OAuth client ID from your API client credentials.                                                                                                                                                                |
| `CAMUNDA_CLIENT_SECRET`  | OAuth client secret from your API client credentials.                                                                                                                                                            |
| `CAMUNDA_OAUTH_URL`      | OAuth token endpoint URL.                                                                                                                                                                                        |
| `CAMUNDA_TOKEN_AUDIENCE` | Token audience for the Orchestration Cluster API.                                                                                                                                                                |

:::tip Where to find these values
When you [create API client credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client) in the Camunda Console, all required connection details are displayed on the credentials page. You can also copy a ready-to-use c8ctl configuration snippet directly from the **MCP** tab on the credentials screen.
:::

For the full list of supported environment variables, see the [c8ctl documentation](https://github.com/camunda/c8ctl).

### Use with the MCP Client connectors

You can also connect to the Processes MCP Server from within a BPMN process using Camunda's [MCP Client connectors](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client.md). This allows an AI agent running in an agentic orchestration workflow to invoke your deployed processes as MCP tools.

<Tabs groupId="mcp-connector" defaultValue="remote" queryString values={[
{label: 'MCP Remote Client connector', value: 'remote' },
{label: 'MCP Client connector', value: 'client' },
]}>

<TabItem value="remote">

The [MCP Remote Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-remote-client-connector.md) connects to remote MCP servers over HTTP. Configure it in the properties panel with the following settings:

- **Transport type**: Streamable HTTP.
- **URL**: Your MCP endpoint URL (see [above](#mcp-endpoint-url)).
- **Authentication**: OAuth 2.0.

| Field                    | Value                                                                                                                                                   |
| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------ |
| OAuth 2.0 token endpoint | Your OAuth token endpoint (`https://login.cloud.camunda.io/oauth/token` for SaaS).                                                                      |
| Client ID                | Your OAuth client ID.                                                                                                                                   |
| Client secret            | Your OAuth client secret. Use [secrets](/components/hub/organization/manage-clusters/manage-secrets.md) (for example, `{{secrets.MCP_CLIENT_SECRET}}`). |
| Audience                 | The audience for your cluster API (`zeebe.camunda.io` for SaaS).                                                                                        |
| Client authentication    | Send client credentials in body.                                                                                                                        |

For more details, see [MCP Remote Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-remote-client-connector.md).

</TabItem>

<TabItem value="client">

The [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client-connector.md) manages persistent MCP connections through the connector runtime. Configure the Processes MCP Server as a remote HTTP client in your connector runtime configuration (for example, `application.yml`):

```yaml
camunda:
  connector:
    agenticai:
      mcp:
        client:
          enabled: true
          clients:
            camunda-processes:
              type: http
              http:
                url: https://${REGION_ID}.api.camunda.io/${CLUSTER_ID}/mcp/processes
                authentication:
                  type: oauth
                  oauth:
                    oauth-token-endpoint: https://login.cloud.camunda.io/oauth/token
                    client-id: <your-client-id>
                    client-secret: <your-client-secret>
                    audience: zeebe.camunda.io
                    client-authentication: credentials-body
```

The example above shows a SaaS configuration using the public endpoint. For clusters with Secure connectivity (AWS PrivateLink), set `url` to the private MCP endpoint URL shown in Camunda Console instead of the public `zeebe.camunda.io` host (the path still ends with `/mcp/processes`).

For local unauthenticated setups, you can omit the `authentication` block and use `http://localhost:8080/mcp/processes` as the URL.

Reference the client ID `camunda-processes` in the MCP Client connector element template in your BPMN process. For more details, see [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client-connector.md).

</TabItem>

</Tabs>

---

## Static tools

The Processes MCP Server exposes the following static tools alongside dynamically registered process tools.

These tools let an MCP agent inspect the process instance it just started, including its variables, state, and incidents, without switching to a different MCP server.

| Tool                 | Description                                                 |
| :------------------- | :---------------------------------------------------------- |
| `searchVariables`    | Search and inspect variables of a running process instance. |
| `getProcessInstance` | Retrieve the state and details of a process instance.       |
| `searchIncidents`    | Inspect incidents raised on a running process instance.     |

:::note
These tools are a subset of the [Orchestration Cluster MCP Server tools](../orchestration-cluster-api-mcp/orchestration-cluster-api-mcp-tools.md). Refer to that page for full parameter and response schema details.
:::

---

## Version binding

Understand how the Processes MCP Server handles process version binding, stale tool references after redeployment, and best practices for managing breaking changes.

## Which version is exposed

The Processes MCP Server always exposes only the **latest deployed version** of a process. When you deploy a new version of a process, it replaces the previous version's tool registration. There is no mechanism to pin an MCP client to a specific process version.

## Stale tool references

MCP clients typically cache the tool list after connecting. If a client cached the tool list before a redeployment and then attempts to call the now-replaced tool, it receives an error instructing it to refresh its tool list by running tool discovery again.

MCP clients must therefore:

1. Handle the stale-tool error gracefully.
2. Re-fetch the tool list by running tool discovery again before retrying.

## Implications for process owners

Redeploying a process with a changed interface, such as a different tool name, input parameters, or output variables, is a breaking change for any MCP client currently holding a reference to that tool.

To reduce disruption:

- Communicate planned redeployments to teams operating MCP clients that use your process tool.
- When making a significant interface change, consider deploying a new process with a different tool name rather than redeploying over the existing one. This lets existing clients continue using the old version while new clients adopt the updated tool.

---

## CamundaAsyncClient


## CamundaAsyncClient

```python
class CamundaAsyncClient(configuration=None, auth_provider=None, logger=None, **kwargs)
```

Bases: `object`

**Parameters:**

| Parameter       | Type                                                                                                                   | Description |
| --------------- | ---------------------------------------------------------------------------------------------------------------------- | ----------- |
| `configuration` | [CamundaSdkConfiguration](runtime.md#camunda_orchestration_sdk.runtime.configuration_resolver.CamundaSdkConfiguration) |             |
| `auth_provider` | [AuthProvider](runtime.md#camunda_orchestration_sdk.runtime.auth.AuthProvider)                                         |             |
| `logger`        | [CamundaLogger](runtime.md#camunda_orchestration_sdk.runtime.logging.CamundaLogger) \| `None`                          |             |
| `kwargs`        | `Any`                                                                                                                  |             |

### aclose()

```python
async def aclose()
```

Close underlying HTTP clients.

This closes both the API client’s async httpx client and, when available,
the auth provider’s token client.

- **Return type:**
  None

### activate_ad_hoc_sub_process_activities()

```python
async def activate_ad_hoc_sub_process_activities(ad_hoc_sub_process_instance_key, *, data, **kwargs)
```

Activate activities within an ad-hoc sub-process

> Activates selected activities within an ad-hoc sub-process identified by element ID.
>
> The provided element IDs must exist within the ad-hoc sub-process instance identified by the
> provided adHocSubProcessInstanceKey.

**Parameters:**

| Parameter                         | Type                                           | Description                                                             |
| --------------------------------- | ---------------------------------------------- | ----------------------------------------------------------------------- |
| `ad_hoc_sub_process_instance_key` | `str`                                          | System-generated key for a element instance. Example: 2251799813686789. |
| `data`                            | `AdHocSubProcessActivateActivitiesInstruction` |                                                                         |
| `kwargs`                          | `Any`                                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The ad-hoc sub-process instance is not found or the provided key does not identify an ad-hoc sub-process.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Activate ad-hoc sub-process activities:**

```python
def activate_ad_hoc_sub_process_activities_example(element_id: ElementId) -> None:
    client = CamundaClient()

    client.activate_ad_hoc_sub_process_activities(
        ad_hoc_sub_process_instance_key="123456",
        data=AdHocSubProcessActivateActivitiesInstruction(
            elements=[
                AdHocSubProcessActivateActivityReference(element_id=element_id),
                AdHocSubProcessActivateActivityReference(element_id=element_id),
            ],
        ),
    )
```

### activate_jobs()

```python
async def activate_jobs(*, data, **kwargs)
```

Activate jobs

> Iterate through all known partitions and activate jobs up to the requested maximum.

**Parameters:**

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `data`    | `JobActivationRequest` |             |
| `kwargs`  | `Any`                  |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobActivationResult
- **Return type:**
  JobActivationResult

#### Examples

**Activate and process jobs:**

```python
async def activate_jobs_example() -> None:
    async with CamundaAsyncClient() as client:
        result = await client.activate_jobs(
            data=JobActivationRequest(
                type_="payment-processing",
                timeout=30000,
                max_jobs_to_activate=5,
            )
        )

        for job in result.jobs:
            print(f"Job {job.job_key}: {job.type_}")
```

### assign_client_to_group()

```python
async def assign_client_to_group(group_id, client_id, **kwargs)
```

Assign a client to a group

> Assigns a client to a group, making it a member of the group.
>
> Members of the group inherit the group authorizations, roles, and tenant assignments.

**Parameters:**

| Parameter   | Type   | Description                                             |
| ----------- | ------ | ------------------------------------------------------- |
| `group_id`  | `str`  | The unique identifier of a group. Example: engineering. |
| `client_id` | str) – |                                                         |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The client with the given ID is already assigned to the group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a client to a group:**

```python
def assign_client_to_group_example(group_id: GroupId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.assign_client_to_group(
        group_id=group_id,
        client_id=client_id,
    )
```

### assign_client_to_tenant()

```python
async def assign_client_to_tenant(tenant_id, client_id, **kwargs)
```

Assign a client to a tenant

> Assign the client to the specified tenant.
>
> The client can then access tenant data and perform authorized actions.

**Parameters:**

| Parameter   | Type   | Description                                                     |
| ----------- | ------ | --------------------------------------------------------------- |
| `tenant_id` | `str`  | The unique identifier of the tenant. Example: customer-service. |
| `client_id` | str) – |                                                                 |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The tenant was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a client to a tenant:**

```python
def assign_client_to_tenant_example(tenant_id: TenantId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.assign_client_to_tenant(
        tenant_id=tenant_id,
        client_id=client_id,
    )
```

### assign_group_to_tenant()

```python
async def assign_group_to_tenant(tenant_id, group_id, **kwargs)
```

Assign a group to a tenant

> Assigns a group to a specified tenant.
>
> Group members (users, clients) can then access tenant data and perform authorized actions.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `group_id`  | `str` | The unique identifier of a group. Example: engineering.         |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or group was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a group to a tenant:**

```python
def assign_group_to_tenant_example(tenant_id: TenantId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.assign_group_to_tenant(
        tenant_id=tenant_id,
        group_id=group_id,
    )
```

### assign_mapping_rule_to_group()

```python
async def assign_mapping_rule_to_group(group_id, mapping_rule_id, **kwargs)
```

Assign a mapping rule to a group

> Assigns a mapping rule to a group.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `group_id`        | `str` | The unique identifier of a group. Example: engineering.            |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or mapping rule with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The mapping rule with the given ID is already assigned to the group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a mapping rule to a group:**

```python
def assign_mapping_rule_to_group_example(group_id: GroupId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.assign_mapping_rule_to_group(
        group_id=group_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### assign_mapping_rule_to_tenant()

```python
async def assign_mapping_rule_to_tenant(tenant_id, mapping_rule_id, **kwargs)
```

Assign a mapping rule to a tenant

> Assign a single mapping rule to a specified tenant.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `tenant_id`       | `str` | The unique identifier of the tenant. Example: customer-service.    |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or mapping rule was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a mapping rule to a tenant:**

```python
def assign_mapping_rule_to_tenant_example(tenant_id: TenantId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.assign_mapping_rule_to_tenant(
        tenant_id=tenant_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### assign_process_instance_business_id()

```python
async def assign_process_instance_business_id(process_instance_key, *, data, **kwargs)
```

Assign business id to process instance

> Assigns a business id to an already-running process instance that currently has none.
>
> The assignment is single and irreversible: only artifacts created after the assignment
> (for example future jobs, user tasks, decision instances, and message subscriptions) carry
> the business id, while existing artifacts are not retroactively enriched. Re-sending the
> same business id succeeds as a no-op. This endpoint is only useful while business id
> uniqueness enforcement is disabled; when it is enabled, the request is rejected with a 409
> response.

**Parameters:**

| Parameter              | Type                                             | Description                                                                         |
| ---------------------- | ------------------------------------------------ | ----------------------------------------------------------------------------------- |
| `process_instance_key` | `str`                                            | System-generated key for a process instance. Example: 2251799813690746.             |
| `data`                 | `ProcessInstanceBusinessIdAssignmentInstruction` | The instruction describing the business id to assign to a running process instance. |
| `kwargs`               | `Any`                                            |                                                                                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The business id assignment failed because the process instance is not eligible, for example it already has a different business id, it is a call-activity child, or business id uniqueness enforcement is enabled. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a business id to a process instance:**

```python
def assign_process_instance_business_id_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.assign_process_instance_business_id(
        process_instance_key=process_instance_key,
        data=ProcessInstanceBusinessIdAssignmentInstruction(
            business_id="order-12345",
        ),
    )
```

### assign_role_to_client()

```python
async def assign_role_to_client(role_id, client_id, **kwargs)
```

Assign a role to a client

> Assigns the specified role to the client. The client will inherit the authorizations associated with
> this role.

**Parameters:**

| Parameter   | Type   | Description                                      |
| ----------- | ------ | ------------------------------------------------ |
| `role_id`   | `str`  | The unique identifier of a role. Example: admin. |
| `client_id` | str) – |                                                  |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The role was already assigned to the client with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a client:**

```python
def assign_role_to_client_example(role_id: RoleId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.assign_role_to_client(
        role_id=role_id,
        client_id=client_id,
    )
```

### assign_role_to_group()

```python
async def assign_role_to_group(role_id, group_id, **kwargs)
```

Assign a role to a group

> Assigns the specified role to the group. Every member of the group (user or client) will inherit the
> authorizations associated with this role.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `role_id`  | `str` | The unique identifier of a role. Example: admin.        |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or group with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The role is already assigned to the group with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a group:**

```python
def assign_role_to_group_example(role_id: RoleId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.assign_role_to_group(
        role_id=role_id,
        group_id=group_id,
    )
```

### assign_role_to_mapping_rule()

```python
async def assign_role_to_mapping_rule(role_id, mapping_rule_id, **kwargs)
```

Assign a role to a mapping rule

> Assigns a role to a mapping rule.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `role_id`         | `str` | The unique identifier of a role. Example: admin.                   |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or mapping rule with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The role is already assigned to the mapping rule with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a mapping rule:**

```python
def assign_role_to_mapping_rule_example(role_id: RoleId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.assign_role_to_mapping_rule(
        role_id=role_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### assign_role_to_tenant()

```python
async def assign_role_to_tenant(tenant_id, role_id, **kwargs)
```

Assign a role to a tenant

> Assigns a role to a specified tenant.
>
> Users, Clients or Groups, that have the role assigned, will get access to the tenant’s data and can
> perform actions according to their authorizations.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `role_id`   | `str` | The unique identifier of a role. Example: admin.                |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or role was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a tenant:**

```python
def assign_role_to_tenant_example(tenant_id: TenantId, role_id: RoleId) -> None:
    client = CamundaClient()

    client.assign_role_to_tenant(
        tenant_id=tenant_id,
        role_id=role_id,
    )
```

### assign_role_to_user()

```python
async def assign_role_to_user(role_id, username, **kwargs)
```

Assign a role to a user

> Assigns the specified role to the user. The user will inherit the authorizations associated with
> this role.

**Parameters:**

| Parameter  | Type  | Description                                      |
| ---------- | ----- | ------------------------------------------------ |
| `role_id`  | `str` | The unique identifier of a role. Example: admin. |
| `username` | `str` | The unique name of a user. Example: swillis.     |
| `kwargs`   | `Any` |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or user with the given ID or username was not found.
  - **errors.ConflictError** – If the response status code is 409. The role is already assigned to the user with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a user:**

```python
def assign_role_to_user_example(role_id: RoleId, username: Username) -> None:
    client = CamundaClient()

    client.assign_role_to_user(
        role_id=role_id,
        username=username,
    )
```

### assign_user_task()

```python
async def assign_user_task(user_task_key, *, data, **kwargs)
```

Assign user task

> Assigns a user task with the given key to the given assignee. Assignment waits for blocking task
> listeners on this lifecycle transition. If listener processing is delayed beyond the request
> timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with
> backoff and inspect listener worker availability and logs when this repeats.

**Parameters:**

| Parameter       | Type                        | Description                           |
| --------------- | --------------------------- | ------------------------------------- |
| `user_task_key` | `str`                       | System-generated key for a user task. |
| `data`          | `UserTaskAssignmentRequest` |                                       |
| `kwargs`        | `Any`                       |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a user task:**

```python
def assign_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    client.assign_user_task(
        user_task_key=user_task_key,
        data=UserTaskAssignmentRequest(
            assignee="user@example.com",
        ),
    )
```

### assign_user_to_group()

```python
async def assign_user_to_group(group_id, username, **kwargs)
```

Assign a user to a group

> Assigns a user to a group, making the user a member of the group.
>
> Group members inherit the group authorizations, roles, and tenant assignments.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `username` | `str` | The unique name of a user. Example: swillis.            |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or user with the given ID or username was not found.
  - **errors.ConflictError** – If the response status code is 409. The user with the given ID is already assigned to the group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a user to a group:**

```python
def assign_user_to_group_example(group_id: GroupId, username: Username) -> None:
    client = CamundaClient()

    client.assign_user_to_group(
        group_id=group_id,
        username=username,
    )
```

### assign_user_to_tenant()

```python
async def assign_user_to_tenant(tenant_id, username, **kwargs)
```

Assign a user to a tenant

> Assign a single user to a specified tenant. The user can then access tenant data and perform
> authorized actions.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `username`  | `str` | The unique name of a user. Example: swillis.                    |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or user was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a user to a tenant:**

```python
def assign_user_to_tenant_example(tenant_id: TenantId, username: Username) -> None:
    client = CamundaClient()

    client.assign_user_to_tenant(
        tenant_id=tenant_id,
        username=username,
    )
```

### auth_provider

```python
auth_provider: [AuthProvider](runtime.md#camunda_orchestration_sdk.runtime.auth.AuthProvider)
```

### broadcast_signal()

```python
async def broadcast_signal(*, data, **kwargs)
```

Broadcast signal

> Broadcasts a signal.

**Parameters:**

| Parameter | Type                     | Description |
| --------- | ------------------------ | ----------- |
| `data`    | `SignalBroadcastRequest` |             |
| `kwargs`  | `Any`                    |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The signal is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  SignalBroadcastResult
- **Return type:**
  SignalBroadcastResult

#### Examples

**Broadcast a signal:**

```python
def broadcast_signal_example() -> None:
    client = CamundaClient()

    result = client.broadcast_signal(
        data=SignalBroadcastRequest(
            signal_name="order-cancelled",
        )
    )

    print(f"Signal key: {result.signal_key}")
```

### cancel_batch_operation()

```python
async def cancel_batch_operation(batch_operation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Cancel Batch operation

> Cancels a running batch operation.
>
> This is done asynchronously, the progress can be tracked using the batch operation status endpoint
> (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter             | Type             | Description                                                             |
| --------------------- | ---------------- | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`            | System-generated key for an batch operation. Example: 2251799813684321. |
| `data`                | `Any` \| `Unset` |                                                                         |
| `kwargs`              | `Any`            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The batch operation was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Cancel a batch operation:**

```python
def cancel_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    client.cancel_batch_operation(
        batch_operation_key=batch_operation_key,
    )
```

### cancel_process_instance()

```python
async def cancel_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Cancel process instance

> Cancels a running process instance. As a cancellation includes more than just the removal of the
> process instance resource, the cancellation resource must be posted. Cancellation can wait on
> listener-related processing; when that processing does not complete in time, this endpoint can
> return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener
> worker availability and logs when this repeats.

**Parameters:**

| Parameter              | Type                                                | Description                                                             |
| ---------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                               | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `CancelProcessInstanceRequest` \| `None` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                               |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Cancel a process instance:**

```python
def cancel_process_instance_example(process_definition_id: ProcessDefinitionId) -> None:
    client = CamundaClient()

    # Create a process instance and get its key from the response
    created = client.create_process_instance(
        data=ProcessCreationById(process_definition_id=process_definition_id)
    )

    # Cancel it using the key from the creation response
    client.cancel_process_instance(
        process_instance_key=created.process_instance_key,
    )
```

### cancel_process_instances_batch_operation()

```python
async def cancel_process_instances_batch_operation(*, data, **kwargs)
```

Cancel process instances (batch)

> Cancels multiple running process instances.
>
> Since only ACTIVE root instances can be cancelled, any given filters for state and
> parentProcessInstanceKey are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                               | Description                                                                          |
| --------- | -------------------------------------------------- | ------------------------------------------------------------------------------------ |
| `data`    | `ProcessInstanceCancellationBatchOperationRequest` | The process instance filter that defines which process instances should be canceled. |
| `kwargs`  | `Any`                                              |                                                                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Cancel process instances in batch:**

```python
def cancel_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.cancel_process_instances_batch_operation(
        data=ProcessInstanceCancellationBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### change_cluster_mode()

```python
async def change_cluster_mode(*, mode, dry_run=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Change cluster mode

> Transitions the cluster between processing and recovery mode. This is a non-blocking operation: the
> request is acknowledged once the change has been accepted, before the transition itself has
> completed. Entering recovery mode deactivates all partitions so that only a restricted set of read-
> only operations remains available; exiting recovery mode returns the cluster to normal processing.
> Returns the planned cluster change so its progress can be monitored via the topology.

**Parameters:**

| Parameter | Type                    | Description |
| --------- | ----------------------- | ----------- |
| `mode`    | `ChangeClusterModeMode` |             |
| `dry_run` | `bool` \| `Unset`       |             |
| `kwargs`  | `Any`                   |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterModeChangeResponse
- **Return type:**
  ClusterModeChangeResponse

#### Examples

**Change cluster mode:**

```python
def change_cluster_mode_example() -> None:
    client = CamundaClient()

    # Pass dry_run=True to validate the request and inspect the resulting plan
    # without applying it. Omit it (or set it to False) to trigger the transition.
    result = client.change_cluster_mode(
        mode=ChangeClusterModeMode.RECOVERING,
        dry_run=True,
    )

    print(f"Cluster change {result.change_id}:")
    for operation in result.planned_changes:
        suffix = f" -> {operation.mode}" if operation.mode else ""
        print(f"  {operation.operation}{suffix}")
```

### client

```python
client: [Client](configuration.md#camunda_orchestration_sdk.Client) | [AuthenticatedClient](configuration.md#camunda_orchestration_sdk.AuthenticatedClient)
```

### complete_job()

```python
async def complete_job(job_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Complete job

> Complete a job with the given payload, which allows completing the associated service task.

**Parameters:**

| Parameter | Type                              | Description                                                |
| --------- | --------------------------------- | ---------------------------------------------------------- |
| `job_key` | `str`                             | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobCompletionRequest` \| `Unset` |                                                            |
| `kwargs`  | `Any`                             |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Complete a job:**

```python
def complete_job_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.complete_job(
        job_key=job_key,
        data=JobCompletionRequest(
            variables=JobCompletionRequestVariables.from_dict(
                {"paymentId": "PAY-123", "status": "completed"}
            )
        ),
    )
```

### complete_user_task()

```python
async def complete_user_task(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Complete user task

> Completes a user task with the given key. Completion waits for blocking task listeners on this
> lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint
> can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect
> listener worker availability and logs when this repeats.

**Parameters:**

| Parameter       | Type                                   | Description                           |
| --------------- | -------------------------------------- | ------------------------------------- |
| `user_task_key` | `str`                                  | System-generated key for a user task. |
| `data`          | `UserTaskCompletionRequest` \| `Unset` |                                       |
| `kwargs`        | `Any`                                  |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Complete a user task:**

```python
def complete_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    variables = UserTaskCompletionRequestVariables()
    variables["approved"] = True

    client.complete_user_task(
        user_task_key=user_task_key,
        data=UserTaskCompletionRequest(
            variables=variables,
        ),
    )
```

### configuration

```python
configuration: [CamundaSdkConfiguration](runtime.md#camunda_orchestration_sdk.runtime.configuration_resolver.CamundaSdkConfiguration)
```

### correlate_message()

```python
async def correlate_message(*, data, **kwargs)
```

Correlate message

> Publishes a message and correlates it to a subscription.
>
> If correlation is successful it will return the first process instance key the message correlated
> with.
> The message is not buffered.
> Use the publish message endpoint to send messages that can be buffered.

**Parameters:**

| Parameter | Type                        | Description |
| --------- | --------------------------- | ----------- |
| `data`    | `MessageCorrelationRequest` |             |
| `kwargs`  | `Any`                       |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MessageCorrelationResult
- **Return type:**
  MessageCorrelationResult

#### Examples

**Correlate a message:**

```python
def correlate_message_example() -> None:
    client = CamundaClient()

    result = client.correlate_message(
        data=MessageCorrelationRequest(
            name="payment-received",
            correlation_key="order-12345",
        )
    )

    print(f"Message key: {result.message_key}")
```

### create_admin_user()

```python
async def create_admin_user(*, data, **kwargs)
```

Create admin user

> Creates a new user and assigns the admin role to it. This endpoint is only usable when users are
> managed in the Orchestration Cluster and while no user is assigned to the admin role.

**Parameters:**

| Parameter | Type          | Description |
| --------- | ------------- | ----------- |
| `data`    | `UserRequest` |             |
| `kwargs`  | `Any`         |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A user with this username already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserCreateResult
- **Return type:**
  UserCreateResult

#### Examples

**Create an admin user:**

```python
def create_admin_user_example(username: Username) -> None:
    client = CamundaClient()

    result = client.create_admin_user(
        data=UserRequest(
            username=username,
            name="Admin User",
            email="admin@example.com",
            password="admin-password",
        ),
    )

    print(f"Admin user: {result.username}")
```

### create_agent_instance()

```python
async def create_agent_instance(*, data, **kwargs)
```

Create agent instance

> Creates a new agent instance. The returned key identifies the instance and must
> be used in subsequent update and query calls.

**Parameters:**

| Parameter | Type                           | Description                             |
| --------- | ------------------------------ | --------------------------------------- |
| `data`    | `AgentInstanceCreationRequest` | Request to create a new agent instance. |
| `kwargs`  | `Any`                          |                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The elementInstanceKey does not correspond to an active element instance. More details are provided in the response body.
  - **errors.ConflictError** – If the response status code is 409. An agent instance already exists for the given element instance.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceCreationResult
- **Return type:**
  AgentInstanceCreationResult

#### Examples

**Create an agent instance:**

```python
def create_agent_instance_example(element_instance_key: ElementInstanceKey) -> None:
    client = CamundaClient()

    result = client.create_agent_instance(
        data=AgentInstanceCreationRequest(
            element_instance_key=element_instance_key,
            definition=AgentInstanceCreationRequestDefinition(
                model="gpt-4o",
                provider="openai",
                system_prompt="You are a helpful assistant.",
            ),
        ),
    )

    print(f"Created agent instance: {result.agent_instance_key}")
```

### create_agent_instance_history_item()

```python
async def create_agent_instance_history_item(agent_instance_key, *, data, **kwargs)
```

Create agent instance history item

> Appends a single history item to an agent instance’s conversation history.
>
> The created item has commitStatus PENDING until the job identified by jobLease
> completes successfully, at which point it transitions to COMMITTED. If the job
> fails or is superseded by a retry, the item is marked DISCARDED.

**Parameters:**

| Parameter            | Type                              | Description                                                                          |
| -------------------- | --------------------------------- | ------------------------------------------------------------------------------------ |
| `agent_instance_key` | `str`                             | System-generated key for an agent instance. Example: 4503599627370496.               |
| `data`               | `AgentInstanceHistoryItemRequest` | Request to append a single history item to an agent instance’s conversation history. |
| `kwargs`             | `Any`                             |                                                                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found, or the specified jobKey does not correspond to an active job. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceHistoryItemCreationResult
- **Return type:**
  AgentInstanceHistoryItemCreationResult

#### Examples

**Append an agent instance history item:**

```python
def create_agent_instance_history_item_example(
    agent_instance_key: AgentInstanceKey,
    element_instance_key: ElementInstanceKey,
    job_key: JobKey,
) -> None:
    client = CamundaClient()

    result = client.create_agent_instance_history_item(
        agent_instance_key=agent_instance_key,
        data=AgentInstanceHistoryItemRequest(
            element_instance_key=element_instance_key,
            job_key=job_key,
            job_lease="lease-token",
            role=AgentInstanceHistoryItemRequestRole.ASSISTANT,
            content=[TextContent(content_type="TEXT", text="How can I help you today?")],
            produced_at=datetime.datetime.now(datetime.timezone.utc),
        ),
    )

    print(f"Created history item: {result.history_item_key}")
```

### create_authorization()

```python
async def create_authorization(*, data, **kwargs)
```

Create authorization

> Create the authorization.

**Parameters:**

| Parameter | Type                                                                 | Description |
| --------- | -------------------------------------------------------------------- | ----------- |
| `data`    | `AuthorizationIdBasedRequest` \| `AuthorizationPropertyBasedRequest` |             |
| `kwargs`  | `Any`                                                                |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The owner was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuthorizationCreateResult
- **Return type:**
  AuthorizationCreateResult

#### Examples

**Create an authorization:**

```python
def create_authorization_example() -> None:
    client = CamundaClient()

    result = client.create_authorization(
        data=AuthorizationIdBasedRequest(
            resource_type=AuthorizationIdBasedRequestResourceType.PROCESS_DEFINITION,
            permission_types=[
                AuthorizationIdBasedRequestPermissionTypesItem.READ,
                AuthorizationIdBasedRequestPermissionTypesItem.UPDATE,
            ],
            resource_id="my-process",
            owner_type=OwnerTypeEnum.USER,
            owner_id="user@example.com",
        ),
    )

    print(f"Authorization key: {result.authorization_key}")
```

### create_deployment()

```python
async def create_deployment(*, data, **kwargs)
```

Deploy resources

> Deploys one or more resources, including BPMN processes, DMN decision models, forms, RPA resources,
> and generic files.
> A deployment can contain any file type. Files that are not interpreted as BPMN, DMN, form, or RPA
> resources are stored as deployable generic resources in the engine.
> This is an atomic call, i.e. either all resources are deployed or none of them are.

**Parameters:**

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `data`    | `CreateDeploymentData` |             |
| `kwargs`  | `Any`                  |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DeploymentResult
- **Return type:**
  DeploymentResult

#### Examples

**From files:**

```python
def deploy_resources_example() -> None:
    client = CamundaClient()

    result = client.deploy_resources_from_files(
        ["order-process.bpmn", "decision.dmn"]
    )

    print(f"Deployment key: {result.deployment_key}")
    for process in result.processes:
        print(
            f"  Process: {process.process_definition_id} v{process.process_definition_version}"
        )
    for decision in result.decisions:
        print(f"  Decision: {decision.decision_definition_id}")
```

**With tenant ID:**

```python
def deploy_resources_with_tenant_example() -> None:
    client = CamundaClient()

    result = client.deploy_resources_from_files(
        ["order-process.bpmn"],
        tenant_id="my-tenant",
    )

    print(f"Deployment key: {result.deployment_key}")
    print(f"Tenant: {result.tenant_id}")
```

### create_document()

```python
async def create_document(*, data, store_id=<camunda_orchestration_sdk.types.Unset object>, document_id=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Upload document

> Upload a document to the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter     | Type                 | Description                                      |
| ------------- | -------------------- | ------------------------------------------------ |
| `store_id`    | `str` \| `Unset`     |                                                  |
| `document_id` | `str` \| `Unset`     | Document Id that uniquely identifies a document. |
| `data`        | `CreateDocumentData` |                                                  |
| `kwargs`      | `Any`                |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnsupportedMediaTypeError** – If the response status code is 415. The server cannot process the request because the media type (Content-Type) of the request payload is not supported by the server for the requested resource and method.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DocumentReference
- **Return type:**
  DocumentReference

#### Examples

**Create a document:**

```python
def create_document_example() -> None:

    client = CamundaClient()

    result = client.create_document(
        data=CreateDocumentData(
            file=File(payload=io.BytesIO(b"hello world"), file_name="example.txt"),
        ),
    )

    print(f"Document ID: {result.document_id}")
```

### create_document_link()

```python
async def create_document_link(document_id, *, data=<camunda_orchestration_sdk.types.Unset object>, store_id=<camunda_orchestration_sdk.types.Unset object>, content_hash=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create document link

> Create a link to a document in the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP

**Parameters:**

| Parameter      | Type                             | Description                                      |
| -------------- | -------------------------------- | ------------------------------------------------ |
| `document_id`  | `str`                            | Document Id that uniquely identifies a document. |
| `store_id`     | `str` \| `Unset`                 |                                                  |
| `content_hash` | `str` \| `Unset`                 |                                                  |
| `data`         | `DocumentLinkRequest` \| `Unset` |                                                  |
| `kwargs`       | `Any`                            |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DocumentLink
- **Return type:**
  DocumentLink

#### Examples

**Create a document link:**

```python
def create_document_link_example(document_id: DocumentId) -> None:
    client = CamundaClient()

    result = client.create_document_link(
        document_id=document_id,
        data=DocumentLinkRequest(),
    )

    print(f"Document link: {result.url}")
```

### create_documents()

```python
async def create_documents(*, data, store_id=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Upload multiple documents

> Upload multiple documents to the Camunda 8 cluster.
>
> The caller must provide a file name for each document, which will be used in case of a multi-status
> response
> to identify which documents failed to upload. The file name can be provided in the Content-
> Disposition header
> of the file part or in the fileName field of the metadata. You can add a parallel array of
> metadata objects. These
> are matched with the files based on index, and must have the same length as the files array.
> To pass homogenous metadata for all files, spread the metadata over the metadata array.
> A filename value provided explicitly via the metadata array in the request overrides the Content-
> Disposition header
> of the file part.
>
> In case of a multi-status response, the response body will contain a list of
> DocumentBatchProblemDetail objects,
> each of which contains the file name of the document that failed to upload and the reason for the
> failure.
> The client can choose to retry the whole batch or individual documents based on the response.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter  | Type                  | Description |
| ---------- | --------------------- | ----------- |
| `store_id` | `str` \| `Unset`      |             |
| `data`     | `CreateDocumentsData` |             |
| `kwargs`   | `Any`                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnsupportedMediaTypeError** – If the response status code is 415. The server cannot process the request because the media type (Content-Type) of the request payload is not supported by the server for the requested resource and method.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DocumentCreationBatchResponse
- **Return type:**
  DocumentCreationBatchResponse

#### Examples

**Create documents:**

```python
def create_documents_example() -> None:

    client = CamundaClient()

    result = client.create_documents(
        data=CreateDocumentsData(
            files=[
                File(payload=io.BytesIO(b"file one"), file_name="one.txt"),
                File(payload=io.BytesIO(b"file two"), file_name="two.txt"),
            ],
        ),
    )

    if not isinstance(result.created_documents, Unset):
        for doc in result.created_documents:
            print(f"Created document: {doc.document_id}")
```

### create_element_instance_variables()

```python
async def create_element_instance_variables(element_instance_key, *, data, **kwargs)
```

Update element instance variables

> Updates all the variables of a particular scope (for example, process instance, element instance)
> with the given variable data.
> Specify the element instance in the elementInstanceKey parameter.
> Variable updates can be delayed by listener-related processing; if processing exceeds the
> request timeout, this endpoint can return 504. Other gateway timeout causes are also
> possible. Retry with backoff and inspect listener worker availability and logs when this
> repeats.

**Parameters:**

| Parameter              | Type                 | Description                                                             |
| ---------------------- | -------------------- | ----------------------------------------------------------------------- |
| `element_instance_key` | `str`                | System-generated key for a element instance. Example: 2251799813686789. |
| `data`                 | `SetVariableRequest` |                                                                         |
| `kwargs`               | `Any`                |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Create element instance variables:**

```python
def create_element_instance_variables_example(
    element_instance_key: ElementInstanceKey,
) -> None:
    client = CamundaClient()

    variables = SetVariableRequestVariables.from_dict({"myVar": "myValue"})
    client.create_element_instance_variables(
        element_instance_key=element_instance_key,
        data=SetVariableRequest(
            variables=variables,
        ),
    )
```

### create_global_cluster_variable()

```python
async def create_global_cluster_variable(*, data, **kwargs)
```

Create a global-scoped cluster variable

> Create a global-scoped cluster variable.

**Parameters:**

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `data`    | `CreateClusterVariableRequest` |             |
| `kwargs`  | `Any`                          |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A cluster variable with this name already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Create a global cluster variable:**

```python
def create_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.create_global_cluster_variable(
        data=CreateClusterVariableRequest(
            name=name,
            value=CreateClusterVariableRequestValue.from_dict({"key": "my-value"}),
        ),
    )

    print(f"Created variable: {result.name}")
```

### create_global_task_listener()

```python
async def create_global_task_listener(*, data, **kwargs)
```

Create global user task listener

> Create a new global user task listener.

**Parameters:**

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `data`    | `CreateGlobalTaskListenerRequest` |             |
| `kwargs`  | `Any`                             |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A global listener with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerResult
- **Return type:**
  GlobalTaskListenerResult

#### Examples

**Create a global task listener:**

```python
def create_global_task_listener_example() -> None:
    client = CamundaClient()

    result = client.create_global_task_listener(
        data=CreateGlobalTaskListenerRequest(
            id="audit-log-listener",
            event_types=[GlobalTaskListenerEventTypeEnum.COMPLETING],
            type_="my-task-listener",
        ),
    )

    print(f"Task listener: {result.id}")
```

### create_group()

```python
async def create_group(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create group

> Create a new group.
>
> The supplied groupId is validated against ^[a-zA-Z0-9_~@.+-]+$
> (max 256 characters) by IdentifierValidator.validateId in the
> runtime. This strict validation applies wherever the Groups API
> is available: in OIDC deployments that set
> camunda.security.authentication.oidc.groupsClaim the Groups
> API (including this endpoint) is disabled entirely, so group
> CRUD never sees externally-minted IdP IDs. The BYOG relaxation
> only loosens validation when a group is referenced _as a member_
> of a role or tenant (assignRoleToGroup,
> assignGroupToTenant); group CRUD itself always uses the strict
> default-id regex. The constraint is not advertised on the
> GroupId schema so that the same schema can be reused at
> member-reference sites without falsely rejecting
> externally-minted IdP group IDs there.

**Parameters:**

| Parameter | Type                            | Description |
| --------- | ------------------------------- | ----------- |
| `data`    | `GroupCreateRequest` \| `Unset` |             |
| `kwargs`  | `Any`                           |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. Group with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupCreateResult
- **Return type:**
  GroupCreateResult

#### Examples

**Create a group:**

```python
def create_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.create_group(
        data=GroupCreateRequest(group_id=group_id, name="Engineering"),
    )

    print(f"Group: {result.group_id}")
```

### create_job_worker(config: [WorkerConfig](runtime.md#camunda_orchestration_sdk.runtime.job_worker.WorkerConfig), callback: Callable[[[ConnectedJobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.ConnectedJobContext)], Coroutine[Any, Any, dict[str, Any] | JobCompletionRequest | None]] | Callable[[[SyncJobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.SyncJobContext)], dict[str, Any] | JobCompletionRequest | None], auto_start: bool = True, , execution_strategy: Literal['auto', 'async', 'thread'] = 'auto', startup_jitter_max_seconds: float | None = None) → [JobWorker](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobWorker)

### create_job_worker(config: [WorkerConfig](runtime.md#camunda_orchestration_sdk.runtime.job_worker.WorkerConfig), callback: Callable[[[JobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobContext)], Coroutine[Any, Any, dict[str, Any] | JobCompletionRequest | None]] | Callable[[[JobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobContext)], dict[str, Any] | JobCompletionRequest | None], auto_start: bool = True, , execution_strategy: Literal['process'], startup_jitter_max_seconds: float | None = None) → [JobWorker](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobWorker)

**Parameters:**

| Parameter                    | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Description |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| `config`                     | [WorkerConfig](runtime.md#camunda_orchestration_sdk.runtime.job_worker.WorkerConfig)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |             |
| `callback`                   | Callable [ [[ConnectedJobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.ConnectedJobContext) ] , Coroutine [Any , Any , dict [str , Any ] \| `JobCompletionRequest` \| None ] ] \| Callable [ [[SyncJobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.SyncJobContext) ] , dict [str , Any ] \| `JobCompletionRequest` \| None ] \| Callable [ [[JobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobContext) ] , Coroutine [Any , Any , dict [str , Any ] \| `JobCompletionRequest` \| None ] ] \| Callable [ [[JobContext](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobContext) ] , dict [str , Any ] \| `JobCompletionRequest` \| None ] |             |
| `auto_start`                 | `bool`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |             |
| `execution_strategy`         | Literal [ 'auto' , 'async' , 'thread' , 'process' ]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |             |
| `startup_jitter_max_seconds` | `float` \| `None`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |             |

- **Return type:**
  [_JobWorker_](runtime.md#camunda_orchestration_sdk.runtime.job_worker.JobWorker)

### create_mapping_rule()

```python
async def create_mapping_rule(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create mapping rule

> Create a new mapping rule

**Parameters:**

| Parameter | Type                                  | Description |
| --------- | ------------------------------------- | ----------- |
| `data`    | `MappingRuleCreateRequest` \| `Unset` |             |
| `kwargs`  | `Any`                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. The request to create a mapping rule was denied. More details are provided in the response body.
  - **errors.NotFoundError** – If the response status code is 404. The request to create a mapping rule was denied.
  - **errors.ConflictError** – If the response status code is 409. Mapping rule with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleCreateResult
- **Return type:**
  MappingRuleCreateResult

#### Examples

**Create a mapping rule:**

```python
def create_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    result = client.create_mapping_rule(
        data=MappingRuleCreateRequest(
            mapping_rule_id=mapping_rule_id,
            claim_name="groups",
            claim_value="engineering",
            name="Engineering Group Mapping",
        ),
    )

    print(f"Mapping rule: {result.mapping_rule_id}")
```

### create_process_instance()

```python
async def create_process_instance(*, data, **kwargs)
```

Create process instance

> Creates and starts an instance of the specified process.
>
> The process definition to use to create the instance can be specified either using its unique key
> (as returned by Deploy resources), or using the BPMN process id and a version.
>
> Waits for the completion of the process instance before returning a result
> when awaitCompletion is enabled.

**Parameters:**

| Parameter | Type                                            | Description                                                                                                   |
| --------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `data`    | `ProcessCreationById` \| `ProcessCreationByKey` | Instructions for creating a process instance. The process definition can be specified either by id or by key. |
| `kwargs`  | `Any`                                           |                                                                                                               |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ConflictError** – If the response status code is 409. The process instance creation was rejected due to a business ID uniqueness conflict. This can happen only when Business ID Uniqueness Control is enabled and an active root process instance with the provided business ID already exists for the same process definition and tenant.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The process instance creation request timed out in the gateway. This can happen if the awaitCompletion request parameter is set to true and the created process instance did not complete within the defined request timeout. This often happens when the created instance is not fully automated or contains wait states.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  CreateProcessInstanceResult
- **Return type:**
  CreateProcessInstanceResult

#### Examples

**By key:**

```python
def create_process_instance_by_key_example() -> None:
    client = CamundaClient()

    # Deploy a process and obtain the typed key from the response
    deployment = client.deploy_resources_from_files(["order-process.bpmn"])
    process_key = deployment.processes[0].process_definition_key

    # Use the typed key directly — no manual string lifting needed
    result = client.create_process_instance(
        data=ProcessCreationByKey(
            process_definition_key=process_key,
        )
    )

    print(f"Process instance key: {result.process_instance_key}")
```

**By stored key:**

```python
def create_process_instance_by_key_from_storage_example() -> None:
    client = CamundaClient()

    # When restoring a key from a database or message queue,
    # wrap the raw string with the semantic type constructor:
    stored_key = "2251799813685249"  # e.g. from a DB row
    result = client.create_process_instance(
        data=ProcessCreationByKey(
            process_definition_key=ProcessDefinitionKey(stored_key),
        )
    )

    print(f"Process instance key: {result.process_instance_key}")
```

**By ID:**

```python
def create_process_instance_by_id_example(process_definition_id: ProcessDefinitionId) -> None:
    client = CamundaClient()

    result = client.create_process_instance(
        data=ProcessCreationById(
            process_definition_id=process_definition_id,
        )
    )

    print(f"Process instance key: {result.process_instance_key}")
```

### create_role()

```python
async def create_role(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create role

> Create a new role.

**Parameters:**

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `data`    | `RoleCreateRequest` \| `Unset` |             |
| `kwargs`  | `Any`                          |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. Role with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleCreateResult
- **Return type:**
  RoleCreateResult

#### Examples

**Create a role:**

```python
def create_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.create_role(
        data=RoleCreateRequest(role_id=role_id, name="Developer"),
    )

    print(f"Role: {result.role_id}")
```

### create_tenant()

```python
async def create_tenant(*, data, **kwargs)
```

Create tenant

> Creates a new tenant.

**Parameters:**

| Parameter | Type                  | Description |
| --------- | --------------------- | ----------- |
| `data`    | `TenantCreateRequest` |             |
| `kwargs`  | `Any`                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The resource was not found.
  - **errors.ConflictError** – If the response status code is 409. Tenant with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantCreateResult
- **Return type:**
  TenantCreateResult

#### Examples

**Create a tenant:**

```python
def create_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.create_tenant(
        data=TenantCreateRequest(
            tenant_id=tenant_id,
            name="Acme Corporation",
        ),
    )

    print(f"Tenant: {result.tenant_id}")
```

### create_tenant_cluster_variable()

```python
async def create_tenant_cluster_variable(tenant_id, *, data, **kwargs)
```

Create a tenant-scoped cluster variable

> Create a new cluster variable for the given tenant.

**Parameters:**

| Parameter   | Type                           | Description                                                     |
| ----------- | ------------------------------ | --------------------------------------------------------------- |
| `tenant_id` | `str`                          | The unique identifier of the tenant. Example: customer-service. |
| `data`      | `CreateClusterVariableRequest` |                                                                 |
| `kwargs`    | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The tenant with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. A cluster variable with this name already exists for the given tenant.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Create a tenant cluster variable:**

```python
def create_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.create_tenant_cluster_variable(
        tenant_id=tenant_id,
        data=CreateClusterVariableRequest(
            name=name,
            value=CreateClusterVariableRequestValue.from_dict({"key": "tenant-value"}),
        ),
    )

    print(f"Created variable: {result.name}")
```

### create_user()

```python
async def create_user(*, data, **kwargs)
```

Create user

> Create a new user.

**Parameters:**

| Parameter | Type          | Description |
| --------- | ------------- | ----------- |
| `data`    | `UserRequest` |             |
| `kwargs`  | `Any`         |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A user with this username already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserCreateResult
- **Return type:**
  UserCreateResult

#### Examples

**Create a user:**

```python
def create_user_example(username: Username) -> None:
    client = CamundaClient()

    result = client.create_user(
        data=UserRequest(
            username=username,
            name="Jane Doe",
            email="jdoe@example.com",
            password="secure-password",
        ),
    )

    print(f"Created user: {result.username}")
```

### delete_authorization()

```python
async def delete_authorization(authorization_key, **kwargs)
```

Delete authorization

> Deletes the authorization with the given key.

**Parameters:**

| Parameter           | Type  | Description                                                           |
| ------------------- | ----- | --------------------------------------------------------------------- |
| `authorization_key` | `str` | System-generated key for an authorization. Example: 2251799813684332. |
| `kwargs`            | `Any` |                                                                       |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The authorization with the authorizationKey was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete an authorization:**

```python
def delete_authorization_example(authorization_key: AuthorizationKey) -> None:
    client = CamundaClient()

    client.delete_authorization(
        authorization_key=authorization_key,
    )
```

### delete_decision_instance()

```python
async def delete_decision_instance(decision_evaluation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete decision instance

> Delete all associated decision evaluations based on provided key.

**Parameters:**

| Parameter                 | Type                                                 | Description                                                                |
| ------------------------- | ---------------------------------------------------- | -------------------------------------------------------------------------- |
| `decision_evaluation_key` | `str`                                                | System-generated key for a decision evaluation. Example: 2251792362345323. |
| `data`                    | `DeleteDecisionInstanceRequest` \| `None` \| `Unset` |                                                                            |
| `kwargs`                  | `Any`                                                |                                                                            |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a decision instance:**

```python
def delete_decision_instance_example(decision_evaluation_key: DecisionEvaluationKey) -> None:
    client = CamundaClient()

    client.delete_decision_instance(
        decision_evaluation_key=decision_evaluation_key,
    )
```

### delete_decision_instances_batch_operation()

```python
async def delete_decision_instances_batch_operation(*, data, **kwargs)
```

Delete decision instances (batch)

> Delete multiple decision instances. This will delete the historic data from secondary storage.
>
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                            | Description                                                                           |
| --------- | ----------------------------------------------- | ------------------------------------------------------------------------------------- |
| `data`    | `DecisionInstanceDeletionBatchOperationRequest` | The decision instance filter that defines which decision instances should be deleted. |
| `kwargs`  | `Any`                                           |                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The decision instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Delete decision instances in batch:**

```python
def delete_decision_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.delete_decision_instances_batch_operation(
        data=DecisionInstanceDeletionBatchOperationRequest(
            filter_=DecisionInstanceDeletionBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### delete_document()

```python
async def delete_document(document_id, *, store_id=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete document

> Delete a document from the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter     | Type             | Description                                      |
| ------------- | ---------------- | ------------------------------------------------ |
| `document_id` | `str`            | Document Id that uniquely identifies a document. |
| `store_id`    | `str` \| `Unset` |                                                  |
| `kwargs`      | `Any`            |                                                  |

- **Raises:**
  - **errors.NotFoundError** – If the response status code is 404. The document with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a document:**

```python
def delete_document_example(document_id: DocumentId) -> None:
    client = CamundaClient()

    client.delete_document(document_id=document_id)
```

### delete_global_cluster_variable()

```python
async def delete_global_cluster_variable(name, **kwargs)
```

Delete a global-scoped cluster variable

> Delete a global-scoped cluster variable.

**Parameters:**

| Parameter | Type  | Description                                                                                                           |
| --------- | ----- | --------------------------------------------------------------------------------------------------------------------- |
| `name`    | `str` | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `kwargs`  | `Any` |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a global cluster variable:**

```python
def delete_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    client.delete_global_cluster_variable(name=name)
```

### delete_global_task_listener()

```python
async def delete_global_task_listener(id, **kwargs)
```

Delete global user task listener

> Deletes a global user task listener.

**Parameters:**

| Parameter | Type  | Description                                                            |
| --------- | ----- | ---------------------------------------------------------------------- |
| `id`      | `str` | The user-defined id for the global listener Example: GlobalListener_1. |
| `kwargs`  | `Any` |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The global user task listener was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a global task listener:**

```python
def delete_global_task_listener_example(listener_id: GlobalListenerId) -> None:
    client = CamundaClient()

    client.delete_global_task_listener(id=listener_id)
```

### delete_group()

```python
async def delete_group(group_id, **kwargs)
```

Delete group

> Deletes the group with the given ID.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a group:**

```python
def delete_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    client.delete_group(group_id=group_id)
```

### delete_mapping_rule()

```python
async def delete_mapping_rule(mapping_rule_id, **kwargs)
```

Delete a mapping rule

> Deletes the mapping rule with the given ID.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The mapping rule with the mappingRuleId was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a mapping rule:**

```python
def delete_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.delete_mapping_rule(mapping_rule_id=mapping_rule_id)
```

### delete_process_instance()

```python
async def delete_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete process instance

> Deletes a process instance. Only instances that are completed or terminated can be deleted.

**Parameters:**

| Parameter              | Type                                                | Description                                                             |
| ---------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                               | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `DeleteProcessInstanceRequest` \| `None` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                               |                                                                         |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance is not in a completed or terminated state and cannot be deleted.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a process instance:**

```python
def delete_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.delete_process_instance(
        process_instance_key=process_instance_key,
    )
```

### delete_process_instances_batch_operation()

```python
async def delete_process_instances_batch_operation(*, data, **kwargs)
```

Delete process instances (batch)

> Delete multiple process instances. This will delete the historic data from secondary storage.
>
> Only process instances in a final state (COMPLETED or TERMINATED) can be deleted.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                           | Description                                                                         |
| --------- | ---------------------------------------------- | ----------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceDeletionBatchOperationRequest` | The process instance filter that defines which process instances should be deleted. |
| `kwargs`  | `Any`                                          |                                                                                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Delete process instances in batch:**

```python
def delete_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.delete_process_instances_batch_operation(
        data=ProcessInstanceDeletionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### delete_resource()

```python
async def delete_resource(resource_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete resource

> Deletes a deployed resource. This can be a process definition, decision requirements
> definition, or form definition deployed using the deploy resources endpoint. Specify the
> resource you want to delete in the resourceKey parameter.
>
> Once a resource has been deleted it cannot be recovered. If the resource needs to be
> available again, a new deployment of the resource is required.
>
> By default, only the resource itself is deleted from the runtime state. To also delete the
> historic data associated with a resource, set the deleteHistory flag in the request body
> to true. The historic data is deleted asynchronously via a batch operation. The details of
> the created batch operation are included in the response. Note that history deletion is only
> supported for process resources; for other resource types this flag is ignored and no history
> will be deleted.

**Parameters:**

| Parameter      | Type                                         | Description                                |
| -------------- | -------------------------------------------- | ------------------------------------------ |
| `resource_key` | `str`                                        | The system-assigned key for this resource. |
| `data`         | `DeleteResourceRequest` \| `None` \| `Unset` |                                            |
| `kwargs`       | `Any`                                        |                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The resource is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DeleteResourceResponse
- **Return type:**
  DeleteResourceResponse

#### Examples

**Delete a resource:**

```python
def delete_resource_example() -> None:
    client = CamundaClient()

    # Use a resource key from a previous deployment response
    client.delete_resource(resource_key="2251799813685249")
```

### delete_role()

```python
async def delete_role(role_id, **kwargs)
```

Delete role

> Deletes the role with the given ID.

**Parameters:**

| Parameter | Type  | Description                                      |
| --------- | ----- | ------------------------------------------------ |
| `role_id` | `str` | The unique identifier of a role. Example: admin. |
| `kwargs`  | `Any` |                                                  |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The role with the ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a role:**

```python
def delete_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    client.delete_role(role_id=role_id)
```

### delete_tenant()

```python
async def delete_tenant(tenant_id, **kwargs)
```

Delete tenant

> Deletes an existing tenant.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a tenant:**

```python
def delete_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    client.delete_tenant(tenant_id=tenant_id)
```

### delete_tenant_cluster_variable()

```python
async def delete_tenant_cluster_variable(tenant_id, name, **kwargs)
```

Delete a tenant-scoped cluster variable

> Delete a tenant-scoped cluster variable.

**Parameters:**

| Parameter   | Type  | Description                                                                                                           |
| ----------- | ----- | --------------------------------------------------------------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service.                                                       |
| `name`      | `str` | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `kwargs`    | `Any` |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a tenant cluster variable:**

```python
def delete_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    client.delete_tenant_cluster_variable(
        tenant_id=tenant_id,
        name=name,
    )
```

### delete_user()

```python
async def delete_user(username, **kwargs)
```

Delete user

> Deletes a user.

**Parameters:**

| Parameter  | Type  | Description                                  |
| ---------- | ----- | -------------------------------------------- |
| `username` | `str` | The unique name of a user. Example: swillis. |
| `kwargs`   | `Any` |                                              |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a user:**

```python
def delete_user_example(username: Username) -> None:
    client = CamundaClient()

    client.delete_user(username=username)
```

### deploy_resources_from_files()

```python
async def deploy_resources_from_files(files, tenant_id=None)
```

Deploy BPMN/DMN/Form resources from local files.

Async variant of [`CamundaClient.deploy_resources_from_files()`](client.md#camunda_orchestration_sdk.CamundaClient.deploy_resources_from_files).

This reads each file path in `files` as bytes, wraps them into
`camunda_orchestration_sdk.types.File`, calls [`create_deployment()`](#create_deployment), and returns
an `ExtendedDeploymentResult`.

Note: file reads are currently performed using blocking I/O (`open(...).read()`). If you
need fully non-blocking file access, load the bytes yourself and call [`create_deployment()`](#create_deployment).

**Parameters:**

| Parameter   | Type                | Description                                                              |
| ----------- | ------------------- | ------------------------------------------------------------------------ |
| `files`     | list [str \| Path ] | File paths (`str` or `Path`) to deploy.                                  |
| `tenant_id` | `str` \| `None`     | Optional tenant identifier. If not provided, the default tenant is used. |

- **Returns:**
  The deployment result with extracted resource lists.
- **Return type:**
  ExtendedDeploymentResult
- **Raises:**
  - **FileNotFoundError** – If any file path does not exist.
  - **PermissionError** – If any file path cannot be read.
  - **IsADirectoryError** – If any file path is a directory.
  - **OSError** – For other I/O failures while reading files.
  - **Exception** – Propagates any exception raised by [`create_deployment()`](#create_deployment) (including
    typed API errors in `camunda_orchestration_sdk.errors` and `httpx.TimeoutException`).

### evaluate_conditionals()

```python
async def evaluate_conditionals(*, data, **kwargs)
```

Evaluate root level conditional start events

> Evaluates root-level conditional start events for process definitions.
>
> If the evaluation is successful, it will return the keys of all created process instances, along
> with their associated process definition key.
> Multiple root-level conditional start events of the same process definition can trigger if their
> conditions evaluate to true.

**Parameters:**

| Parameter | Type                               | Description |
| --------- | ---------------------------------- | ----------- |
| `data`    | `ConditionalEvaluationInstruction` |             |
| `kwargs`  | `Any`                              |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. The client is not authorized to start process instances for the specified process definition. If a processDefinitionKey is not provided, this indicates that the client is not authorized to start process instances for at least one of the matched process definitions.
  - **errors.NotFoundError** – If the response status code is 404. The process definition was not found for the given processDefinitionKey.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  EvaluateConditionalResult
- **Return type:**
  EvaluateConditionalResult

#### Examples

**Evaluate conditionals:**

```python
def evaluate_conditionals_example() -> None:
    client = CamundaClient()

    result = client.evaluate_conditionals(
        data=ConditionalEvaluationInstruction(
            variables=ConditionalEvaluationInstructionVariables.from_dict({"orderReady": True}),
        ),
    )

    print(f"Result: {result}")
```

### evaluate_decision()

```python
async def evaluate_decision(*, data, **kwargs)
```

Evaluate decision

> Evaluates a decision.
>
> You specify the decision to evaluate either by using its unique key (as returned by
> DeployResource), or using the decision ID. When using the decision ID, the latest deployed
> version of the decision is used.

**Parameters:**

| Parameter | Type                                                  | Description |
| --------- | ----------------------------------------------------- | ----------- |
| `data`    | `DecisionEvaluationByID` \| `DecisionEvaluationByKey` |             |
| `kwargs`  | `Any`                                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The decision is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  EvaluateDecisionResult
- **Return type:**
  EvaluateDecisionResult

#### Examples

**By key:**

```python
def evaluate_decision_by_key_example(decision_definition_key: DecisionDefinitionKey) -> None:
    client = CamundaClient()

    result = client.evaluate_decision(
        data=DecisionEvaluationByKey(
            decision_definition_key=decision_definition_key,
        )
    )

    print(f"Decision key: {result.decision_definition_key}")
```

**By ID:**

```python
def evaluate_decision_by_id_example(decision_definition_id: DecisionDefinitionId) -> None:
    client = CamundaClient()

    result = client.evaluate_decision(
        data=DecisionEvaluationByID(
            decision_definition_id=decision_definition_id,
        )
    )

    print(f"Decision key: {result.decision_definition_key}")
```

### evaluate_expression()

```python
async def evaluate_expression(*, data, **kwargs)
```

Evaluate an expression

> Evaluates a FEEL expression and returns the result. Supports references to tenant scoped
> cluster variables when a tenant ID is provided. Optionally, provide a scopeKey to make the
> variables of a specific process instance or element instance visible while evaluating the
> expression.

**Parameters:**

| Parameter | Type                          | Description |
| --------- | ----------------------------- | ----------- |
| `data`    | `ExpressionEvaluationRequest` |             |
| `kwargs`  | `Any`                         |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ExpressionEvaluationResult
- **Return type:**
  ExpressionEvaluationResult

#### Examples

**Evaluate an expression:**

```python
def evaluate_expression_example() -> None:
    client = CamundaClient()

    result = client.evaluate_expression(
        data=ExpressionEvaluationRequest(
            expression="= 1 + 2",
        ),
    )

    print(f"Result: {result.result}")
```

### fail_job()

```python
async def fail_job(job_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Fail job

> Mark the job as failed.

**Parameters:**

| Parameter | Type                        | Description                                                |
| --------- | --------------------------- | ---------------------------------------------------------- |
| `job_key` | `str`                       | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobFailRequest` \| `Unset` |                                                            |
| `kwargs`  | `Any`                       |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the given jobKey is not found. It was completed by another worker, or the process instance itself was canceled.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state (i.e: not ACTIVATED or ACTIVATABLE). The job was failed by another worker with retries = 0, and the process is now in an incident state.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Fail a job with retry:**

```python
def fail_job_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.fail_job(
        job_key=job_key,
        data=JobFailRequest(
            retries=2,
            error_message="Payment gateway timeout",
            retry_back_off=5000,
        ),
    )
```

### get_agent_instance()

```python
async def get_agent_instance(agent_instance_key, *, consistency=None, **kwargs)
```

Get agent instance

> Returns agent instance as JSON.

**Parameters:**

| Parameter            | Type                           | Description                                                            |
| -------------------- | ------------------------------ | ---------------------------------------------------------------------- |
| `agent_instance_key` | `str`                          | System-generated key for an agent instance. Example: 4503599627370496. |
| `consistency`        | `ConsistencyOptions` \| `None` |                                                                        |
| `kwargs`             | `Any`                          |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceResult
- **Return type:**
  AgentInstanceResult

#### Examples

**Get an agent instance:**

```python
def get_agent_instance_example(agent_instance_key: AgentInstanceKey) -> None:
    client = CamundaClient()

    agent_instance = client.get_agent_instance(agent_instance_key=agent_instance_key)

    print(f"Agent instance status: {agent_instance.status}")
```

### get_audit_log()

```python
async def get_audit_log(audit_log_key, *, consistency=None, **kwargs)
```

Get audit log

> Get an audit log entry by auditLogKey.

**Parameters:**

| Parameter       | Type                           | Description                                                              |
| --------------- | ------------------------------ | ------------------------------------------------------------------------ |
| `audit_log_key` | `str`                          | System-generated key for an audit log entry. Example: 22517998136843567. |
| `consistency`   | `ConsistencyOptions` \| `None` |                                                                          |
| `kwargs`        | `Any`                          |                                                                          |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The audit log with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuditLogResult
- **Return type:**
  AuditLogResult

#### Examples

**Get an audit log entry:**

```python
def get_audit_log_example(audit_log_key: AuditLogKey) -> None:
    client = CamundaClient()

    result = client.get_audit_log(audit_log_key=audit_log_key)

    print(f"Audit log: {result.audit_log_key}")
```

### get_authentication()

```python
async def get_authentication(**kwargs)
```

Get current user

> Retrieves the current authenticated user.

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  CamundaUserResult
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  CamundaUserResult

#### Examples

**Get authentication info:**

```python
def get_authentication_example() -> None:
    client = CamundaClient()

    result = client.get_authentication()

    print(f"Authenticated user: {result.username}")
```

### get_authorization()

```python
async def get_authorization(authorization_key, *, consistency=None, **kwargs)
```

Get authorization

> Get authorization by the given key.

**Parameters:**

| Parameter           | Type                           | Description                                                           |
| ------------------- | ------------------------------ | --------------------------------------------------------------------- |
| `authorization_key` | `str`                          | System-generated key for an authorization. Example: 2251799813684332. |
| `consistency`       | `ConsistencyOptions` \| `None` |                                                                       |
| `kwargs`            | `Any`                          |                                                                       |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The authorization with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuthorizationResult
- **Return type:**
  AuthorizationResult

#### Examples

**Get an authorization:**

```python
def get_authorization_example(authorization_key: AuthorizationKey) -> None:
    client = CamundaClient()

    result = client.get_authorization(
        authorization_key=authorization_key,
    )

    print(f"Resource type: {result.resource_type}")
```

### get_batch_operation()

```python
async def get_batch_operation(batch_operation_key, *, consistency=None, **kwargs)
```

Get batch operation

> Get batch operation by key.

**Parameters:**

| Parameter             | Type                           | Description                                                             |
| --------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`                          | System-generated key for an batch operation. Example: 2251799813684321. |
| `consistency`         | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`              | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The batch operation is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationResponse
- **Return type:**
  BatchOperationResponse

#### Examples

**Get a batch operation:**

```python
def get_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    result = client.get_batch_operation(
        batch_operation_key=batch_operation_key,
    )

    print(f"Batch operation: {result.batch_operation_key}")
```

### get_decision_definition()

```python
async def get_decision_definition(decision_definition_key, *, consistency=None, **kwargs)
```

Get decision definition

> Returns a decision definition by key.

**Parameters:**

| Parameter                 | Type                           | Description                                                                |
| ------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
| `decision_definition_key` | `str`                          | System-generated key for a decision definition. Example: 2251799813326547. |
| `consistency`             | `ConsistencyOptions` \| `None` |                                                                            |
| `kwargs`                  | `Any`                          |                                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionDefinitionResult
- **Return type:**
  DecisionDefinitionResult

#### Examples

**Get a decision definition:**

```python
def get_decision_definition_example(decision_definition_key: DecisionDefinitionKey) -> None:
    client = CamundaClient()

    definition = client.get_decision_definition(
        decision_definition_key=decision_definition_key,
    )

    print(f"Decision: {definition.decision_definition_id}")
```

### get_decision_definition_xml()

```python
async def get_decision_definition_xml(decision_definition_key, *, consistency=None, **kwargs)
```

Get decision definition XML

> Returns decision definition as XML.

**Parameters:**

| Parameter                 | Type                           | Description                                                                |
| ------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
| `decision_definition_key` | `str`                          | System-generated key for a decision definition. Example: 2251799813326547. |
| `consistency`             | `ConsistencyOptions` \| `None` |                                                                            |
| `kwargs`                  | `Any`                          |                                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  str
- **Return type:**
  str

#### Examples

**Get decision definition XML:**

```python
def get_decision_definition_xml_example(decision_definition_key: DecisionDefinitionKey) -> None:
    client = CamundaClient()

    xml = client.get_decision_definition_xml(
        decision_definition_key=decision_definition_key,
    )

    print(f"XML length: {len(xml)}")
```

### get_decision_instance()

```python
async def get_decision_instance(decision_evaluation_instance_key, *, consistency=None, **kwargs)
```

Get decision instance

> Returns a decision instance.

**Parameters:**

| Parameter                          | Type   | Description |
| ---------------------------------- | ------ | ----------- |
| `decision_evaluation_instance_key` | str) – |             |

    System-generated identifier for a decision
    evaluation instance. It is composed of the
    parent decision evaluation key and the 1-based index of the evaluated decision within
    that evaluation, joined by a hyphen (format: <decisionEvaluationKey>-<index>).
    > Example: 2251799813684367-1.

- **consistency** (_ConsistencyOptions_ _|_ _None_)
- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionInstanceGetQueryResult
- **Return type:**
  DecisionInstanceGetQueryResult

#### Examples

**Get a decision instance:**

```python
def get_decision_instance_example(decision_evaluation_instance_key: DecisionEvaluationInstanceKey) -> None:
    client = CamundaClient()

    result = client.get_decision_instance(
        decision_evaluation_instance_key=decision_evaluation_instance_key,
    )

    print(f"Decision instance: {result.decision_definition_id}")
```

### get_decision_requirements()

```python
async def get_decision_requirements(decision_requirements_key, *, consistency=None, **kwargs)
```

Get decision requirements

> Returns Decision Requirements as JSON.

**Parameters:**

| Parameter                   | Type                           | Description                                                                                      |
| --------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------ |
| `decision_requirements_key` | `str`                          | System-generated key for a deployed decision requirements definition. Example: 2251799813683346. |
| `consistency`               | `ConsistencyOptions` \| `None` |                                                                                                  |
| `kwargs`                    | `Any`                          |                                                                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision requirements with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionRequirementsResult
- **Return type:**
  DecisionRequirementsResult

#### Examples

**Get decision requirements:**

```python
def get_decision_requirements_example(decision_requirements_key: DecisionRequirementsKey) -> None:
    client = CamundaClient()

    result = client.get_decision_requirements(
        decision_requirements_key=decision_requirements_key,
    )

    print(f"DRD: {result.decision_requirements_name}")
```

### get_decision_requirements_xml()

```python
async def get_decision_requirements_xml(decision_requirements_key, *, consistency=None, **kwargs)
```

Get decision requirements XML

> Returns decision requirements as XML.

**Parameters:**

| Parameter                   | Type                           | Description                                                                                      |
| --------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------ |
| `decision_requirements_key` | `str`                          | System-generated key for a deployed decision requirements definition. Example: 2251799813683346. |
| `consistency`               | `ConsistencyOptions` \| `None` |                                                                                                  |
| `kwargs`                    | `Any`                          |                                                                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision requirements with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  str
- **Return type:**
  str

#### Examples

**Get decision requirements XML:**

```python
def get_decision_requirements_xml_example(decision_requirements_key: DecisionRequirementsKey) -> None:
    client = CamundaClient()

    xml = client.get_decision_requirements_xml(
        decision_requirements_key=decision_requirements_key,
    )

    print(f"XML length: {len(xml)}")
```

### get_document()

```python
async def get_document(document_id, *, store_id=<camunda_orchestration_sdk.types.Unset object>, content_hash=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Download document

> Download a document from the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter      | Type             | Description                                      |
| -------------- | ---------------- | ------------------------------------------------ |
| `document_id`  | `str`            | Document Id that uniquely identifies a document. |
| `store_id`     | `str` \| `Unset` |                                                  |
| `content_hash` | `str` \| `Unset` |                                                  |
| `kwargs`       | `Any`            |                                                  |

- **Raises:**
  - **errors.NotFoundError** – If the response status code is 404. The document with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  File
- **Return type:**
  File

#### Examples

**Get a document:**

```python
def get_document_example(document_id: DocumentId) -> None:
    client = CamundaClient()

    result = client.get_document(document_id=document_id)

    print(f"File name: {result.file_name}")
```

### get_element_instance()

```python
async def get_element_instance(element_instance_key, *, consistency=None, **kwargs)
```

Get element instance

> Returns element instance as JSON.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `element_instance_key` | `str`                          | System-generated key for a element instance. Example: 2251799813686789. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The element instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ElementInstanceResult
- **Return type:**
  ElementInstanceResult

#### Examples

**Get an element instance:**

```python
def get_element_instance_example(element_instance_key: ElementInstanceKey) -> None:
    client = CamundaClient()

    result = client.get_element_instance(
        element_instance_key=element_instance_key,
    )

    print(f"Element: {result.element_id}")
```

### get_form_by_key()

```python
async def get_form_by_key(form_key, *, consistency=None, **kwargs)
```

Get form by key

> Get a form by its unique form key.

**Parameters:**

| Parameter     | Type                           | Description                                                          |
| ------------- | ------------------------------ | -------------------------------------------------------------------- |
| `form_key`    | `str`                          | System-generated key for a deployed form. Example: 2251799813684365. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                      |
| `kwargs`      | `Any`                          |                                                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The form with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  FormResult
- **Return type:**
  FormResult

#### Examples

**Get a form by key:**

```python
def get_form_by_key_example(form_key: FormKey) -> None:
    client = CamundaClient()

    result = client.get_form_by_key(form_key=form_key)

    print(f"Form: {result.form_id}")
```

### get_global_cluster_variable()

```python
async def get_global_cluster_variable(name, *, consistency=None, **kwargs)
```

Get a global-scoped cluster variable

> Get a global-scoped cluster variable.

**Parameters:**

| Parameter     | Type                           | Description                                                                                                           |
| ------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `name`        | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                                                                       |
| `kwargs`      | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Get a global cluster variable:**

```python
def get_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.get_global_cluster_variable(name=name)

    print(f"Variable: {result.name} = {result.value}")
```

### get_global_job_statistics()

```python
async def get_global_job_statistics(*, from_, to, job_type=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Global job statistics

> Returns global aggregated counts for jobs. Filter by the creation time window (required) and
> optionally by jobType.

**Parameters:**

| Parameter     | Type                           | Description |
| ------------- | ------------------------------ | ----------- |
| `from`        | `datetime.datetime`            |             |
| `to`          | `datetime.datetime`            |             |
| `job_type`    | `str` \| `Unset`               |             |
| `from_`       | `datetime.datetime`            |             |
| `consistency` | `ConsistencyOptions` \| `None` |             |
| `kwargs`      | `Any`                          |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalJobStatisticsQueryResult
- **Return type:**
  GlobalJobStatisticsQueryResult

#### Examples

**Get global job statistics:**

```python
def get_global_job_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_global_job_statistics(
        from_=datetime.datetime(2024, 1, 1),
        to=datetime.datetime(2024, 12, 31),
    )

    print(f"Global job stats: {result}")
```

### get_global_task_listener()

```python
async def get_global_task_listener(id, *, consistency=None, **kwargs)
```

Get global user task listener

> Get a global user task listener by its id.

**Parameters:**

| Parameter     | Type                           | Description                                                            |
| ------------- | ------------------------------ | ---------------------------------------------------------------------- |
| `id`          | `str`                          | The user-defined id for the global listener Example: GlobalListener_1. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                        |
| `kwargs`      | `Any`                          |                                                                        |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The global user task listener with the given id was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerResult
- **Return type:**
  GlobalTaskListenerResult

#### Examples

**Get a global task listener:**

```python
def get_global_task_listener_example(listener_id: GlobalListenerId) -> None:
    client = CamundaClient()

    result = client.get_global_task_listener(id=listener_id)

    print(f"Task listener: {result.event_types}")
```

### get_group()

```python
async def get_group(group_id, *, consistency=None, **kwargs)
```

Get group

> Get a group by its ID.

**Parameters:**

| Parameter     | Type                           | Description                                             |
| ------------- | ------------------------------ | ------------------------------------------------------- |
| `group_id`    | `str`                          | The unique identifier of a group. Example: engineering. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                         |
| `kwargs`      | `Any`                          |                                                         |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupResult
- **Return type:**
  GroupResult

#### Examples

**Get a group:**

```python
def get_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.get_group(group_id=group_id)

    print(f"Group: {result.name}")
```

### get_incident()

```python
async def get_incident(incident_key, *, consistency=None, **kwargs)
```

Get incident

> Returns incident as JSON.

**Parameters:**

| Parameter      | Type                           | Description                                                     |
| -------------- | ------------------------------ | --------------------------------------------------------------- |
| `incident_key` | `str`                          | System-generated key for a incident. Example: 2251799813689432. |
| `consistency`  | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`       | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The incident with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentResult
- **Return type:**
  IncidentResult

#### Examples

**Get an incident:**

```python
def get_incident_example(incident_key: IncidentKey) -> None:
    client = CamundaClient()

    incident = client.get_incident(incident_key=incident_key)

    print(f"Incident error type: {incident.error_type}")
```

### get_job_error_statistics()

```python
async def get_job_error_statistics(*, data, consistency=None, **kwargs)
```

Get error metrics for a job type

> Returns aggregated metrics per error for the given jobType.

**Parameters:**

| Parameter     | Type                           | Description                 |
| ------------- | ------------------------------ | --------------------------- |
| `data`        | `JobErrorStatisticsQuery`      | Job error statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                             |
| `kwargs`      | `Any`                          |                             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobErrorStatisticsQueryResult
- **Return type:**
  JobErrorStatisticsQueryResult

#### Examples

**Get job error statistics:**

```python
def get_job_error_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_error_statistics(
        data=JobErrorStatisticsQuery(
            filter_=JobErrorStatisticsFilter(
                from_=datetime.datetime(2024, 1, 1),
                to=datetime.datetime(2024, 12, 31),
                job_type="payment-processing",
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Error: {stat.error_code}")
```

### get_job_time_series_statistics()

```python
async def get_job_time_series_statistics(*, data, consistency=None, **kwargs)
```

Get time-series metrics for a job type

> Returns a list of time-bucketed metrics ordered ascending by time.
>
> The from and to fields select the time window of interest.
> Each item in the response corresponds to one time bucket of the requested resolution.

**Parameters:**

| Parameter     | Type                           | Description                       |
| ------------- | ------------------------------ | --------------------------------- |
| `data`        | `JobTimeSeriesStatisticsQuery` | Job time-series statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                                   |
| `kwargs`      | `Any`                          |                                   |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobTimeSeriesStatisticsQueryResult
- **Return type:**
  JobTimeSeriesStatisticsQueryResult

#### Examples

**Get job time series statistics:**

```python
def get_job_time_series_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_time_series_statistics(
        data=JobTimeSeriesStatisticsQuery(
            filter_=JobTimeSeriesStatisticsFilter(
                from_=datetime.datetime(2024, 1, 1),
                to=datetime.datetime(2024, 12, 31),
                job_type="payment-processing",
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Time series: {stat}")
```

### get_job_type_statistics()

```python
async def get_job_type_statistics(*, data, consistency=None, **kwargs)
```

Get job statistics by type

> Get statistics about jobs, grouped by job type.

**Parameters:**

| Parameter     | Type                           | Description                |
| ------------- | ------------------------------ | -------------------------- |
| `data`        | `JobTypeStatisticsQuery`       | Job type statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                            |
| `kwargs`      | `Any`                          |                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobTypeStatisticsQueryResult
- **Return type:**
  JobTypeStatisticsQueryResult

#### Examples

**Get job type statistics:**

```python
def get_job_type_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_type_statistics(
        data=JobTypeStatisticsQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Job type: {stat.job_type}")
```

### get_job_worker_statistics()

```python
async def get_job_worker_statistics(*, data, consistency=None, **kwargs)
```

Get job statistics by worker

> Get statistics about jobs, grouped by worker, for a given job type.

**Parameters:**

| Parameter     | Type                           | Description                  |
| ------------- | ------------------------------ | ---------------------------- |
| `data`        | `JobWorkerStatisticsQuery`     | Job worker statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                              |
| `kwargs`      | `Any`                          |                              |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobWorkerStatisticsQueryResult
- **Return type:**
  JobWorkerStatisticsQueryResult

#### Examples

**Get job worker statistics:**

```python
def get_job_worker_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_worker_statistics(
        data=JobWorkerStatisticsQuery(
            filter_=JobWorkerStatisticsFilter(
                from_=datetime.datetime(2024, 1, 1),
                to=datetime.datetime(2024, 12, 31),
                job_type="payment-processing",
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Worker: {stat.worker}")
```

### get_license()

```python
async def get_license(**kwargs)
```

Get license status

> Obtains the status of the current Camunda license.

- **Raises:**
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  LicenseResponse
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  LicenseResponse

#### Examples

**Get license information:**

```python
def get_license_example() -> None:
    client = CamundaClient()

    result = client.get_license()

    print(f"License type: {result.license_type}")
```

### get_mapping_rule()

```python
async def get_mapping_rule(mapping_rule_id, *, consistency=None, **kwargs)
```

Get a mapping rule

> Gets the mapping rule with the given ID.

**Parameters:**

| Parameter         | Type                           | Description                                                        |
| ----------------- | ------------------------------ | ------------------------------------------------------------------ |
| `mapping_rule_id` | `str`                          | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `consistency`     | `ConsistencyOptions` \| `None` |                                                                    |
| `kwargs`          | `Any`                          |                                                                    |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The mapping rule with the mappingRuleId was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleResult
- **Return type:**
  MappingRuleResult

#### Examples

**Get a mapping rule:**

```python
def get_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    result = client.get_mapping_rule(mapping_rule_id=mapping_rule_id)

    print(f"Mapping rule: {result.name}")
```

### get_process_definition()

```python
async def get_process_definition(process_definition_key, *, consistency=None, **kwargs)
```

Get process definition

> Returns process definition as JSON.

**Parameters:**

| Parameter                | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                          | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `consistency`            | `ConsistencyOptions` \| `None` |                                                                                    |
| `kwargs`                 | `Any`                          |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionResult
- **Return type:**
  ProcessDefinitionResult

#### Examples

**Get a process definition:**

```python
def get_process_definition_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_definition(
        process_definition_key=process_definition_key,
    )

    print(f"Process definition: {result.name}")
```

### get_process_definition_instance_statistics()

```python
async def get_process_definition_instance_statistics(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get process instance statistics

> Get statistics about process instances, grouped by process definition and tenant.

**Parameters:**

| Parameter     | Type                                                  | Description |
| ------------- | ----------------------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionInstanceStatisticsQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                        |             |
| `kwargs`      | `Any`                                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionInstanceStatisticsQueryResult
- **Return type:**
  ProcessDefinitionInstanceStatisticsQueryResult

#### Examples

**Get process definition instance statistics:**

```python
def get_process_definition_instance_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_process_definition_instance_statistics(
        data=ProcessDefinitionInstanceStatisticsQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Definition: {stat.process_definition_id}")
```

### get_process_definition_instance_version_statistics()

```python
async def get_process_definition_instance_version_statistics(*, data, consistency=None, **kwargs)
```

Get process instance statistics by version

> Get statistics about process instances, grouped by version for a given process definition.
>
> The process definition ID must be provided as a required field in the request body filter.

**Parameters:**

| Parameter     | Type                                              | Description |
| ------------- | ------------------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionInstanceVersionStatisticsQuery` |             |
| `consistency` | `ConsistencyOptions` \| `None`                    |             |
| `kwargs`      | `Any`                                             |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionInstanceVersionStatisticsQueryResult
- **Return type:**
  ProcessDefinitionInstanceVersionStatisticsQueryResult

#### Examples

**Get version statistics:**

```python
def get_process_definition_instance_version_statistics_example(
    process_definition_id: ProcessDefinitionId,
) -> None:
    client = CamundaClient()

    result = client.get_process_definition_instance_version_statistics(
        data=ProcessDefinitionInstanceVersionStatisticsQuery(
            filter_=ProcessDefinitionInstanceVersionStatisticsQueryFilter(
                process_definition_id=process_definition_id,
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Version: {stat.process_definition_version}")
```

### get_process_definition_message_subscription_statistics()

```python
async def get_process_definition_message_subscription_statistics(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get message subscription statistics

> Get message subscription statistics, grouped by process definition.

**Parameters:**

| Parameter     | Type                                                             | Description |
| ------------- | ---------------------------------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionMessageSubscriptionStatisticsQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                                   |             |
| `kwargs`      | `Any`                                                            |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionMessageSubscriptionStatisticsQueryResult
- **Return type:**
  ProcessDefinitionMessageSubscriptionStatisticsQueryResult

#### Examples

**Get message subscription statistics:**

```python
def get_process_definition_message_subscription_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_process_definition_message_subscription_statistics(
        data=ProcessDefinitionMessageSubscriptionStatisticsQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(
                f"Definition: {stat.process_definition_id}, subscriptions: {stat.active_subscriptions}"
            )
```

### get_process_definition_statistics()

```python
async def get_process_definition_statistics(process_definition_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get process definition statistics

> Get statistics about elements in currently running process instances by process definition key and
> search filter.

**Parameters:**

| Parameter                | Type                                                 | Description                                                                        |
| ------------------------ | ---------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                                                | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `data`                   | `ProcessDefinitionElementStatisticsQuery` \| `Unset` | Process definition element statistics request.                                     |
| `consistency`            | `ConsistencyOptions` \| `None`                       |                                                                                    |
| `kwargs`                 | `Any`                                                |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionElementStatisticsQueryResult
- **Return type:**
  ProcessDefinitionElementStatisticsQueryResult

#### Examples

**Get process definition element statistics:**

```python
def get_process_definition_statistics_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_definition_statistics(
        process_definition_key=process_definition_key,
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Element: {stat.element_id}")
```

### get_process_definition_xml()

```python
async def get_process_definition_xml(process_definition_key, *, consistency=None, **kwargs)
```

Get process definition XML

> Returns process definition as XML.

**Parameters:**

| Parameter                | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                          | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `consistency`            | `ConsistencyOptions` \| `None` |                                                                                    |
| `kwargs`                 | `Any`                          |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  str
- **Return type:**
  str

#### Examples

**Get process definition XML:**

```python
def get_process_definition_xml_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    xml = client.get_process_definition_xml(
        process_definition_key=process_definition_key,
    )

    print(f"XML length: {len(xml)}")
```

### get_process_instance()

```python
async def get_process_instance(process_instance_key, *, consistency=None, **kwargs)
```

Get process instance

> Get the process instance by the process instance key.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceResult
- **Return type:**
  ProcessInstanceResult

#### Examples

**Get a process instance:**

```python
def get_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    result = client.get_process_instance(
        process_instance_key=process_instance_key,
    )

    print(f"Process instance: {result.process_definition_id}")
```

### get_process_instance_call_hierarchy()

```python
async def get_process_instance_call_hierarchy(process_instance_key, *, consistency=None, **kwargs)
```

Get call hierarchy

> Returns the call hierarchy for a given process instance, showing its ancestry up to the root
> instance.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  list[Any]
- **Return type:**
  list[Any]

#### Examples

**Get process instance call hierarchy:**

```python
def get_process_instance_call_hierarchy_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_call_hierarchy(
        process_instance_key=process_instance_key,
    )

    for entry in result:
        print(f"Call hierarchy entry: {entry}")
```

### get_process_instance_sequence_flows()

```python
async def get_process_instance_sequence_flows(process_instance_key, *, consistency=None, **kwargs)
```

Get sequence flows

> Get sequence flows taken by the process instance.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceSequenceFlowsQueryResult
- **Return type:**
  ProcessInstanceSequenceFlowsQueryResult

#### Examples

**Get process instance sequence flows:**

```python
def get_process_instance_sequence_flows_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_sequence_flows(
        process_instance_key=process_instance_key,
    )

    if not isinstance(result.items, Unset):
        for flow in result.items:
            print(f"Sequence flow: {flow}")
```

### get_process_instance_statistics()

```python
async def get_process_instance_statistics(process_instance_key, *, consistency=None, **kwargs)
```

Get element instance statistics

> Get statistics about elements by the process instance key.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceElementStatisticsQueryResult
- **Return type:**
  ProcessInstanceElementStatisticsQueryResult

#### Examples

**Get process instance statistics:**

```python
def get_process_instance_statistics_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_statistics(
        process_instance_key=process_instance_key,
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Element: {stat.element_id}, Active: {stat.active}")
```

### get_process_instance_statistics_by_definition()

```python
async def get_process_instance_statistics_by_definition(*, data, consistency=None, **kwargs)
```

Get process instance statistics by definition

> Returns statistics for active process instances with incidents, grouped by process
> definition. The result set is scoped to a specific incident error hash code, which must be
> provided as a filter in the request body.

**Parameters:**

| Parameter     | Type                                                 | Description |
| ------------- | ---------------------------------------------------- | ----------- |
| `data`        | `IncidentProcessInstanceStatisticsByDefinitionQuery` |             |
| `consistency` | `ConsistencyOptions` \| `None`                       |             |
| `kwargs`      | `Any`                                                |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentProcessInstanceStatisticsByDefinitionQueryResult
- **Return type:**
  IncidentProcessInstanceStatisticsByDefinitionQueryResult

#### Examples

**Get instance statistics by definition:**

```python
def get_process_instance_statistics_by_definition_example() -> None:
    client = CamundaClient()

    result = client.get_process_instance_statistics_by_definition(
        data=IncidentProcessInstanceStatisticsByDefinitionQuery(
            filter_=IncidentProcessInstanceStatisticsByDefinitionQueryFilter(
                error_hash_code=12345,
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Definition: {stat.process_definition_key}")
```

### get_process_instance_statistics_by_error()

```python
async def get_process_instance_statistics_by_error(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get process instance statistics by error

> Returns statistics for active process instances that currently have active incidents,
> grouped by incident error hash code.

**Parameters:**

| Parameter     | Type                                                       | Description |
| ------------- | ---------------------------------------------------------- | ----------- |
| `data`        | `IncidentProcessInstanceStatisticsByErrorQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                             |             |
| `kwargs`      | `Any`                                                      |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentProcessInstanceStatisticsByErrorQueryResult
- **Return type:**
  IncidentProcessInstanceStatisticsByErrorQueryResult

#### Examples

**Get instance statistics by error:**

```python
def get_process_instance_statistics_by_error_example() -> None:
    client = CamundaClient()

    result = client.get_process_instance_statistics_by_error(
        data=IncidentProcessInstanceStatisticsByErrorQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Error: {stat.error_message}")
```

### get_process_instance_wait_state_statistics()

```python
async def get_process_instance_wait_state_statistics(process_instance_key, *, consistency=None, **kwargs)
```

Get wait state statistics

> Get statistics about waiting element instances by the process instance key, grouped by element id.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceWaitStateStatisticsQueryResult
- **Return type:**
  ProcessInstanceWaitStateStatisticsQueryResult

#### Examples

**Get process instance wait state statistics:**

```python
def get_process_instance_wait_state_statistics_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_wait_state_statistics(
        process_instance_key=process_instance_key,
    )

    for stat in result.items:
        print(f"Element: {stat.element_id}, Waiting: {stat.waiting_count}")
```

### get_resource()

```python
async def get_resource(resource_key, *, consistency=None, **kwargs)
```

Get resource

> Returns a deployed resource.

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective APIs.
:::

- **resource_key**: The system-assigned key for this resource.

````

* **Raises:**
  * **errors.NotFoundError** – If the response status code is 404. A resource with the given key was not found.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  ResourceResult
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `resource_key` | `str` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  ResourceResult

#### Examples

**Get a resource:**

```python
def get_resource_example() -> None:
    client = CamundaClient()

    result = client.get_resource(resource_key="123456")

    print(f"Resource: {result.resource_name}")
````

### get_resource_content()

```python
async def get_resource_content(resource_key, *, consistency=None, **kwargs)
```

Get RPA resource content (deprecated)

> **Deprecated** — use /resources/{resourceKey}/content/binary instead, which supports all
> resource types and returns content as binary (octet-stream).
>
> Returns the content of a deployed RPA resource as JSON.

:::info
This endpoint only supports RPA resources. For generic resource content in binary format,
use the /resources/{resourceKey}/content/binary endpoint.
:::

- **resource_key**: The system-assigned key for this resource.

````

* **Raises:**
  * **errors.NotFoundError** – If the response status code is 404. A resource with the given key was not found.
  * **errors.NotAcceptableError** – If the response status code is 406. The resource exists but is not an RPA resource.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  GetResourceContentResponse200
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `resource_key` | `str` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  GetResourceContentResponse200

#### Examples

**Get resource content:**

```python
def get_resource_content_example() -> None:
    client = CamundaClient()

    content = client.get_resource_content(resource_key="123456")

    print(f"Content: {content}")
````

### get_resource_content_binary()

```python
async def get_resource_content_binary(resource_key, *, consistency=None, **kwargs)
```

Get resource content as binary

> Returns the content of a deployed resource in binary format (octet-stream).

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective APIs.
:::

- **resource_key**: The system-assigned key for this resource.

````

* **Raises:**
  * **errors.NotFoundError** – If the response status code is 404. A resource with the given key was not found.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  File
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `resource_key` | `str` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  File

#### Examples

**Get resource content as binary:**

```python
def get_resource_content_binary_example() -> None:
    client = CamundaClient()

    content = client.get_resource_content_binary(resource_key="123456")

    print(f"Binary content size: {len(content.payload.read())}")
````

### get_role()

```python
async def get_role(role_id, *, consistency=None, **kwargs)
```

Get role

> Get a role by its ID.

**Parameters:**

| Parameter     | Type                           | Description                                      |
| ------------- | ------------------------------ | ------------------------------------------------ |
| `role_id`     | `str`                          | The unique identifier of a role. Example: admin. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                  |
| `kwargs`      | `Any`                          |                                                  |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleResult
- **Return type:**
  RoleResult

#### Examples

**Get a role:**

```python
def get_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.get_role(role_id=role_id)

    print(f"Role: {result.name}")
```

### get_start_process_form()

```python
async def get_start_process_form(process_definition_key, *, consistency=None, **kwargs)
```

Get process start form

> Get the start form of a process.
>
> Note that this endpoint will only return linked forms. This endpoint does not support embedded
> forms.

**Parameters:**

| Parameter                | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                          | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `consistency`            | `ConsistencyOptions` \| `None` |                                                                                    |
| `kwargs`                 | `Any`                          |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  FormResult
- **Return type:**
  FormResult

#### Examples

**Get start process form:**

```python
def get_start_process_form_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.get_start_process_form(
        process_definition_key=process_definition_key,
    )

    print(f"Form: {result.form_key}")
```

### get_status()

```python
async def get_status(**kwargs)
```

Get cluster status

- **Raises:**
  - **errors.ServiceUnavailableError** – If the response status code is 503.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  None

#### Examples

**Check cluster status:**

```python
def get_status_example() -> None:
    client = CamundaClient()

    client.get_status()

    print("Cluster is healthy")
```

### get_system_configuration()

```python
async def get_system_configuration(**kwargs)
```

System configuration (alpha)

> Returns the current system configuration. The response is an envelope
> that groups settings by feature area.
>
> This endpoint is an alpha feature and may be subject to change
> in future releases.

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  SystemConfigurationResponse
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  SystemConfigurationResponse

#### Examples

**Get system configuration:**

```python
def get_system_configuration_example() -> None:
    client = CamundaClient()

    result = client.get_system_configuration()

    print(f"System config: {result}")
```

### get_tenant()

```python
async def get_tenant(tenant_id, *, consistency=None, **kwargs)
```

Get tenant

> Retrieves a single tenant by tenant ID.

**Parameters:**

| Parameter     | Type                           | Description                                                     |
| ------------- | ------------------------------ | --------------------------------------------------------------- |
| `tenant_id`   | `str`                          | The unique identifier of the tenant. Example: customer-service. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`      | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Tenant not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantResult
- **Return type:**
  TenantResult

#### Examples

**Get a tenant:**

```python
def get_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.get_tenant(tenant_id=tenant_id)

    print(f"Tenant: {result.name}")
```

### get_tenant_cluster_variable()

```python
async def get_tenant_cluster_variable(tenant_id, name, *, consistency=None, **kwargs)
```

Get a tenant-scoped cluster variable

> Get a tenant-scoped cluster variable.

**Parameters:**

| Parameter     | Type                           | Description                                                                                                           |
| ------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `tenant_id`   | `str`                          | The unique identifier of the tenant. Example: customer-service.                                                       |
| `name`        | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                                                                       |
| `kwargs`      | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Get a tenant cluster variable:**

```python
def get_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.get_tenant_cluster_variable(
        tenant_id=tenant_id,
        name=name,
    )

    print(f"Variable: {result.name} = {result.value}")
```

### get_topology()

```python
async def get_topology(**kwargs)
```

Get cluster topology

> Obtains the current topology of the cluster the gateway is part of.

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TopologyResponse
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  TopologyResponse

#### Examples

**Get cluster topology:**

```python
def get_topology_example() -> None:
    client = CamundaClient()

    result = client.get_topology()

    print(f"Topology: {result}")
```

### get_usage_metrics()

```python
async def get_usage_metrics(*, start_time, end_time, tenant_id=<camunda_orchestration_sdk.types.Unset object>, with_tenants=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get usage metrics

> Retrieve the usage metrics based on given criteria.

**Parameters:**

| Parameter      | Type                           | Description                                                     |
| -------------- | ------------------------------ | --------------------------------------------------------------- |
| `start_time`   | `datetime.datetime`            | Example: 2025-06-07T13:14:15Z.                                  |
| `end_time`     | `datetime.datetime`            | Example: 2025-06-07T13:14:15Z.                                  |
| `tenant_id`    | `str` \| `Unset`               | The unique identifier of the tenant. Example: customer-service. |
| `with_tenants` | `bool` \| `Unset`              |                                                                 |
| `consistency`  | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`       | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UsageMetricsResponse
- **Return type:**
  UsageMetricsResponse

#### Examples

**Get usage metrics:**

```python
def get_usage_metrics_example() -> None:
    client = CamundaClient()

    result = client.get_usage_metrics(
        start_time=datetime.datetime(2024, 1, 1),
        end_time=datetime.datetime(2024, 12, 31),
    )

    print(f"Metrics: {result}")
```

### get_user()

```python
async def get_user(username, *, consistency=None, **kwargs)
```

Get user

> Get a user by its username.

**Parameters:**

| Parameter     | Type                           | Description                                  |
| ------------- | ------------------------------ | -------------------------------------------- |
| `username`    | `str`                          | The unique name of a user. Example: swillis. |
| `consistency` | `ConsistencyOptions` \| `None` |                                              |
| `kwargs`      | `Any`                          |                                              |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The user with the given username was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserResult
- **Return type:**
  UserResult

#### Examples

**Get a user:**

```python
def get_user_example(username: Username) -> None:
    client = CamundaClient()

    result = client.get_user(username=username)

    print(f"User: {result.username}")
```

### get_user_task()

```python
async def get_user_task(user_task_key, *, consistency=None, **kwargs)
```

Get user task

> Get the user task by the user task key.

**Parameters:**

| Parameter       | Type                           | Description                           |
| --------------- | ------------------------------ | ------------------------------------- |
| `user_task_key` | `str`                          | System-generated key for a user task. |
| `consistency`   | `ConsistencyOptions` \| `None` |                                       |
| `kwargs`        | `Any`                          |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserTaskResult
- **Return type:**
  UserTaskResult

#### Examples

**Get a user task:**

```python
def get_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    task = client.get_user_task(user_task_key=user_task_key)

    print(f"Task: {task.user_task_key}")
```

### get_user_task_form()

```python
async def get_user_task_form(user_task_key, *, consistency=None, **kwargs)
```

Get user task form

> Get the form of a user task.
>
> Note that this endpoint will only return linked forms. This endpoint does not support embedded
> forms.

**Parameters:**

| Parameter       | Type                           | Description                           |
| --------------- | ------------------------------ | ------------------------------------- |
| `user_task_key` | `str`                          | System-generated key for a user task. |
| `consistency`   | `ConsistencyOptions` \| `None` |                                       |
| `kwargs`        | `Any`                          |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  FormResult
- **Return type:**
  FormResult

#### Examples

**Get a user task form:**

```python
def get_user_task_form_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.get_user_task_form(
        user_task_key=user_task_key,
    )

    print(f"Form: {result.form_key}")
```

### get_variable()

```python
async def get_variable(variable_key, *, consistency=None, **kwargs)
```

Get variable

> Get a variable by its key.
>
> This endpoint returns both process-level and local (element-scoped) variables.
> The variable’s scopeKey indicates whether it’s a process-level variable or scoped to a
> specific element instance.

**Parameters:**

| Parameter      | Type                           | Description                                                     |
| -------------- | ------------------------------ | --------------------------------------------------------------- |
| `variable_key` | `str`                          | System-generated key for a variable. Example: 2251799813683287. |
| `consistency`  | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`       | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableResult
- **Return type:**
  VariableResult

#### Examples

**Get a variable:**

```python
def get_variable_example(variable_key: VariableKey) -> None:
    client = CamundaClient()

    result = client.get_variable(
        variable_key=variable_key,
    )

    print(f"Variable: {result.name} = {result.value}")
```

### migrate_process_instance()

```python
async def migrate_process_instance(process_instance_key, *, data, **kwargs)
```

Migrate process instance

> Migrates a process instance to a new process definition.
>
> This request can contain multiple mapping instructions to define mapping between the active
> process instance’s elements and target process definition elements.
>
> Use this to upgrade a process instance to a new version of a process or to
> a different process definition, e.g. to keep your running instances up-to-date with the
> latest process improvements.

**Parameters:**

| Parameter              | Type                                  | Description                                                                                                   |
| ---------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `process_instance_key` | `str`                                 | System-generated key for a process instance. Example: 2251799813690746.                                       |
| `data`                 | `ProcessInstanceMigrationInstruction` | The migration instructions describe how to migrate a process instance from one process definition to another. |
| `kwargs`               | `Any`                                 |                                                                                                               |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance migration failed. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Migrate a process instance:**

```python
def migrate_process_instance_example(
    process_instance_key: ProcessInstanceKey,
    target_process_definition_key: ProcessDefinitionKey,
    source_element_id: ElementId,
    target_element_id: ElementId,
) -> None:
    client = CamundaClient()

    client.migrate_process_instance(
        process_instance_key=process_instance_key,
        data=ProcessInstanceMigrationInstruction(
            target_process_definition_key=target_process_definition_key,
            mapping_instructions=[
                MigrateProcessInstanceMappingInstruction(
                    source_element_id=source_element_id,
                    target_element_id=target_element_id,
                ),
            ],
        ),
    )
```

### migrate_process_instances_batch_operation()

```python
async def migrate_process_instances_batch_operation(*, data, **kwargs)
```

Migrate process instances (batch)

> Migrate multiple process instances.
>
> Since only process instances with ACTIVE state can be migrated, any given
> filters for state are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                            | Description |
| --------- | ----------------------------------------------- | ----------- |
| `data`    | `ProcessInstanceMigrationBatchOperationRequest` |             |
| `kwargs`  | `Any`                                           |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Migrate process instances in batch:**

```python
def migrate_process_instances_batch_operation_example(target_process_definition_key: ProcessDefinitionKey, source_element_id: ElementId, target_element_id: ElementId) -> None:
    client = CamundaClient()

    result = client.migrate_process_instances_batch_operation(
        data=ProcessInstanceMigrationBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
            migration_plan=ProcessInstanceMigrationBatchOperationRequestMigrationPlan(
                target_process_definition_key=target_process_definition_key,
                mapping_instructions=[
                    MigrateProcessInstanceMappingInstruction(
                        source_element_id=source_element_id,
                        target_element_id=target_element_id,
                    ),
                ],
            ),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### modify_process_instance()

```python
async def modify_process_instance(process_instance_key, *, data, **kwargs)
```

Modify process instance

> Modifies a running process instance.
>
> This request can contain multiple instructions to activate an element of the process or
> to terminate an active instance of an element.
>
> Use this to repair a process instance that is stuck on an element or took an unintended path.
> For example, because an external system is not available or doesn’t respond as expected.

**Parameters:**

| Parameter              | Type                                     | Description                                                             |
| ---------------------- | ---------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                    | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `ProcessInstanceModificationInstruction` |                                                                         |
| `kwargs`               | `Any`                                    |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Modify a process instance:**

```python
def modify_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.modify_process_instance(
        process_instance_key=process_instance_key,
        data=ProcessInstanceModificationInstruction(),
    )
```

### modify_process_instances_batch_operation()

```python
async def modify_process_instances_batch_operation(*, data, **kwargs)
```

Modify process instances (batch)

> Modify multiple process instances.
>
> Since only process instances with ACTIVE state can be modified, any given
> filters for state are ignored and overridden during this batch operation.
> In contrast to single modification operation, it is not possible to add variable instructions or
> modify by element key.
> It is only possible to use the element id of the source and target.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                               | Description                                                                                                                                           |
| --------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceModificationBatchOperationRequest` | The process instance filter to define on which process instances tokens should be moved, and new element instances should be activated or terminated. |
| `kwargs`  | `Any`                                              |                                                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Modify process instances in batch:**

```python
def modify_process_instances_batch_operation_example(source_element_id: ElementId, target_element_id: ElementId) -> None:
    client = CamundaClient()

    result = client.modify_process_instances_batch_operation(
        data=ProcessInstanceModificationBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
            move_instructions=[
                ProcessInstanceModificationMoveBatchOperationInstruction(
                    source_element_id=source_element_id,
                    target_element_id=target_element_id,
                ),
            ],
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### pin_clock()

```python
async def pin_clock(*, data, **kwargs)
```

Pin internal clock (alpha)

> Set a precise, static time for the Zeebe engine’s internal clock.
>
> When the clock is pinned, it remains at the specified time and does not advance.
> To change the time, the clock must be pinned again with a new timestamp.
>
> This endpoint is an alpha feature and may be subject to change
> in future releases.

**Parameters:**

| Parameter | Type              | Description |
| --------- | ----------------- | ----------- |
| `data`    | `ClockPinRequest` |             |
| `kwargs`  | `Any`             |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Pin the cluster clock:**

```python
def pin_clock_example() -> None:
    client = CamundaClient()

    client.pin_clock(
        data=ClockPinRequest(
            timestamp=1700000000000,
        ),
    )
```

### publish_message()

```python
async def publish_message(*, data, **kwargs)
```

Publish message

> Publishes a single message.
>
> Messages are published to specific partitions computed from their correlation keys.
> Messages can be buffered.
> The endpoint does not wait for a correlation result.
> Use the message correlation endpoint for such use cases.

**Parameters:**

| Parameter | Type                        | Description |
| --------- | --------------------------- | ----------- |
| `data`    | `MessagePublicationRequest` |             |
| `kwargs`  | `Any`                       |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MessagePublicationResult
- **Return type:**
  MessagePublicationResult

#### Examples

**Publish a message:**

```python
def publish_message_example() -> None:
    client = CamundaClient()

    result = client.publish_message(
        data=MessagePublicationRequest(
            name="order-created",
            correlation_key="order-12345",
            time_to_live=60000,
        )
    )

    print(f"Message key: {result.message_key}")
```

### reset_clock()

```python
async def reset_clock(**kwargs)
```

Reset internal clock (alpha)

> Resets the Zeebe engine’s internal clock to the current system time, enabling it to tick in real-
> time.
> This operation is useful for returning the clock to
> normal behavior after it has been pinned to a specific time.
>
> This endpoint is an alpha feature and may be subject to change
> in future releases.

- **Raises:**
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  None

#### Examples

**Reset the cluster clock:**

```python
def reset_clock_example() -> None:
    client = CamundaClient()

    client.reset_clock()
```

### resolve_incident()

```python
async def resolve_incident(incident_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resolve incident

> Marks the incident as resolved; most likely a call to Update job will be necessary
> to reset the job’s retries, followed by this call.

**Parameters:**

| Parameter      | Type                                   | Description                                                     |
| -------------- | -------------------------------------- | --------------------------------------------------------------- |
| `incident_key` | `str`                                  | System-generated key for a incident. Example: 2251799813689432. |
| `data`         | `IncidentResolutionRequest` \| `Unset` |                                                                 |
| `kwargs`       | `Any`                                  |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The incident with the incidentKey is not found.
  - **errors.ConflictError** – If the response status code is 409. The incident cannot be resolved due to an invalid state. For example, the associated job may have no retries left.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Resolve an incident:**

```python
def resolve_incident_example(incident_key: IncidentKey) -> None:
    client = CamundaClient()

    client.resolve_incident(incident_key=incident_key)
```

### resolve_incidents_batch_operation()

```python
async def resolve_incidents_batch_operation(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resolve related incidents (batch)

> Resolves multiple instances of process instances.
>
> Since only process instances with ACTIVE state can have unresolved incidents, any given
> filters for state are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                                                | Description                                                                                            |
| --------- | ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `data`    | `ProcessInstanceIncidentResolutionBatchOperationRequest` \| `Unset` | The process instance filter that defines which process instances should have their incidents resolved. |
| `kwargs`  | `Any`                                                               |                                                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Resolve incidents in batch:**

```python
def resolve_incidents_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.resolve_incidents_batch_operation(
        data=ProcessInstanceIncidentResolutionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### resolve_process_instance_incidents()

```python
async def resolve_process_instance_incidents(process_instance_key, **kwargs)
```

Resolve related incidents

> Creates a batch operation to resolve multiple incidents of a process instance.

**Parameters:**

| Parameter              | Type  | Description                                                             |
| ---------------------- | ----- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str` | System-generated key for a process instance. Example: 2251799813690746. |
| `kwargs`               | `Any` |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Resolve process instance incidents:**

```python
def resolve_process_instance_incidents_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.resolve_process_instance_incidents(
        process_instance_key=process_instance_key,
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### resolve_secrets()

```python
async def resolve_secrets(*, data, **kwargs)
```

Resolve secrets (alpha)

> Resolve a deduplicated batch of camunda.secrets.\* references for the caller’s
> physical tenant in a single round-trip.
>
> Each reference is authorized and resolved independently. For valid requests, the endpoint
> always responds with HTTP 200: successfully resolved references are returned in resolved,
> while references that could not be resolved (for example not found, malformed or over-long,
> or the caller lacks SECRET:REVEAL on that reference) are returned in errors. A failure of
> one reference never fails the others. Only structurally invalid requests are rejected with
> HTTP 400: a missing or non-array references field, more than 20 references, or a null entry.
>
> This endpoint is an alpha feature and may be subject to change in future releases.
>
> Phase 1: the secret backend is mocked. Only a fixed allow-list of references resolves;
> every other authorized, valid reference returns NOT_FOUND.

**Parameters:**

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `data`    | `SecretResolveRequest` |             |
| `kwargs`  | `Any`                  |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  SecretResolveResult
- **Return type:**
  SecretResolveResult

#### Examples

**Resolve secrets:**

```python
def resolve_secrets_example() -> None:
    client = CamundaClient()

    # Hands the resolved secret to whatever needs it (an HTTP client, a DB
    # driver, ...) without logging it.
    def use_secret(value: str) -> None: ...

    result = client.resolve_secrets(
        data=SecretResolveRequest(
            references=[
                "camunda.secrets.my_api_token",
                "camunda.secrets.db_password",
            ],
        )
    )

    # Successfully resolved references are returned in `resolved`; references that
    # could not be resolved are returned in `errors`, each with a typed error code.
    # Never log a resolved value -- it holds secret material. Pass it straight to
    # the consumer that needs it instead.
    for resolved in result.resolved:
        print(f"Resolved {resolved.reference} (value redacted)")
        use_secret(resolved.value)

    for error in result.errors:
        print(f"Failed to resolve {error.reference}: {error.code.value} - {error.message}")
```

### restore()

```python
async def restore(*, data, **kwargs)
```

Restore from a backup

> Restores the cluster from a backup. The restore is described either by a single backup ID or by a
> time range (from/to) that selects the backups to restore. This endpoint is only accessible while
> the cluster is in recovery mode; requests are rejected otherwise. The request is validated and
> acknowledged, but the restore itself is performed asynchronously.

**Parameters:**

| Parameter | Type             | Description                                                                                                                                                     |
| --------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data`    | `RestoreRequest` | Describes a restore request. Provide either a list of backup IDs or a time range (from/to) that selects the backups to restore; the two are mutually exclusive. |
| `kwargs`  | `Any`            |                                                                                                                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ConflictError** – If the response status code is 409. The cluster is not in recovery mode, so the restore cannot be accepted.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterModeChangeResponse
- **Return type:**
  ClusterModeChangeResponse

#### Examples

**Restore from a backup:**

```python
def restore_example() -> None:
    client = CamundaClient()

    # The cluster must be in recovery mode before a restore is accepted. Provide
    # either a list of backup IDs (one per partition) or a time range (from/to)
    # that selects the backups to restore, but not both.
    result = client.restore(
        data=RestoreRequest(backup_ids=[100, 101]),
    )

    print(f"Cluster change {result.change_id}:")
    for operation in result.planned_changes:
        suffix = f" -> {operation.mode}" if operation.mode else ""
        print(f"  {operation.operation}{suffix}")
```

### resume_batch_operation()

```python
async def resume_batch_operation(batch_operation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resume Batch operation

> Resumes a suspended batch operation.
>
> This is done asynchronously, the progress can be tracked using the batch operation status endpoint
> (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter             | Type             | Description                                                             |
| --------------------- | ---------------- | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`            | System-generated key for an batch operation. Example: 2251799813684321. |
| `data`                | `Any` \| `Unset` |                                                                         |
| `kwargs`              | `Any`            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The batch operation was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Resume a batch operation:**

```python
def resume_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    client.resume_batch_operation(
        batch_operation_key=batch_operation_key,
    )
```

### resume_process_instance()

```python
async def resume_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resume process instance

> Resumes a suspended process instance, returning it to the ACTIVE state and continuing processing.
>
> Only process instances in the SUSPENDED state can be resumed.

**Parameters:**

| Parameter              | Type                                                | Description                                                             |
| ---------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                               | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `None` \| `ResumeProcessInstanceRequest` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                               |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance is not in the SUSPENDED state and cannot be resumed. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Resume a process instance:**

```python
def resume_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.resume_process_instance(
        process_instance_key=process_instance_key,
    )
```

### resume_process_instances_batch_operation()

```python
async def resume_process_instances_batch_operation(*, data, **kwargs)
```

Resume process instances (batch)

> Resumes multiple suspended process instances.
>
> Since only SUSPENDED root instances can be resumed, any given filters for state and
> parentProcessInstanceKey are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                             | Description                                                                         |
| --------- | ------------------------------------------------ | ----------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceResumptionBatchOperationRequest` | The process instance filter that defines which process instances should be resumed. |
| `kwargs`  | `Any`                                            |                                                                                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Resume process instances in batch:**

```python
def resume_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.resume_process_instances_batch_operation(
        data=ProcessInstanceResumptionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### run_workers()

```python
async def run_workers()
```

### search_agent_instance_history()

```python
async def search_agent_instance_history(agent_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search agent instance history

> Searches the conversation history of an agent instance. Committed items
> are returned by default.

**Parameters:**

| Parameter            | Type                                         | Description                                                            |
| -------------------- | -------------------------------------------- | ---------------------------------------------------------------------- |
| `agent_instance_key` | `str`                                        | System-generated key for an agent instance. Example: 4503599627370496. |
| `data`               | `AgentInstanceHistorySearchQuery` \| `Unset` | Agent instance history search request.                                 |
| `consistency`        | `ConsistencyOptions` \| `None`               |                                                                        |
| `kwargs`             | `Any`                                        |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceHistorySearchQueryResult
- **Return type:**
  AgentInstanceHistorySearchQueryResult

#### Examples

**Search agent instance history:**

```python
def search_agent_instance_history_example(agent_instance_key: AgentInstanceKey) -> None:
    client = CamundaClient()

    result = client.search_agent_instance_history(
        agent_instance_key=agent_instance_key,
        data=AgentInstanceHistorySearchQuery(),
    )

    print(f"Found {len(result.items)} history items")
```

### search_agent_instances()

```python
async def search_agent_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search agent instances

> Search for agent instances based on given criteria.

**Parameters:**

| Parameter     | Type                                  | Description                    |
| ------------- | ------------------------------------- | ------------------------------ |
| `data`        | `AgentInstanceSearchQuery` \| `Unset` | Agent instance search request. |
| `consistency` | `ConsistencyOptions` \| `None`        |                                |
| `kwargs`      | `Any`                                 |                                |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceSearchQueryResult
- **Return type:**
  AgentInstanceSearchQueryResult

#### Examples

**Search agent instances:**

```python
def search_agent_instances_example() -> None:
    client = CamundaClient()

    result = client.search_agent_instances(data=AgentInstanceSearchQuery())

    if not isinstance(result.items, Unset):
        for agent_instance in result.items:
            print(f"Agent instance key: {agent_instance.agent_instance_key}")
```

### search_audit_logs()

```python
async def search_audit_logs(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search audit logs

> Search for audit logs based on given criteria.

**Parameters:**

| Parameter     | Type                                    | Description               |
| ------------- | --------------------------------------- | ------------------------- |
| `data`        | `AuditLogSearchQueryRequest` \| `Unset` | Audit log search request. |
| `consistency` | `ConsistencyOptions` \| `None`          |                           |
| `kwargs`      | `Any`                                   |                           |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuditLogSearchQueryResult
- **Return type:**
  AuditLogSearchQueryResult

#### Examples

**Search audit logs:**

```python
def search_audit_logs_example() -> None:
    client = CamundaClient()

    result = client.search_audit_logs(
        data=AuditLogSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for log in result.items:
            print(f"Audit log: {log.audit_log_key}")
```

### search_authorizations()

```python
async def search_authorizations(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search authorizations

> Search for authorizations based on given criteria.

**Parameters:**

| Parameter     | Type                                  | Description |
| ------------- | ------------------------------------- | ----------- |
| `data`        | `AuthorizationSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`        |             |
| `kwargs`      | `Any`                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuthorizationSearchResult
- **Return type:**
  AuthorizationSearchResult

#### Examples

**Search authorizations:**

```python
def search_authorizations_example() -> None:
    client = CamundaClient()

    result = client.search_authorizations(
        data=AuthorizationSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for auth in result.items:
            print(f"Authorization: {auth.authorization_key}")
```

### search_batch_operation_items()

```python
async def search_batch_operation_items(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search batch operation items

> Search for batch operation items based on given criteria.

**Parameters:**

| Parameter     | Type                                       | Description                          |
| ------------- | ------------------------------------------ | ------------------------------------ |
| `data`        | `BatchOperationItemSearchQuery` \| `Unset` | Batch operation item search request. |
| `consistency` | `ConsistencyOptions` \| `None`             |                                      |
| `kwargs`      | `Any`                                      |                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationItemSearchQueryResult
- **Return type:**
  BatchOperationItemSearchQueryResult

#### Examples

**Search batch operation items:**

```python
def search_batch_operation_items_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    result = client.search_batch_operation_items(
        batch_operation_key=batch_operation_key,
        data=BatchOperationItemSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for item in result.items:
            print(f"Item: {item.item_key}")
```

### search_batch_operations()

```python
async def search_batch_operations(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search batch operations

> Search for batch operations based on given criteria.

**Parameters:**

| Parameter     | Type                                   | Description                     |
| ------------- | -------------------------------------- | ------------------------------- |
| `data`        | `BatchOperationSearchQuery` \| `Unset` | Batch operation search request. |
| `consistency` | `ConsistencyOptions` \| `None`         |                                 |
| `kwargs`      | `Any`                                  |                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationSearchQueryResult
- **Return type:**
  BatchOperationSearchQueryResult

#### Examples

**Search batch operations:**

```python
def search_batch_operations_example() -> None:
    client = CamundaClient()

    result = client.search_batch_operations(
        data=BatchOperationSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for op in result.items:
            print(f"Batch operation: {op.batch_operation_key}")
```

### search_clients_for_group()

```python
async def search_clients_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group clients

> Search clients assigned to a group.

**Parameters:**

| Parameter     | Type                                       | Description                                             |
| ------------- | ------------------------------------------ | ------------------------------------------------------- |
| `group_id`    | `str`                                      | The unique identifier of a group. Example: engineering. |
| `data`        | `GroupClientSearchQueryRequest` \| `Unset` |                                                         |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                         |
| `kwargs`      | `Any`                                      |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupClientSearchResult
- **Return type:**
  GroupClientSearchResult

#### Examples

**Search clients in a group:**

```python
def search_clients_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_clients_for_group(
        group_id=group_id,
    )

    if not isinstance(result.items, Unset):
        for c in result.items:
            print(f"Client: {c.client_id}")
```

### search_clients_for_role()

```python
async def search_clients_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role clients

> Search clients with assigned role.

**Parameters:**

| Parameter     | Type                                      | Description                                      |
| ------------- | ----------------------------------------- | ------------------------------------------------ |
| `role_id`     | `str`                                     | The unique identifier of a role. Example: admin. |
| `data`        | `RoleClientSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`            |                                                  |
| `kwargs`      | `Any`                                     |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleClientSearchResult
- **Return type:**
  RoleClientSearchResult

#### Examples

**Search clients for a role:**

```python
def search_clients_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_clients_for_role(
        role_id=role_id,
    )

    if not isinstance(result.items, Unset):
        for c in result.items:
            print(f"Client: {c.client_id}")
```

### search_clients_for_tenant()

```python
async def search_clients_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search clients for tenant

> Retrieves a filtered and sorted list of clients for a specified tenant.

**Parameters:**

| Parameter     | Type                                        | Description                                                     |
| ------------- | ------------------------------------------- | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                       | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `TenantClientSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`              |                                                                 |
| `kwargs`      | `Any`                                       |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantClientSearchResult
- **Return type:**
  TenantClientSearchResult

#### Examples

**Search clients for a tenant:**

```python
def search_clients_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_clients_for_tenant(
        tenant_id=tenant_id,
    )

    if not isinstance(result.items, Unset):
        for c in result.items:
            print(f"Client: {c.client_id}")
```

### search_cluster_variables()

```python
async def search_cluster_variables(*, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search for cluster variables based on given criteria. By default, long variable values in the
response are truncated.

**Parameters:**

| Parameter         | Type                                           | Description                            |
| ----------------- | ---------------------------------------------- | -------------------------------------- |
| `truncate_values` | `bool` \| `Unset`                              |                                        |
| `data`            | `ClusterVariableSearchQueryRequest` \| `Unset` | Cluster variable search query request. |
| `consistency`     | `ConsistencyOptions` \| `None`                 |                                        |
| `kwargs`          | `Any`                                          |                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableSearchQueryResult
- **Return type:**
  ClusterVariableSearchQueryResult

#### Examples

**Search cluster variables:**

```python
def search_cluster_variables_example() -> None:
    client = CamundaClient()

    result = client.search_cluster_variables(
        data=ClusterVariableSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_correlated_message_subscriptions()

```python
async def search_correlated_message_subscriptions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search correlated message subscriptions

> Search correlated message subscriptions based on given criteria.

**Parameters:**

| Parameter     | Type                                                  | Description |
| ------------- | ----------------------------------------------------- | ----------- |
| `data`        | `CorrelatedMessageSubscriptionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                        |             |
| `kwargs`      | `Any`                                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  CorrelatedMessageSubscriptionSearchQueryResult
- **Return type:**
  CorrelatedMessageSubscriptionSearchQueryResult

#### Examples

**Search correlated message subscriptions:**

```python
def search_correlated_message_subscriptions_example() -> None:
    client = CamundaClient()

    result = client.search_correlated_message_subscriptions(
        data=CorrelatedMessageSubscriptionSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for sub in result.items:
            print(f"Correlated subscription: {sub.message_name}")
```

### search_decision_definitions()

```python
async def search_decision_definitions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search decision definitions

> Search for decision definitions based on given criteria.

**Parameters:**

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `data`        | `DecisionDefinitionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`             |             |
| `kwargs`      | `Any`                                      |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionDefinitionSearchQueryResult
- **Return type:**
  DecisionDefinitionSearchQueryResult

#### Examples

**Search decision definitions:**

```python
def search_decision_definitions_example() -> None:
    client = CamundaClient()

    result = client.search_decision_definitions(
        data=DecisionDefinitionSearchQuery()
    )

    if not isinstance(result.items, Unset):
        for definition in result.items:
            print(f"Decision: {definition.decision_definition_id}")
```

### search_decision_instances()

```python
async def search_decision_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search decision instances

> Search for decision instances based on given criteria.

**Parameters:**

| Parameter     | Type                                     | Description |
| ------------- | ---------------------------------------- | ----------- |
| `data`        | `DecisionInstanceSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`           |             |
| `kwargs`      | `Any`                                    |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionInstanceSearchQueryResult
- **Return type:**
  DecisionInstanceSearchQueryResult

#### Examples

**Search decision instances:**

```python
def search_decision_instances_example() -> None:
    client = CamundaClient()

    result = client.search_decision_instances(
        data=DecisionInstanceSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for di in result.items:
            print(f"Decision instance: {di.decision_definition_id}")
```

### search_decision_requirements()

```python
async def search_decision_requirements(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search decision requirements

> Search for decision requirements based on given criteria.

**Parameters:**

| Parameter     | Type                                         | Description |
| ------------- | -------------------------------------------- | ----------- |
| `data`        | `DecisionRequirementsSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`               |             |
| `kwargs`      | `Any`                                        |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionRequirementsSearchQueryResult
- **Return type:**
  DecisionRequirementsSearchQueryResult

#### Examples

**Search decision requirements:**

```python
def search_decision_requirements_example() -> None:
    client = CamundaClient()

    result = client.search_decision_requirements(
        data=DecisionRequirementsSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for drd in result.items:
            print(f"DRD: {drd.decision_requirements_name}")
```

### search_element_instance_incidents()

```python
async def search_element_instance_incidents(element_instance_key, *, data, consistency=None, **kwargs)
```

Search for incidents of a specific element instance

> Search for incidents caused by the specified element instance, including incidents of any child
> instances created from this element instance.
>
> Although the elementInstanceKey is provided as a path parameter to indicate the root element
> instance,
> you may also include an elementInstanceKey within the filter object to narrow results to specific
> child element instances. This is useful, for example, if you want to isolate incidents associated
> with
> nested or subordinate elements within the given element instance while excluding incidents directly
> tied
> to the root element itself.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `element_instance_key` | `str`                          | System-generated key for a element instance. Example: 2251799813686789. |
| `data`                 | `IncidentSearchQuery`          |                                                                         |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The element instance with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentSearchQueryResult
- **Return type:**
  IncidentSearchQueryResult

#### Examples

**Search element instance incidents:**

```python
def search_element_instance_incidents_example(
    element_instance_key: ElementInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.search_element_instance_incidents(
        element_instance_key=element_instance_key,
        data=IncidentSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for incident in result.items:
            print(f"Incident: {incident.incident_key}")
```

### search_element_instance_wait_states()

```python
async def search_element_instance_wait_states(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search element instance wait states

> Returns the wait states for element instances matching the given filter.

**Parameters:**

| Parameter     | Type                                       | Description                          |
| ------------- | ------------------------------------------ | ------------------------------------ |
| `data`        | `ElementInstanceWaitStateQuery` \| `Unset` | Element instance inspection request. |
| `consistency` | `ConsistencyOptions` \| `None`             |                                      |
| `kwargs`      | `Any`                                      |                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ElementInstanceWaitStateQueryResult
- **Return type:**
  ElementInstanceWaitStateQueryResult

#### Examples

**Search element instance wait states:**

```python
def search_element_instance_wait_states_example() -> None:
    client = CamundaClient()

    result = client.search_element_instance_wait_states(
        data=ElementInstanceWaitStateQuery(),
    )

    for wait_state in result.items:
        details = wait_state.details
        if isinstance(details, JobWaitStateDetails):
            info = f"waiting on job '{details.job_type}'"
        elif isinstance(details, MessageWaitStateDetails):
            info = f"waiting for message '{details.message_name}'"
        else:
            info = f"waiting ({details.wait_state_type})"
        print(
            f"Element {wait_state.element_id} "
            f"(instance {wait_state.element_instance_key}) {info}"
        )
```

### search_element_instances()

```python
async def search_element_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search element instances

> Search for element instances based on given criteria.

**Parameters:**

| Parameter     | Type                                    | Description                      |
| ------------- | --------------------------------------- | -------------------------------- |
| `data`        | `ElementInstanceSearchQuery` \| `Unset` | Element instance search request. |
| `consistency` | `ConsistencyOptions` \| `None`          |                                  |
| `kwargs`      | `Any`                                   |                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ElementInstanceSearchQueryResult
- **Return type:**
  ElementInstanceSearchQueryResult

#### Examples

**Search element instances:**

```python
def search_element_instances_example() -> None:
    client = CamundaClient()

    result = client.search_element_instances(
        data=ElementInstanceSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for ei in result.items:
            print(f"Element instance: {ei.element_instance_key}")
```

### search_global_task_listeners()

```python
async def search_global_task_listeners(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search global user task listeners

> Search for global user task listeners based on given criteria.

**Parameters:**

| Parameter     | Type                                              | Description                           |
| ------------- | ------------------------------------------------- | ------------------------------------- |
| `data`        | `GlobalTaskListenerSearchQueryRequest` \| `Unset` | Global listener search query request. |
| `consistency` | `ConsistencyOptions` \| `None`                    |                                       |
| `kwargs`      | `Any`                                             |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerSearchQueryResult
- **Return type:**
  GlobalTaskListenerSearchQueryResult

#### Examples

**Search global task listeners:**

```python
def search_global_task_listeners_example() -> None:
    client = CamundaClient()

    result = client.search_global_task_listeners(
        data=GlobalTaskListenerSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for listener in result.items:
            print(f"Listener: {listener.id}")
```

### search_group_ids_for_tenant()

```python
async def search_group_ids_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search groups for tenant

> Retrieves a filtered and sorted list of groups for a specified tenant.

**Parameters:**

| Parameter     | Type                                       | Description                                                     |
| ------------- | ------------------------------------------ | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                      | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `TenantGroupSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                                 |
| `kwargs`      | `Any`                                      |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantGroupSearchResult
- **Return type:**
  TenantGroupSearchResult

#### Examples

**Search groups for a tenant:**

```python
def search_group_ids_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_group_ids_for_tenant(
        tenant_id=tenant_id,
        data=TenantGroupSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for group in result.items:
            print(f"Group: {group.group_id}")
```

### search_groups()

```python
async def search_groups(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search groups

> Search for groups based on given criteria.

**Parameters:**

| Parameter     | Type                                 | Description           |
| ------------- | ------------------------------------ | --------------------- |
| `data`        | `GroupSearchQueryRequest` \| `Unset` | Group search request. |
| `consistency` | `ConsistencyOptions` \| `None`       |                       |
| `kwargs`      | `Any`                                |                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupSearchQueryResult
- **Return type:**
  GroupSearchQueryResult

#### Examples

**Search groups:**

```python
def search_groups_example() -> None:
    client = CamundaClient()

    result = client.search_groups(
        data=GroupSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for group in result.items:
            print(f"Group: {group.name}")
```

### search_groups_for_role()

```python
async def search_groups_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role groups

> Search groups with assigned role.

**Parameters:**

| Parameter     | Type                                     | Description                                      |
| ------------- | ---------------------------------------- | ------------------------------------------------ |
| `role_id`     | `str`                                    | The unique identifier of a role. Example: admin. |
| `data`        | `RoleGroupSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`           |                                                  |
| `kwargs`      | `Any`                                    |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleGroupSearchResult
- **Return type:**
  RoleGroupSearchResult

#### Examples

**Search groups for a role:**

```python
def search_groups_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_groups_for_role(
        role_id=role_id,
        data=RoleGroupSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for group in result.items:
            print(f"Group: {group.group_id}")
```

### search_incidents()

```python
async def search_incidents(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search incidents

> Search for incidents based on given criteria.

**Parameters:**

| Parameter     | Type                             | Description |
| ------------- | -------------------------------- | ----------- |
| `data`        | `IncidentSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`   |             |
| `kwargs`      | `Any`                            |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentSearchQueryResult
- **Return type:**
  IncidentSearchQueryResult

#### Examples

**Search incidents:**

```python
def search_incidents_example() -> None:
    client = CamundaClient()

    result = client.search_incidents(
        data=IncidentSearchQuery()
    )

    if not isinstance(result.items, Unset):
        for incident in result.items:
            print(f"Incident key: {incident.incident_key}")
```

### search_jobs()

```python
async def search_jobs(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search jobs

> Search for jobs based on given criteria.

**Parameters:**

| Parameter     | Type                           | Description         |
| ------------- | ------------------------------ | ------------------- |
| `data`        | `JobSearchQuery` \| `Unset`    | Job search request. |
| `consistency` | `ConsistencyOptions` \| `None` |                     |
| `kwargs`      | `Any`                          |                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobSearchQueryResult
- **Return type:**
  JobSearchQueryResult

#### Examples

**Search jobs:**

```python
def search_jobs_example() -> None:
    client = CamundaClient()

    result = client.search_jobs(
        data=JobSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for job in result.items:
            print(f"Job: {job.job_key}")
```

### search_mapping_rule()

```python
async def search_mapping_rule(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search mapping rules

> Search for mapping rules based on given criteria.

**Parameters:**

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`             |             |
| `kwargs`      | `Any`                                      |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleSearchQueryResult
- **Return type:**
  MappingRuleSearchQueryResult

#### Examples

**Search mapping rules:**

```python
def search_mapping_rule_example() -> None:
    client = CamundaClient()

    result = client.search_mapping_rule(
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.name}")
```

### search_mapping_rules_for_group()

```python
async def search_mapping_rules_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group mapping rules

> Search mapping rules assigned to a group.

**Parameters:**

| Parameter     | Type                                       | Description                                             |
| ------------- | ------------------------------------------ | ------------------------------------------------------- |
| `group_id`    | `str`                                      | The unique identifier of a group. Example: engineering. |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |                                                         |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                         |
| `kwargs`      | `Any`                                      |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupMappingRuleSearchResult
- **Return type:**
  GroupMappingRuleSearchResult

#### Examples

**Search mapping rules for a group:**

```python
def search_mapping_rules_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_mapping_rules_for_group(
        group_id=group_id,
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.mapping_rule_id}")
```

### search_mapping_rules_for_role()

```python
async def search_mapping_rules_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role mapping rules

> Search mapping rules with assigned role.

**Parameters:**

| Parameter     | Type                                       | Description                                      |
| ------------- | ------------------------------------------ | ------------------------------------------------ |
| `role_id`     | `str`                                      | The unique identifier of a role. Example: admin. |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                  |
| `kwargs`      | `Any`                                      |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleMappingRuleSearchResult
- **Return type:**
  RoleMappingRuleSearchResult

#### Examples

**Search mapping rules for a role:**

```python
def search_mapping_rules_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_mapping_rules_for_role(
        role_id=role_id,
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.mapping_rule_id}")
```

### search_mapping_rules_for_tenant()

```python
async def search_mapping_rules_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search mapping rules for tenant

> Retrieves a filtered and sorted list of MappingRules for a specified tenant.

**Parameters:**

| Parameter     | Type                                       | Description                                                     |
| ------------- | ------------------------------------------ | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                      | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                                 |
| `kwargs`      | `Any`                                      |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantMappingRuleSearchResult
- **Return type:**
  TenantMappingRuleSearchResult

#### Examples

**Search mapping rules for a tenant:**

```python
def search_mapping_rules_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_mapping_rules_for_tenant(
        tenant_id=tenant_id,
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.mapping_rule_id}")
```

### search_message_subscriptions()

```python
async def search_message_subscriptions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search message subscriptions

> Search for message subscriptions based on given criteria.
>
> By default, both start and intermediate event subscriptions are returned. Use the
> messageSubscriptionType filter to restrict results to a single type.
>
> **Version notes:**

- Start event subscriptions are only captured for deployments made with 8.10 or later.
- The messageSubscriptionType field is only populated for data created

> with Camunda 8.10 or later. For pre-8.10 data, intermediate event entries have no
> messageSubscriptionType value stored. For convenience, the API returns PROCESS_EVENT
> as a default for such search results, though.

- Searching for intermediate event subscriptions **including legacy data** can be achieved
  by filtering for messageSubscriptionType not matching START_EVENT.

**Parameters:**

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `data`        | `MessageSubscriptionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`              |             |
| `kwargs`      | `Any`                                       |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MessageSubscriptionSearchQueryResult
- **Return type:**
  MessageSubscriptionSearchQueryResult

#### Examples

**Search message subscriptions:**

```python
def search_message_subscriptions_example() -> None:
    client = CamundaClient()

    result = client.search_message_subscriptions(
        data=MessageSubscriptionSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for sub in result.items:
            print(f"Subscription: {sub.message_name}")
```

### search_process_definition_variable_names()

```python
async def search_process_definition_variable_names(process_definition_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search process definition variable names

> Search for distinct variable names defined on a process definition, optionally narrowed by the name
> filter.

**Parameters:**

| Parameter                | Type                                                  | Description                                                                        |
| ------------------------ | ----------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                                                 | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `data`                   | `ProcessDefinitionVariableNameSearchQuery` \| `Unset` | Process definition variable name search query request.                             |
| `consistency`            | `ConsistencyOptions` \| `None`                        |                                                                                    |
| `kwargs`                 | `Any`                                                 |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionVariableNameSearchQueryResult
- **Return type:**
  ProcessDefinitionVariableNameSearchQueryResult

#### Examples

**Search process definition variable names:**

```python
def search_process_definition_variable_names_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.search_process_definition_variable_names(
        process_definition_key=process_definition_key,
        data=ProcessDefinitionVariableNameSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for variable in result.items:
            print(f"Variable name: {variable.name}")
```

### search_process_definitions()

```python
async def search_process_definitions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search process definitions

> Search for process definitions based on given criteria.

**Parameters:**

| Parameter     | Type                                      | Description |
| ------------- | ----------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`            |             |
| `kwargs`      | `Any`                                     |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionSearchQueryResult
- **Return type:**
  ProcessDefinitionSearchQueryResult

#### Examples

**Search process definitions:**

```python
def search_process_definitions_example() -> None:
    client = CamundaClient()

    result = client.search_process_definitions(
        data=ProcessDefinitionSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for pd in result.items:
            print(f"Process definition: {pd.name}")
```

### search_process_instance_incidents()

```python
async def search_process_instance_incidents(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search related incidents

> Search for incidents caused by the process instance or any of its called process or decision
> instances.
>
> Although the processInstanceKey is provided as a path parameter to indicate the root process
> instance,
> you may also include a processInstanceKey within the filter object to narrow results to specific
> child process instances. This is useful, for example, if you want to isolate incidents associated
> with
> subprocesses or called processes under the root instance while excluding incidents directly tied to
> the root.

**Parameters:**

| Parameter              | Type                             | Description                                                             |
| ---------------------- | -------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                            | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `IncidentSearchQuery` \| `Unset` |                                                                         |
| `consistency`          | `ConsistencyOptions` \| `None`   |                                                                         |
| `kwargs`               | `Any`                            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentSearchQueryResult
- **Return type:**
  IncidentSearchQueryResult

#### Examples

**Search process instance incidents:**

```python
def search_process_instance_incidents_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.search_process_instance_incidents(
        process_instance_key=process_instance_key,
        data=IncidentSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for incident in result.items:
            print(f"Incident: {incident.incident_key}")
```

### search_process_instances()

```python
async def search_process_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search process instances

> Search for process instances based on given criteria.

**Parameters:**

| Parameter     | Type                                    | Description                      |
| ------------- | --------------------------------------- | -------------------------------- |
| `data`        | `ProcessInstanceSearchQuery` \| `Unset` | Process instance search request. |
| `consistency` | `ConsistencyOptions` \| `None`          |                                  |
| `kwargs`      | `Any`                                   |                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceSearchQueryResult
- **Return type:**
  ProcessInstanceSearchQueryResult

#### Examples

**Search process instances:**

```python
def search_process_instances_example() -> None:
    client = CamundaClient()

    result = client.search_process_instances(
        data=ProcessInstanceSearchQuery(
            filter_=ProcessInstanceSearchQueryFilter(
                process_definition_id="order-process",
            ),
            sort=[
                ProcessInstanceSearchQuerySortRequest(
                    field=ProcessInstanceSearchQuerySortRequestField.STARTDATE,
                    order=SortOrderEnum.DESC,
                )
            ],
            page=LimitBasedPagination(limit=10),
        )
    )

    for instance in result.items:
        print(f"{instance.process_instance_key}: {instance.state}")
    print(f"Total: {result.page.total_items}")
```

### search_resources()

```python
async def search_resources(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search resources

> Search for deployed resources based on given criteria.

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective search APIs.
:::

- **data**: :type data: ResourceSearchQuery | Unset

````

* **Raises:**
  * **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  * **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  * **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  ResourceSearchQueryResult
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `data` | `ResourceSearchQuery` \| `Unset` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  ResourceSearchQueryResult

#### Examples

**Search resources:**

```python
def search_resources_example() -> None:
    client = CamundaClient()

    result = client.search_resources(
        data=ResourceSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for resource in result.items:
            print(f"Resource: {resource.resource_name}")
````

### search_roles()

```python
async def search_roles(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search roles

> Search for roles based on given criteria.

**Parameters:**

| Parameter     | Type                                | Description          |
| ------------- | ----------------------------------- | -------------------- |
| `data`        | `RoleSearchQueryRequest` \| `Unset` | Role search request. |
| `consistency` | `ConsistencyOptions` \| `None`      |                      |
| `kwargs`      | `Any`                               |                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleSearchQueryResult
- **Return type:**
  RoleSearchQueryResult

#### Examples

**Search roles:**

```python
def search_roles_example() -> None:
    client = CamundaClient()

    result = client.search_roles(
        data=RoleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for role in result.items:
            print(f"Role: {role.name}")
```

### search_roles_for_group()

```python
async def search_roles_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group roles

> Search roles assigned to a group.

**Parameters:**

| Parameter     | Type                                | Description                                             |
| ------------- | ----------------------------------- | ------------------------------------------------------- |
| `group_id`    | `str`                               | The unique identifier of a group. Example: engineering. |
| `data`        | `RoleSearchQueryRequest` \| `Unset` | Role search request.                                    |
| `consistency` | `ConsistencyOptions` \| `None`      |                                                         |
| `kwargs`      | `Any`                               |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupRoleSearchResult
- **Return type:**
  GroupRoleSearchResult

#### Examples

**Search roles for a group:**

```python
def search_roles_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_roles_for_group(
        group_id=group_id,
        data=RoleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for role in result.items:
            print(f"Role: {role.name}")
```

### search_roles_for_tenant()

```python
async def search_roles_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search roles for tenant

> Retrieves a filtered and sorted list of roles for a specified tenant.

**Parameters:**

| Parameter     | Type                                | Description                                                     |
| ------------- | ----------------------------------- | --------------------------------------------------------------- |
| `tenant_id`   | `str`                               | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `RoleSearchQueryRequest` \| `Unset` | Role search request.                                            |
| `consistency` | `ConsistencyOptions` \| `None`      |                                                                 |
| `kwargs`      | `Any`                               |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantRoleSearchResult
- **Return type:**
  TenantRoleSearchResult

#### Examples

**Search roles for a tenant:**

```python
def search_roles_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_roles_for_tenant(
        tenant_id=tenant_id,
        data=RoleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for role in result.items:
            print(f"Role: {role.name}")
```

### search_tenants()

```python
async def search_tenants(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search tenants

> Retrieves a filtered and sorted list of tenants.

**Parameters:**

| Parameter     | Type                                  | Description           |
| ------------- | ------------------------------------- | --------------------- |
| `data`        | `TenantSearchQueryRequest` \| `Unset` | Tenant search request |
| `consistency` | `ConsistencyOptions` \| `None`        |                       |
| `kwargs`      | `Any`                                 |                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantSearchQueryResult
- **Return type:**
  TenantSearchQueryResult

#### Examples

**Search tenants:**

```python
def search_tenants_example() -> None:
    client = CamundaClient()

    result = client.search_tenants(
        data=TenantSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for tenant in result.items:
            print(f"Tenant: {tenant.name}")
```

### search_user_task_audit_logs()

```python
async def search_user_task_audit_logs(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user task audit logs

> Search for user task audit logs based on given criteria.

**Parameters:**

| Parameter       | Type                                            | Description                           |
| --------------- | ----------------------------------------------- | ------------------------------------- |
| `user_task_key` | `str`                                           | System-generated key for a user task. |
| `data`          | `UserTaskAuditLogSearchQueryRequest` \| `Unset` | User task search query request.       |
| `consistency`   | `ConsistencyOptions` \| `None`                  |                                       |
| `kwargs`        | `Any`                                           |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuditLogSearchQueryResult
- **Return type:**
  AuditLogSearchQueryResult

#### Examples

**Search user task audit logs:**

```python
def search_user_task_audit_logs_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.search_user_task_audit_logs(
        user_task_key=user_task_key,
        data=UserTaskAuditLogSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for log in result.items:
            print(f"Audit log: {log.audit_log_key}")
```

### search_user_task_effective_variables()

```python
async def search_user_task_effective_variables(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user task effective variables

> Search for the effective variables of a user task. This endpoint returns deduplicated
> variables where each variable name appears at most once. When the same variable name exists
> at multiple scope levels in the scope hierarchy, the value from the innermost scope (closest
> to the user task) takes precedence. This is useful for retrieving the actual runtime state
> of variables as seen by the user task. By default, long variable values in the response are
> truncated.

**Parameters:**

| Parameter         | Type                                                     | Description                                                                           |
| ----------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| `user_task_key`   | `str`                                                    | System-generated key for a user task.                                                 |
| `truncate_values` | `bool` \| `Unset`                                        |                                                                                       |
| `data`            | `UserTaskEffectiveVariableSearchQueryRequest` \| `Unset` | User task effective variable search query request. Uses offset-based pagination only. |
| `consistency`     | `ConsistencyOptions` \| `None`                           |                                                                                       |
| `kwargs`          | `Any`                                                    |                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableSearchQueryResult
- **Return type:**
  VariableSearchQueryResult

#### Examples

**Search user task effective variables:**

```python
def search_user_task_effective_variables_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.search_user_task_effective_variables(
        user_task_key=user_task_key,
    )

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_user_task_variables()

```python
async def search_user_task_variables(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user task variables

> Search for user task variables based on given criteria. This endpoint returns all variable
> documents visible from the user task’s scope, including variables from parent scopes in the
> scope hierarchy. If the same variable name exists at multiple scope levels, each scope’s
> variable is returned as a separate result. Use the
> /user-tasks/{userTaskKey}/effective-variables/search endpoint to get deduplicated variables
> where the innermost scope takes precedence. By default, long variable values in the response
> are truncated.

**Parameters:**

| Parameter         | Type                                            | Description                           |
| ----------------- | ----------------------------------------------- | ------------------------------------- |
| `user_task_key`   | `str`                                           | System-generated key for a user task. |
| `truncate_values` | `bool` \| `Unset`                               |                                       |
| `data`            | `UserTaskVariableSearchQueryRequest` \| `Unset` | User task search query request.       |
| `consistency`     | `ConsistencyOptions` \| `None`                  |                                       |
| `kwargs`          | `Any`                                           |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableSearchQueryResult
- **Return type:**
  VariableSearchQueryResult

#### Examples

**Search user task variables:**

```python
def search_user_task_variables_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.search_user_task_variables(
        user_task_key=user_task_key,
    )

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_user_tasks()

```python
async def search_user_tasks(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user tasks

> Search for user tasks based on given criteria.

**Parameters:**

| Parameter     | Type                             | Description                     |
| ------------- | -------------------------------- | ------------------------------- |
| `data`        | `UserTaskSearchQuery` \| `Unset` | User task search query request. |
| `consistency` | `ConsistencyOptions` \| `None`   |                                 |
| `kwargs`      | `Any`                            |                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserTaskSearchQueryResult
- **Return type:**
  UserTaskSearchQueryResult

#### Examples

**Search user tasks:**

```python
def search_user_tasks_example() -> None:
    client = CamundaClient()

    result = client.search_user_tasks(
        data=UserTaskSearchQuery()
    )

    if not isinstance(result.items, Unset):
        for task in result.items:
            print(f"Task: {task.user_task_key}")
```

### search_users()

```python
async def search_users(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search users

> Search for users based on given criteria.

**Parameters:**

| Parameter     | Type                                | Description |
| ------------- | ----------------------------------- | ----------- |
| `data`        | `UserSearchQueryRequest` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`      |             |
| `kwargs`      | `Any`                               |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserSearchResult
- **Return type:**
  UserSearchResult

#### Examples

**Search users:**

```python
def search_users_example() -> None:
    client = CamundaClient()

    result = client.search_users(
        data=UserSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_users_for_group()

```python
async def search_users_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group users

> Search users assigned to a group.

**Parameters:**

| Parameter     | Type                                     | Description                                             |
| ------------- | ---------------------------------------- | ------------------------------------------------------- |
| `group_id`    | `str`                                    | The unique identifier of a group. Example: engineering. |
| `data`        | `GroupUserSearchQueryRequest` \| `Unset` |                                                         |
| `consistency` | `ConsistencyOptions` \| `None`           |                                                         |
| `kwargs`      | `Any`                                    |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupUserSearchResult
- **Return type:**
  GroupUserSearchResult

#### Examples

**Search users in a group:**

```python
def search_users_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_users_for_group(
        group_id=group_id,
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_users_for_role()

```python
async def search_users_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role users

> Search users with assigned role.

**Parameters:**

| Parameter     | Type                                    | Description                                      |
| ------------- | --------------------------------------- | ------------------------------------------------ |
| `role_id`     | `str`                                   | The unique identifier of a role. Example: admin. |
| `data`        | `RoleUserSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`          |                                                  |
| `kwargs`      | `Any`                                   |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleUserSearchResult
- **Return type:**
  RoleUserSearchResult

#### Examples

**Search users for a role:**

```python
def search_users_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_users_for_role(
        role_id=role_id,
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_users_for_tenant()

```python
async def search_users_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search users for tenant

> Retrieves a filtered and sorted list of users for a specified tenant.

**Parameters:**

| Parameter     | Type                                      | Description                                                     |
| ------------- | ----------------------------------------- | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                     | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `TenantUserSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`            |                                                                 |
| `kwargs`      | `Any`                                     |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantUserSearchResult
- **Return type:**
  TenantUserSearchResult

#### Examples

**Search users for a tenant:**

```python
def search_users_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_users_for_tenant(
        tenant_id=tenant_id,
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_variables()

```python
async def search_variables(*, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search variables

> Search for variables based on given criteria.
>
> This endpoint returns variables that exist directly at the specified scopes - it does not
> include variables from parent scopes that would be visible through the scope hierarchy.
>
> Variables can be process-level (scoped to the process instance) or local (scoped to specific
> BPMN elements like tasks, subprocesses, etc.).
>
> By default, long variable values in the response are truncated.

**Parameters:**

| Parameter         | Type                             | Description                    |
| ----------------- | -------------------------------- | ------------------------------ |
| `truncate_values` | `bool` \| `Unset`                |                                |
| `data`            | `VariableSearchQuery` \| `Unset` | Variable search query request. |
| `consistency`     | `ConsistencyOptions` \| `None`   |                                |
| `kwargs`          | `Any`                            |                                |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableSearchQueryResult
- **Return type:**
  VariableSearchQueryResult

#### Examples

**Search variables:**

```python
def search_variables_example() -> None:
    client = CamundaClient()

    result = client.search_variables()

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_variables_as_dto()

```python
async def search_variables_as_dto(dto, *, process_instance_key, scope_key=None, tenant_id=None, page_size=100, consistency=None)
```

Fetch the variables declared by a Pydantic model for a process instance.

Async variant of [`CamundaClient.search_variables_as_dto()`](client.md#camunda_orchestration_sdk.CamundaClient.search_variables_as_dto).

**Parameters:**

| Parameter              | Type                           | Description |
| ---------------------- | ------------------------------ | ----------- |
| `dto`                  | type [ \_VarDtoT ]             |             |
| `process_instance_key` | `str`                          |             |
| `scope_key`            | `str` \| `None`                |             |
| `tenant_id`            | `str` \| `None`                |             |
| `page_size`            | `int`                          |             |
| `consistency`          | `ConsistencyOptions` \| `None` |             |

- **Return type:**
  _VariableMap_[ _\_VarDtoT_]

### suspend_batch_operation()

```python
async def suspend_batch_operation(batch_operation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Suspend Batch operation

> Suspends a running batch operation.
>
> This is done asynchronously, the progress can be tracked using the batch operation status endpoint
> (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter             | Type             | Description                                                             |
| --------------------- | ---------------- | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`            | System-generated key for an batch operation. Example: 2251799813684321. |
| `data`                | `Any` \| `Unset` |                                                                         |
| `kwargs`              | `Any`            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The batch operation was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Suspend a batch operation:**

```python
def suspend_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    client.suspend_batch_operation(
        batch_operation_key=batch_operation_key,
    )
```

### suspend_process_instance()

```python
async def suspend_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Suspend process instance

> Suspends a running process instance, pausing further processing until it is resumed.
>
> Only process instances in the ACTIVE state can be suspended.

**Parameters:**

| Parameter              | Type                                                 | Description                                                             |
| ---------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                                | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `None` \| `SuspendProcessInstanceRequest` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                                |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance is not in the ACTIVE state and cannot be suspended. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Suspend a process instance:**

```python
def suspend_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.suspend_process_instance(
        process_instance_key=process_instance_key,
    )
```

### suspend_process_instances_batch_operation()

```python
async def suspend_process_instances_batch_operation(*, data, **kwargs)
```

Suspend process instances (batch)

> Suspends multiple running process instances.
>
> Since only ACTIVE root instances can be suspended, any given filters for state and
> parentProcessInstanceKey are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                             | Description                                                                           |
| --------- | ------------------------------------------------ | ------------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceSuspensionBatchOperationRequest` | The process instance filter that defines which process instances should be suspended. |
| `kwargs`  | `Any`                                            |                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Suspend process instances in batch:**

```python
def suspend_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.suspend_process_instances_batch_operation(
        data=ProcessInstanceSuspensionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### throw_job_error()

```python
async def throw_job_error(job_key, *, data, **kwargs)
```

Throw error for job

> Reports a business error (i.e. non-technical) that occurs while processing a job.

**Parameters:**

| Parameter | Type              | Description                                                |
| --------- | ----------------- | ---------------------------------------------------------- |
| `job_key` | `str`             | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobErrorRequest` |                                                            |
| `kwargs`  | `Any`             |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the given key was not found or is not activated.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Throw a job error:**

```python
def throw_job_error_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.throw_job_error(
        job_key=job_key,
        data=JobErrorRequest(
            error_code="VALIDATION_ERROR",
            error_message="Input validation failed",
        ),
    )
```

### unassign_client_from_group()

```python
async def unassign_client_from_group(group_id, client_id, **kwargs)
```

Unassign a client from a group

> Unassigns a client from a group.
>
> The client is removed as a group member, with associated authorizations, roles, and tenant
> assignments no longer applied.

**Parameters:**

| Parameter   | Type   | Description                                             |
| ----------- | ------ | ------------------------------------------------------- |
| `group_id`  | `str`  | The unique identifier of a group. Example: engineering. |
| `client_id` | str) – |                                                         |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found, or the client is not assigned to this group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a client from a group:**

```python
def unassign_client_from_group_example(group_id: GroupId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.unassign_client_from_group(
        group_id=group_id,
        client_id=client_id,
    )
```

### unassign_client_from_tenant()

```python
async def unassign_client_from_tenant(tenant_id, client_id, **kwargs)
```

Unassign a client from a tenant

> Unassigns the client from the specified tenant.
>
> The client can no longer access tenant data.

**Parameters:**

| Parameter   | Type   | Description                                                     |
| ----------- | ------ | --------------------------------------------------------------- |
| `tenant_id` | `str`  | The unique identifier of the tenant. Example: customer-service. |
| `client_id` | str) – |                                                                 |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The tenant does not exist or the client was not assigned to it.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a client from a tenant:**

```python
def unassign_client_from_tenant_example(tenant_id: TenantId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.unassign_client_from_tenant(
        tenant_id=tenant_id,
        client_id=client_id,
    )
```

### unassign_group_from_tenant()

```python
async def unassign_group_from_tenant(tenant_id, group_id, **kwargs)
```

Unassign a group from a tenant

> Unassigns a group from a specified tenant.
>
> Members of the group (users, clients) will no longer have access to the tenant’s data - except they
> are assigned directly to the tenant.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `group_id`  | `str` | The unique identifier of a group. Example: engineering.         |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or group was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a group from a tenant:**

```python
def unassign_group_from_tenant_example(tenant_id: TenantId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.unassign_group_from_tenant(
        tenant_id=tenant_id,
        group_id=group_id,
    )
```

### unassign_mapping_rule_from_group()

```python
async def unassign_mapping_rule_from_group(group_id, mapping_rule_id, **kwargs)
```

Unassign a mapping rule from a group

> Unassigns a mapping rule from a group.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `group_id`        | `str` | The unique identifier of a group. Example: engineering.            |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or mapping rule with the given ID was not found, or the mapping rule is not assigned to this group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a mapping rule from a group:**

```python
def unassign_mapping_rule_from_group_example(group_id: GroupId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.unassign_mapping_rule_from_group(
        group_id=group_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### unassign_mapping_rule_from_tenant()

```python
async def unassign_mapping_rule_from_tenant(tenant_id, mapping_rule_id, **kwargs)
```

Unassign a mapping rule from a tenant

> Unassigns a single mapping rule from a specified tenant without deleting the rule.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `tenant_id`       | `str` | The unique identifier of the tenant. Example: customer-service.    |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or mapping rule was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a mapping rule from a tenant:**

```python
def unassign_mapping_rule_from_tenant_example(tenant_id: TenantId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.unassign_mapping_rule_from_tenant(
        tenant_id=tenant_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### unassign_role_from_client()

```python
async def unassign_role_from_client(role_id, client_id, **kwargs)
```

Unassign a role from a client

> Unassigns the specified role from the client. The client will no longer inherit the authorizations
> associated with this role.

**Parameters:**

| Parameter   | Type   | Description                                      |
| ----------- | ------ | ------------------------------------------------ |
| `role_id`   | `str`  | The unique identifier of a role. Example: admin. |
| `client_id` | str) – |                                                  |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or client with the given ID or username was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a client:**

```python
def unassign_role_from_client_example(role_id: RoleId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.unassign_role_from_client(
        role_id=role_id,
        client_id=client_id,
    )
```

### unassign_role_from_group()

```python
async def unassign_role_from_group(role_id, group_id, **kwargs)
```

Unassign a role from a group

> Unassigns the specified role from the group. All group members (user or client) no longer inherit
> the authorizations associated with this role.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `role_id`  | `str` | The unique identifier of a role. Example: admin.        |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a group:**

```python
def unassign_role_from_group_example(role_id: RoleId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.unassign_role_from_group(
        role_id=role_id,
        group_id=group_id,
    )
```

### unassign_role_from_mapping_rule()

```python
async def unassign_role_from_mapping_rule(role_id, mapping_rule_id, **kwargs)
```

Unassign a role from a mapping rule

> Unassigns a role from a mapping rule.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `role_id`         | `str` | The unique identifier of a role. Example: admin.                   |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or mapping rule with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a mapping rule:**

```python
def unassign_role_from_mapping_rule_example(role_id: RoleId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.unassign_role_from_mapping_rule(
        role_id=role_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### unassign_role_from_tenant()

```python
async def unassign_role_from_tenant(tenant_id, role_id, **kwargs)
```

Unassign a role from a tenant

> Unassigns a role from a specified tenant.
>
> Users, Clients or Groups, that have the role assigned, will no longer have access to the
> tenant’s data - unless they are assigned directly to the tenant.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `role_id`   | `str` | The unique identifier of a role. Example: admin.                |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or role was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a tenant:**

```python
def unassign_role_from_tenant_example(tenant_id: TenantId, role_id: RoleId) -> None:
    client = CamundaClient()

    client.unassign_role_from_tenant(
        tenant_id=tenant_id,
        role_id=role_id,
    )
```

### unassign_role_from_user()

```python
async def unassign_role_from_user(role_id, username, **kwargs)
```

Unassign a role from a user

> Unassigns a role from a user. The user will no longer inherit the authorizations associated with
> this role.

**Parameters:**

| Parameter  | Type  | Description                                      |
| ---------- | ----- | ------------------------------------------------ |
| `role_id`  | `str` | The unique identifier of a role. Example: admin. |
| `username` | `str` | The unique name of a user. Example: swillis.     |
| `kwargs`   | `Any` |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or user with the given ID or username was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a user:**

```python
def unassign_role_from_user_example(role_id: RoleId, username: Username) -> None:
    client = CamundaClient()

    client.unassign_role_from_user(
        role_id=role_id,
        username=username,
    )
```

### unassign_user_from_group()

```python
async def unassign_user_from_group(group_id, username, **kwargs)
```

Unassign a user from a group

> Unassigns a user from a group.
>
> The user is removed as a group member, with associated authorizations, roles, and tenant assignments
> no longer applied.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `username` | `str` | The unique name of a user. Example: swillis.            |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or user with the given ID was not found, or the user is not assigned to this group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a user from a group:**

```python
def unassign_user_from_group_example(group_id: GroupId, username: Username) -> None:
    client = CamundaClient()

    client.unassign_user_from_group(
        group_id=group_id,
        username=username,
    )
```

### unassign_user_from_tenant()

```python
async def unassign_user_from_tenant(tenant_id, username, **kwargs)
```

Unassign a user from a tenant

> Unassigns the user from the specified tenant.
>
> The user can no longer access tenant data.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `username`  | `str` | The unique name of a user. Example: swillis.                    |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or user was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a user from a tenant:**

```python
def unassign_user_from_tenant_example(tenant_id: TenantId, username: Username) -> None:
    client = CamundaClient()

    client.unassign_user_from_tenant(
        tenant_id=tenant_id,
        username=username,
    )
```

### unassign_user_task()

```python
async def unassign_user_task(user_task_key, **kwargs)
```

Unassign user task

> Removes the assignee of a task with the given key. Unassignment waits for blocking task listeners on
> this lifecycle transition. If listener processing is delayed beyond the request timeout, this
> endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and
> inspect listener worker availability and logs when this repeats.

**Parameters:**

| Parameter       | Type  | Description                           |
| --------------- | ----- | ------------------------------------- |
| `user_task_key` | `str` | System-generated key for a user task. |
| `kwargs`        | `Any` |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a user task:**

```python
def unassign_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    client.unassign_user_task(user_task_key=user_task_key)
```

### update_agent_instance()

```python
async def update_agent_instance(agent_instance_key, *, data, **kwargs)
```

Update agent instance

> Updates the mutable fields of an agent instance: status, metric counters, and
> tools. Metric values are treated as deltas and applied immediately to the
> aggregate counters. Tool updates replace the existing tool list.

**Parameters:**

| Parameter            | Type                         | Description                                                            |
| -------------------- | ---------------------------- | ---------------------------------------------------------------------- |
| `agent_instance_key` | `str`                        | System-generated key for an agent instance. Example: 4503599627370496. |
| `data`               | `AgentInstanceUpdateRequest` | Request to update the mutable state of an agent instance.              |
| `kwargs`             | `Any`                        |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update an agent instance:**

```python
def update_agent_instance_example(
    agent_instance_key: AgentInstanceKey,
    element_instance_key: ElementInstanceKey,
) -> None:
    client = CamundaClient()

    client.update_agent_instance(
        agent_instance_key=agent_instance_key,
        data=AgentInstanceUpdateRequest(
            element_instance_key=element_instance_key,
            status=AgentInstanceUpdateRequestStatus.THINKING,
        ),
    )
```

### update_authorization()

```python
async def update_authorization(authorization_key, *, data, **kwargs)
```

Update authorization

> Update the authorization with the given key.

**Parameters:**

| Parameter           | Type                                                                 | Description                                                           |
| ------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `authorization_key` | `str`                                                                | System-generated key for an authorization. Example: 2251799813684332. |
| `data`              | `AuthorizationIdBasedRequest` \| `AuthorizationPropertyBasedRequest` |                                                                       |
| `kwargs`            | `Any`                                                                |                                                                       |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The authorization with the authorizationKey was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update an authorization:**

```python
def update_authorization_example(authorization_key: AuthorizationKey) -> None:
    client = CamundaClient()

    client.update_authorization(
        authorization_key=authorization_key,
        data=AuthorizationIdBasedRequest(
            resource_type=AuthorizationIdBasedRequestResourceType.PROCESS_DEFINITION,
            permission_types=[
                AuthorizationIdBasedRequestPermissionTypesItem.READ,
                AuthorizationIdBasedRequestPermissionTypesItem.UPDATE,
                AuthorizationIdBasedRequestPermissionTypesItem.DELETE,
            ],
            resource_id="my-process",
            owner_type=OwnerTypeEnum.USER,
            owner_id="user@example.com",
        ),
    )
```

### update_global_cluster_variable()

```python
async def update_global_cluster_variable(name, *, data, **kwargs)
```

Update a global-scoped cluster variable

> Updates the value of an existing global cluster variable.
>
> The variable must exist, otherwise a 404 error is returned.

**Parameters:**

| Parameter | Type                           | Description                                                                                                           |
| --------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `name`    | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `data`    | `UpdateClusterVariableRequest` |                                                                                                                       |
| `kwargs`  | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Update a global cluster variable:**

```python
def update_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.update_global_cluster_variable(
        name=name,
        data=UpdateClusterVariableRequest(
            value=UpdateClusterVariableRequestValue.from_dict({"key": "updated-value"}),
        ),
    )

    print(f"Updated variable: {result.name}")
```

### update_global_task_listener()

```python
async def update_global_task_listener(id, *, data, **kwargs)
```

Update global user task listener

> Updates a global user task listener.

**Parameters:**

| Parameter | Type                              | Description                                                            |
| --------- | --------------------------------- | ---------------------------------------------------------------------- |
| `id`      | `str`                             | The user-defined id for the global listener Example: GlobalListener_1. |
| `data`    | `UpdateGlobalTaskListenerRequest` |                                                                        |
| `kwargs`  | `Any`                             |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The global user task listener was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerResult
- **Return type:**
  GlobalTaskListenerResult

#### Examples

**Update a global task listener:**

```python
def update_global_task_listener_example(listener_id: GlobalListenerId) -> None:
    client = CamundaClient()

    result = client.update_global_task_listener(
        id=listener_id,
        data=UpdateGlobalTaskListenerRequest(
            event_types=[GlobalTaskListenerEventTypeEnum.COMPLETING],
            type_="updated-task-listener",
        ),
    )

    print(f"Updated listener: {result.id}")
```

### update_group()

```python
async def update_group(group_id, *, data, **kwargs)
```

Update group

> Update a group with the given ID.

**Parameters:**

| Parameter  | Type                 | Description                                             |
| ---------- | -------------------- | ------------------------------------------------------- |
| `group_id` | `str`                | The unique identifier of a group. Example: engineering. |
| `data`     | `GroupUpdateRequest` |                                                         |
| `kwargs`   | `Any`                |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupUpdateResult
- **Return type:**
  GroupUpdateResult

#### Examples

**Update a group:**

```python
def update_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    client.update_group(
        group_id=group_id,
        data=GroupUpdateRequest(name="engineering-team"),
    )
```

### update_job()

```python
async def update_job(job_key, *, data, **kwargs)
```

Update job

> Update a job with the given key.

**Parameters:**

| Parameter | Type               | Description                                                |
| --------- | ------------------ | ---------------------------------------------------------- |
| `job_key` | `str`              | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobUpdateRequest` |                                                            |
| `kwargs`  | `Any`              |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the jobKey is not found.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update a job:**

```python
def update_job_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.update_job(
        job_key=job_key,
        data=JobUpdateRequest(
            changeset=JobChangeset(
                retries=3,
            ),
        ),
    )
```

### update_jobs_batch_operation()

```python
async def update_jobs_batch_operation(*, data, **kwargs)
```

Update jobs (batch)

> Creates a batch operation to update jobs matching the given filter. At least one changeset field
> must be non-null. This is done asynchronously; the progress can be tracked using the
> batchOperationKey from the response and the batch operation status endpoint (/batch-
> operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                    | Description                                                                                                                                                                                |
| --------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `data`    | `JobBatchUpdateRequest` | The filter and changeset for a batch job update operation. The filter defines which jobs are updated; the changeset defines what to update. At least one changeset field must be non-null. |
| `kwargs`  | `Any`                   |                                                                                                                                                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The job batch update operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Update jobs in batch:**

```python
def update_jobs_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.update_jobs_batch_operation(
        data=JobBatchUpdateRequest(
            filter_=JobBatchUpdateRequestFilter(
                type_="my-job-type",
            ),
            changeset=JobBatchUpdateRequestChangeset(
                retries=3,
            ),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### update_mapping_rule()

```python
async def update_mapping_rule(mapping_rule_id, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Update mapping rule

> Update a mapping rule.

**Parameters:**

| Parameter         | Type                                  | Description                                                        |
| ----------------- | ------------------------------------- | ------------------------------------------------------------------ |
| `mapping_rule_id` | `str`                                 | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `data`            | `MappingRuleUpdateRequest` \| `Unset` |                                                                    |
| `kwargs`          | `Any`                                 |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. The request to update a mapping rule was denied. More details are provided in the response body.
  - **errors.NotFoundError** – If the response status code is 404. The request to update a mapping rule was denied.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleUpdateResult
- **Return type:**
  MappingRuleUpdateResult

#### Examples

**Update a mapping rule:**

```python
def update_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.update_mapping_rule(
        mapping_rule_id=mapping_rule_id,
        data=MappingRuleUpdateRequest(
            claim_name="groups",
            claim_value="senior-engineering",
            name="Senior Engineering Mapping",
        ),
    )
```

### update_role()

```python
async def update_role(role_id, *, data, **kwargs)
```

Update role

> Update a role with the given ID.

**Parameters:**

| Parameter | Type                | Description                                      |
| --------- | ------------------- | ------------------------------------------------ |
| `role_id` | `str`               | The unique identifier of a role. Example: admin. |
| `data`    | `RoleUpdateRequest` |                                                  |
| `kwargs`  | `Any`               |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The role with the ID is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleUpdateResult
- **Return type:**
  RoleUpdateResult

#### Examples

**Update a role:**

```python
def update_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    client.update_role(
        role_id=role_id,
        data=RoleUpdateRequest(name="senior-developer"),
    )
```

### update_tenant()

```python
async def update_tenant(tenant_id, *, data, **kwargs)
```

Update tenant

> Updates an existing tenant.

**Parameters:**

| Parameter   | Type                  | Description                                                     |
| ----------- | --------------------- | --------------------------------------------------------------- |
| `tenant_id` | `str`                 | The unique identifier of the tenant. Example: customer-service. |
| `data`      | `TenantUpdateRequest` |                                                                 |
| `kwargs`    | `Any`                 |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantUpdateResult
- **Return type:**
  TenantUpdateResult

#### Examples

**Update a tenant:**

```python
def update_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    client.update_tenant(
        tenant_id=tenant_id,
        data=TenantUpdateRequest(name="Acme Corp International"),
    )
```

### update_tenant_cluster_variable()

```python
async def update_tenant_cluster_variable(tenant_id, name, *, data, **kwargs)
```

Update a tenant-scoped cluster variable

> Updates the value of an existing tenant-scoped cluster variable.
>
> The variable must exist, otherwise a 404 error is returned.

**Parameters:**

| Parameter   | Type                           | Description                                                                                                           |
| ----------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `tenant_id` | `str`                          | The unique identifier of the tenant. Example: customer-service.                                                       |
| `name`      | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `data`      | `UpdateClusterVariableRequest` |                                                                                                                       |
| `kwargs`    | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Update a tenant cluster variable:**

```python
def update_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.update_tenant_cluster_variable(
        tenant_id=tenant_id,
        name=name,
        data=UpdateClusterVariableRequest(
            value=UpdateClusterVariableRequestValue.from_dict({"key": "updated-tenant-value"}),
        ),
    )

    print(f"Updated variable: {result.name}")
```

### update_user()

```python
async def update_user(username, *, data, **kwargs)
```

Update user

> Updates a user.

**Parameters:**

| Parameter  | Type                | Description                                  |
| ---------- | ------------------- | -------------------------------------------- |
| `username` | `str`               | The unique name of a user. Example: swillis. |
| `data`     | `UserUpdateRequest` |                                              |
| `kwargs`   | `Any`               |                                              |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The user was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserUpdateResult
- **Return type:**
  UserUpdateResult

#### Examples

**Update a user:**

```python
def update_user_example(username: Username) -> None:
    client = CamundaClient()

    client.update_user(
        username=username,
        data=UserUpdateRequest(
            name="Jane Smith",
            email="jsmith@example.com",
        ),
    )
```

### update_user_task()

```python
async def update_user_task(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Update user task

> Update a user task with the given key. Updates wait for blocking task listeners on this lifecycle
> transition. If listener processing is delayed beyond the request timeout, this endpoint can return

504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker
     availability and logs when this repeats.

**Parameters:**

| Parameter       | Type                               | Description                           |
| --------------- | ---------------------------------- | ------------------------------------- |
| `user_task_key` | `str`                              | System-generated key for a user task. |
| `data`          | `UserTaskUpdateRequest` \| `Unset` |                                       |
| `kwargs`        | `Any`                              |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update a user task:**

```python
def update_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    client.update_user_task(
        user_task_key=user_task_key,
        data=UserTaskUpdateRequest(
            changeset=Changeset(
                due_date=datetime.datetime(2025, 12, 31, 23, 59, 59),
            ),
        ),
    )
```

---

## CamundaClient(Api-reference)


## CamundaClient

```python
class CamundaClient(configuration=None, auth_provider=None, logger=None, **kwargs)
```

Bases: `object`

**Parameters:**

| Parameter       | Type                                                                                                                   | Description |
| --------------- | ---------------------------------------------------------------------------------------------------------------------- | ----------- |
| `configuration` | [CamundaSdkConfiguration](runtime.md#camunda_orchestration_sdk.runtime.configuration_resolver.CamundaSdkConfiguration) |             |
| `auth_provider` | [AuthProvider](runtime.md#camunda_orchestration_sdk.runtime.auth.AuthProvider)                                         |             |
| `logger`        | [CamundaLogger](runtime.md#camunda_orchestration_sdk.runtime.logging.CamundaLogger) \| `None`                          |             |
| `kwargs`        | `Any`                                                                                                                  |             |

### activate_ad_hoc_sub_process_activities()

```python
def activate_ad_hoc_sub_process_activities(ad_hoc_sub_process_instance_key, *, data, **kwargs)
```

Activate activities within an ad-hoc sub-process

> Activates selected activities within an ad-hoc sub-process identified by element ID.
>
> The provided element IDs must exist within the ad-hoc sub-process instance identified by the
> provided adHocSubProcessInstanceKey.

**Parameters:**

| Parameter                         | Type                                           | Description                                                             |
| --------------------------------- | ---------------------------------------------- | ----------------------------------------------------------------------- |
| `ad_hoc_sub_process_instance_key` | `str`                                          | System-generated key for a element instance. Example: 2251799813686789. |
| `data`                            | `AdHocSubProcessActivateActivitiesInstruction` |                                                                         |
| `kwargs`                          | `Any`                                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The ad-hoc sub-process instance is not found or the provided key does not identify an ad-hoc sub-process.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Activate ad-hoc sub-process activities:**

```python
def activate_ad_hoc_sub_process_activities_example(element_id: ElementId) -> None:
    client = CamundaClient()

    client.activate_ad_hoc_sub_process_activities(
        ad_hoc_sub_process_instance_key="123456",
        data=AdHocSubProcessActivateActivitiesInstruction(
            elements=[
                AdHocSubProcessActivateActivityReference(element_id=element_id),
                AdHocSubProcessActivateActivityReference(element_id=element_id),
            ],
        ),
    )
```

### activate_jobs()

```python
def activate_jobs(*, data, **kwargs)
```

Activate jobs

> Iterate through all known partitions and activate jobs up to the requested maximum.

**Parameters:**

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `data`    | `JobActivationRequest` |             |
| `kwargs`  | `Any`                  |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobActivationResult
- **Return type:**
  JobActivationResult

#### Examples

**Activate and process jobs:**

```python
async def activate_jobs_example() -> None:
    async with CamundaAsyncClient() as client:
        result = await client.activate_jobs(
            data=JobActivationRequest(
                type_="payment-processing",
                timeout=30000,
                max_jobs_to_activate=5,
            )
        )

        for job in result.jobs:
            print(f"Job {job.job_key}: {job.type_}")
```

### assign_client_to_group()

```python
def assign_client_to_group(group_id, client_id, **kwargs)
```

Assign a client to a group

> Assigns a client to a group, making it a member of the group.
>
> Members of the group inherit the group authorizations, roles, and tenant assignments.

**Parameters:**

| Parameter   | Type   | Description                                             |
| ----------- | ------ | ------------------------------------------------------- |
| `group_id`  | `str`  | The unique identifier of a group. Example: engineering. |
| `client_id` | str) – |                                                         |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The client with the given ID is already assigned to the group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a client to a group:**

```python
def assign_client_to_group_example(group_id: GroupId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.assign_client_to_group(
        group_id=group_id,
        client_id=client_id,
    )
```

### assign_client_to_tenant()

```python
def assign_client_to_tenant(tenant_id, client_id, **kwargs)
```

Assign a client to a tenant

> Assign the client to the specified tenant.
>
> The client can then access tenant data and perform authorized actions.

**Parameters:**

| Parameter   | Type   | Description                                                     |
| ----------- | ------ | --------------------------------------------------------------- |
| `tenant_id` | `str`  | The unique identifier of the tenant. Example: customer-service. |
| `client_id` | str) – |                                                                 |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The tenant was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a client to a tenant:**

```python
def assign_client_to_tenant_example(tenant_id: TenantId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.assign_client_to_tenant(
        tenant_id=tenant_id,
        client_id=client_id,
    )
```

### assign_group_to_tenant()

```python
def assign_group_to_tenant(tenant_id, group_id, **kwargs)
```

Assign a group to a tenant

> Assigns a group to a specified tenant.
>
> Group members (users, clients) can then access tenant data and perform authorized actions.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `group_id`  | `str` | The unique identifier of a group. Example: engineering.         |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or group was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a group to a tenant:**

```python
def assign_group_to_tenant_example(tenant_id: TenantId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.assign_group_to_tenant(
        tenant_id=tenant_id,
        group_id=group_id,
    )
```

### assign_mapping_rule_to_group()

```python
def assign_mapping_rule_to_group(group_id, mapping_rule_id, **kwargs)
```

Assign a mapping rule to a group

> Assigns a mapping rule to a group.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `group_id`        | `str` | The unique identifier of a group. Example: engineering.            |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or mapping rule with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The mapping rule with the given ID is already assigned to the group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a mapping rule to a group:**

```python
def assign_mapping_rule_to_group_example(group_id: GroupId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.assign_mapping_rule_to_group(
        group_id=group_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### assign_mapping_rule_to_tenant()

```python
def assign_mapping_rule_to_tenant(tenant_id, mapping_rule_id, **kwargs)
```

Assign a mapping rule to a tenant

> Assign a single mapping rule to a specified tenant.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `tenant_id`       | `str` | The unique identifier of the tenant. Example: customer-service.    |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or mapping rule was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a mapping rule to a tenant:**

```python
def assign_mapping_rule_to_tenant_example(tenant_id: TenantId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.assign_mapping_rule_to_tenant(
        tenant_id=tenant_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### assign_process_instance_business_id()

```python
def assign_process_instance_business_id(process_instance_key, *, data, **kwargs)
```

Assign business id to process instance

> Assigns a business id to an already-running process instance that currently has none.
>
> The assignment is single and irreversible: only artifacts created after the assignment
> (for example future jobs, user tasks, decision instances, and message subscriptions) carry
> the business id, while existing artifacts are not retroactively enriched. Re-sending the
> same business id succeeds as a no-op. This endpoint is only useful while business id
> uniqueness enforcement is disabled; when it is enabled, the request is rejected with a 409
> response.

**Parameters:**

| Parameter              | Type                                             | Description                                                                         |
| ---------------------- | ------------------------------------------------ | ----------------------------------------------------------------------------------- |
| `process_instance_key` | `str`                                            | System-generated key for a process instance. Example: 2251799813690746.             |
| `data`                 | `ProcessInstanceBusinessIdAssignmentInstruction` | The instruction describing the business id to assign to a running process instance. |
| `kwargs`               | `Any`                                            |                                                                                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The business id assignment failed because the process instance is not eligible, for example it already has a different business id, it is a call-activity child, or business id uniqueness enforcement is enabled. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a business id to a process instance:**

```python
def assign_process_instance_business_id_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.assign_process_instance_business_id(
        process_instance_key=process_instance_key,
        data=ProcessInstanceBusinessIdAssignmentInstruction(
            business_id="order-12345",
        ),
    )
```

### assign_role_to_client()

```python
def assign_role_to_client(role_id, client_id, **kwargs)
```

Assign a role to a client

> Assigns the specified role to the client. The client will inherit the authorizations associated with
> this role.

**Parameters:**

| Parameter   | Type   | Description                                      |
| ----------- | ------ | ------------------------------------------------ |
| `role_id`   | `str`  | The unique identifier of a role. Example: admin. |
| `client_id` | str) – |                                                  |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The role was already assigned to the client with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a client:**

```python
def assign_role_to_client_example(role_id: RoleId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.assign_role_to_client(
        role_id=role_id,
        client_id=client_id,
    )
```

### assign_role_to_group()

```python
def assign_role_to_group(role_id, group_id, **kwargs)
```

Assign a role to a group

> Assigns the specified role to the group. Every member of the group (user or client) will inherit the
> authorizations associated with this role.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `role_id`  | `str` | The unique identifier of a role. Example: admin.        |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or group with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The role is already assigned to the group with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a group:**

```python
def assign_role_to_group_example(role_id: RoleId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.assign_role_to_group(
        role_id=role_id,
        group_id=group_id,
    )
```

### assign_role_to_mapping_rule()

```python
def assign_role_to_mapping_rule(role_id, mapping_rule_id, **kwargs)
```

Assign a role to a mapping rule

> Assigns a role to a mapping rule.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `role_id`         | `str` | The unique identifier of a role. Example: admin.                   |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or mapping rule with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. The role is already assigned to the mapping rule with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a mapping rule:**

```python
def assign_role_to_mapping_rule_example(role_id: RoleId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.assign_role_to_mapping_rule(
        role_id=role_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### assign_role_to_tenant()

```python
def assign_role_to_tenant(tenant_id, role_id, **kwargs)
```

Assign a role to a tenant

> Assigns a role to a specified tenant.
>
> Users, Clients or Groups, that have the role assigned, will get access to the tenant’s data and can
> perform actions according to their authorizations.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `role_id`   | `str` | The unique identifier of a role. Example: admin.                |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or role was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a tenant:**

```python
def assign_role_to_tenant_example(tenant_id: TenantId, role_id: RoleId) -> None:
    client = CamundaClient()

    client.assign_role_to_tenant(
        tenant_id=tenant_id,
        role_id=role_id,
    )
```

### assign_role_to_user()

```python
def assign_role_to_user(role_id, username, **kwargs)
```

Assign a role to a user

> Assigns the specified role to the user. The user will inherit the authorizations associated with
> this role.

**Parameters:**

| Parameter  | Type  | Description                                      |
| ---------- | ----- | ------------------------------------------------ |
| `role_id`  | `str` | The unique identifier of a role. Example: admin. |
| `username` | `str` | The unique name of a user. Example: swillis.     |
| `kwargs`   | `Any` |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or user with the given ID or username was not found.
  - **errors.ConflictError** – If the response status code is 409. The role is already assigned to the user with the given ID.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a role to a user:**

```python
def assign_role_to_user_example(role_id: RoleId, username: Username) -> None:
    client = CamundaClient()

    client.assign_role_to_user(
        role_id=role_id,
        username=username,
    )
```

### assign_user_task()

```python
def assign_user_task(user_task_key, *, data, **kwargs)
```

Assign user task

> Assigns a user task with the given key to the given assignee. Assignment waits for blocking task
> listeners on this lifecycle transition. If listener processing is delayed beyond the request
> timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with
> backoff and inspect listener worker availability and logs when this repeats.

**Parameters:**

| Parameter       | Type                        | Description                           |
| --------------- | --------------------------- | ------------------------------------- |
| `user_task_key` | `str`                       | System-generated key for a user task. |
| `data`          | `UserTaskAssignmentRequest` |                                       |
| `kwargs`        | `Any`                       |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a user task:**

```python
def assign_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    client.assign_user_task(
        user_task_key=user_task_key,
        data=UserTaskAssignmentRequest(
            assignee="user@example.com",
        ),
    )
```

### assign_user_to_group()

```python
def assign_user_to_group(group_id, username, **kwargs)
```

Assign a user to a group

> Assigns a user to a group, making the user a member of the group.
>
> Group members inherit the group authorizations, roles, and tenant assignments.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `username` | `str` | The unique name of a user. Example: swillis.            |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or user with the given ID or username was not found.
  - **errors.ConflictError** – If the response status code is 409. The user with the given ID is already assigned to the group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a user to a group:**

```python
def assign_user_to_group_example(group_id: GroupId, username: Username) -> None:
    client = CamundaClient()

    client.assign_user_to_group(
        group_id=group_id,
        username=username,
    )
```

### assign_user_to_tenant()

```python
def assign_user_to_tenant(tenant_id, username, **kwargs)
```

Assign a user to a tenant

> Assign a single user to a specified tenant. The user can then access tenant data and perform
> authorized actions.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `username`  | `str` | The unique name of a user. Example: swillis.                    |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or user was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Assign a user to a tenant:**

```python
def assign_user_to_tenant_example(tenant_id: TenantId, username: Username) -> None:
    client = CamundaClient()

    client.assign_user_to_tenant(
        tenant_id=tenant_id,
        username=username,
    )
```

### auth_provider

```python
auth_provider: [AuthProvider](runtime.md#camunda_orchestration_sdk.runtime.auth.AuthProvider)
```

### broadcast_signal()

```python
def broadcast_signal(*, data, **kwargs)
```

Broadcast signal

> Broadcasts a signal.

**Parameters:**

| Parameter | Type                     | Description |
| --------- | ------------------------ | ----------- |
| `data`    | `SignalBroadcastRequest` |             |
| `kwargs`  | `Any`                    |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The signal is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  SignalBroadcastResult
- **Return type:**
  SignalBroadcastResult

#### Examples

**Broadcast a signal:**

```python
def broadcast_signal_example() -> None:
    client = CamundaClient()

    result = client.broadcast_signal(
        data=SignalBroadcastRequest(
            signal_name="order-cancelled",
        )
    )

    print(f"Signal key: {result.signal_key}")
```

### cancel_batch_operation()

```python
def cancel_batch_operation(batch_operation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Cancel Batch operation

> Cancels a running batch operation.
>
> This is done asynchronously, the progress can be tracked using the batch operation status endpoint
> (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter             | Type             | Description                                                             |
| --------------------- | ---------------- | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`            | System-generated key for an batch operation. Example: 2251799813684321. |
| `data`                | `Any` \| `Unset` |                                                                         |
| `kwargs`              | `Any`            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The batch operation was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Cancel a batch operation:**

```python
def cancel_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    client.cancel_batch_operation(
        batch_operation_key=batch_operation_key,
    )
```

### cancel_process_instance()

```python
def cancel_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Cancel process instance

> Cancels a running process instance. As a cancellation includes more than just the removal of the
> process instance resource, the cancellation resource must be posted. Cancellation can wait on
> listener-related processing; when that processing does not complete in time, this endpoint can
> return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener
> worker availability and logs when this repeats.

**Parameters:**

| Parameter              | Type                                                | Description                                                             |
| ---------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                               | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `CancelProcessInstanceRequest` \| `None` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                               |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Cancel a process instance:**

```python
def cancel_process_instance_example(process_definition_id: ProcessDefinitionId) -> None:
    client = CamundaClient()

    # Create a process instance and get its key from the response
    created = client.create_process_instance(
        data=ProcessCreationById(process_definition_id=process_definition_id)
    )

    # Cancel it using the key from the creation response
    client.cancel_process_instance(
        process_instance_key=created.process_instance_key,
    )
```

### cancel_process_instances_batch_operation()

```python
def cancel_process_instances_batch_operation(*, data, **kwargs)
```

Cancel process instances (batch)

> Cancels multiple running process instances.
>
> Since only ACTIVE root instances can be cancelled, any given filters for state and
> parentProcessInstanceKey are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                               | Description                                                                          |
| --------- | -------------------------------------------------- | ------------------------------------------------------------------------------------ |
| `data`    | `ProcessInstanceCancellationBatchOperationRequest` | The process instance filter that defines which process instances should be canceled. |
| `kwargs`  | `Any`                                              |                                                                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Cancel process instances in batch:**

```python
def cancel_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.cancel_process_instances_batch_operation(
        data=ProcessInstanceCancellationBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### change_cluster_mode()

```python
def change_cluster_mode(*, mode, dry_run=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Change cluster mode

> Transitions the cluster between processing and recovery mode. This is a non-blocking operation: the
> request is acknowledged once the change has been accepted, before the transition itself has
> completed. Entering recovery mode deactivates all partitions so that only a restricted set of read-
> only operations remains available; exiting recovery mode returns the cluster to normal processing.
> Returns the planned cluster change so its progress can be monitored via the topology.

**Parameters:**

| Parameter | Type                    | Description |
| --------- | ----------------------- | ----------- |
| `mode`    | `ChangeClusterModeMode` |             |
| `dry_run` | `bool` \| `Unset`       |             |
| `kwargs`  | `Any`                   |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterModeChangeResponse
- **Return type:**
  ClusterModeChangeResponse

#### Examples

**Change cluster mode:**

```python
def change_cluster_mode_example() -> None:
    client = CamundaClient()

    # Pass dry_run=True to validate the request and inspect the resulting plan
    # without applying it. Omit it (or set it to False) to trigger the transition.
    result = client.change_cluster_mode(
        mode=ChangeClusterModeMode.RECOVERING,
        dry_run=True,
    )

    print(f"Cluster change {result.change_id}:")
    for operation in result.planned_changes:
        suffix = f" -> {operation.mode}" if operation.mode else ""
        print(f"  {operation.operation}{suffix}")
```

### client

```python
client: [Client](configuration.md#camunda_orchestration_sdk.Client) | [AuthenticatedClient](configuration.md#camunda_orchestration_sdk.AuthenticatedClient)
```

### close()

```python
def close()
```

Close underlying HTTP clients.

This closes both the API client’s httpx client and, when available, the
auth provider’s token client.

- **Return type:**
  None

### complete_job()

```python
def complete_job(job_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Complete job

> Complete a job with the given payload, which allows completing the associated service task.

**Parameters:**

| Parameter | Type                              | Description                                                |
| --------- | --------------------------------- | ---------------------------------------------------------- |
| `job_key` | `str`                             | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobCompletionRequest` \| `Unset` |                                                            |
| `kwargs`  | `Any`                             |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Complete a job:**

```python
def complete_job_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.complete_job(
        job_key=job_key,
        data=JobCompletionRequest(
            variables=JobCompletionRequestVariables.from_dict(
                {"paymentId": "PAY-123", "status": "completed"}
            )
        ),
    )
```

### complete_user_task()

```python
def complete_user_task(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Complete user task

> Completes a user task with the given key. Completion waits for blocking task listeners on this
> lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint
> can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect
> listener worker availability and logs when this repeats.

**Parameters:**

| Parameter       | Type                                   | Description                           |
| --------------- | -------------------------------------- | ------------------------------------- |
| `user_task_key` | `str`                                  | System-generated key for a user task. |
| `data`          | `UserTaskCompletionRequest` \| `Unset` |                                       |
| `kwargs`        | `Any`                                  |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Complete a user task:**

```python
def complete_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    variables = UserTaskCompletionRequestVariables()
    variables["approved"] = True

    client.complete_user_task(
        user_task_key=user_task_key,
        data=UserTaskCompletionRequest(
            variables=variables,
        ),
    )
```

### configuration

```python
configuration: [CamundaSdkConfiguration](runtime.md#camunda_orchestration_sdk.runtime.configuration_resolver.CamundaSdkConfiguration)
```

### correlate_message()

```python
def correlate_message(*, data, **kwargs)
```

Correlate message

> Publishes a message and correlates it to a subscription.
>
> If correlation is successful it will return the first process instance key the message correlated
> with.
> The message is not buffered.
> Use the publish message endpoint to send messages that can be buffered.

**Parameters:**

| Parameter | Type                        | Description |
| --------- | --------------------------- | ----------- |
| `data`    | `MessageCorrelationRequest` |             |
| `kwargs`  | `Any`                       |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MessageCorrelationResult
- **Return type:**
  MessageCorrelationResult

#### Examples

**Correlate a message:**

```python
def correlate_message_example() -> None:
    client = CamundaClient()

    result = client.correlate_message(
        data=MessageCorrelationRequest(
            name="payment-received",
            correlation_key="order-12345",
        )
    )

    print(f"Message key: {result.message_key}")
```

### create_admin_user()

```python
def create_admin_user(*, data, **kwargs)
```

Create admin user

> Creates a new user and assigns the admin role to it. This endpoint is only usable when users are
> managed in the Orchestration Cluster and while no user is assigned to the admin role.

**Parameters:**

| Parameter | Type          | Description |
| --------- | ------------- | ----------- |
| `data`    | `UserRequest` |             |
| `kwargs`  | `Any`         |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A user with this username already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserCreateResult
- **Return type:**
  UserCreateResult

#### Examples

**Create an admin user:**

```python
def create_admin_user_example(username: Username) -> None:
    client = CamundaClient()

    result = client.create_admin_user(
        data=UserRequest(
            username=username,
            name="Admin User",
            email="admin@example.com",
            password="admin-password",
        ),
    )

    print(f"Admin user: {result.username}")
```

### create_agent_instance()

```python
def create_agent_instance(*, data, **kwargs)
```

Create agent instance

> Creates a new agent instance. The returned key identifies the instance and must
> be used in subsequent update and query calls.

**Parameters:**

| Parameter | Type                           | Description                             |
| --------- | ------------------------------ | --------------------------------------- |
| `data`    | `AgentInstanceCreationRequest` | Request to create a new agent instance. |
| `kwargs`  | `Any`                          |                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The elementInstanceKey does not correspond to an active element instance. More details are provided in the response body.
  - **errors.ConflictError** – If the response status code is 409. An agent instance already exists for the given element instance.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceCreationResult
- **Return type:**
  AgentInstanceCreationResult

#### Examples

**Create an agent instance:**

```python
def create_agent_instance_example(element_instance_key: ElementInstanceKey) -> None:
    client = CamundaClient()

    result = client.create_agent_instance(
        data=AgentInstanceCreationRequest(
            element_instance_key=element_instance_key,
            definition=AgentInstanceCreationRequestDefinition(
                model="gpt-4o",
                provider="openai",
                system_prompt="You are a helpful assistant.",
            ),
        ),
    )

    print(f"Created agent instance: {result.agent_instance_key}")
```

### create_agent_instance_history_item()

```python
def create_agent_instance_history_item(agent_instance_key, *, data, **kwargs)
```

Create agent instance history item

> Appends a single history item to an agent instance’s conversation history.
>
> The created item has commitStatus PENDING until the job identified by jobLease
> completes successfully, at which point it transitions to COMMITTED. If the job
> fails or is superseded by a retry, the item is marked DISCARDED.

**Parameters:**

| Parameter            | Type                              | Description                                                                          |
| -------------------- | --------------------------------- | ------------------------------------------------------------------------------------ |
| `agent_instance_key` | `str`                             | System-generated key for an agent instance. Example: 4503599627370496.               |
| `data`               | `AgentInstanceHistoryItemRequest` | Request to append a single history item to an agent instance’s conversation history. |
| `kwargs`             | `Any`                             |                                                                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found, or the specified jobKey does not correspond to an active job. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceHistoryItemCreationResult
- **Return type:**
  AgentInstanceHistoryItemCreationResult

#### Examples

**Append an agent instance history item:**

```python
def create_agent_instance_history_item_example(
    agent_instance_key: AgentInstanceKey,
    element_instance_key: ElementInstanceKey,
    job_key: JobKey,
) -> None:
    client = CamundaClient()

    result = client.create_agent_instance_history_item(
        agent_instance_key=agent_instance_key,
        data=AgentInstanceHistoryItemRequest(
            element_instance_key=element_instance_key,
            job_key=job_key,
            job_lease="lease-token",
            role=AgentInstanceHistoryItemRequestRole.ASSISTANT,
            content=[TextContent(content_type="TEXT", text="How can I help you today?")],
            produced_at=datetime.datetime.now(datetime.timezone.utc),
        ),
    )

    print(f"Created history item: {result.history_item_key}")
```

### create_authorization()

```python
def create_authorization(*, data, **kwargs)
```

Create authorization

> Create the authorization.

**Parameters:**

| Parameter | Type                                                                 | Description |
| --------- | -------------------------------------------------------------------- | ----------- |
| `data`    | `AuthorizationIdBasedRequest` \| `AuthorizationPropertyBasedRequest` |             |
| `kwargs`  | `Any`                                                                |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The owner was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuthorizationCreateResult
- **Return type:**
  AuthorizationCreateResult

#### Examples

**Create an authorization:**

```python
def create_authorization_example() -> None:
    client = CamundaClient()

    result = client.create_authorization(
        data=AuthorizationIdBasedRequest(
            resource_type=AuthorizationIdBasedRequestResourceType.PROCESS_DEFINITION,
            permission_types=[
                AuthorizationIdBasedRequestPermissionTypesItem.READ,
                AuthorizationIdBasedRequestPermissionTypesItem.UPDATE,
            ],
            resource_id="my-process",
            owner_type=OwnerTypeEnum.USER,
            owner_id="user@example.com",
        ),
    )

    print(f"Authorization key: {result.authorization_key}")
```

### create_deployment()

```python
def create_deployment(*, data, **kwargs)
```

Deploy resources

> Deploys one or more resources, including BPMN processes, DMN decision models, forms, RPA resources,
> and generic files.
> A deployment can contain any file type. Files that are not interpreted as BPMN, DMN, form, or RPA
> resources are stored as deployable generic resources in the engine.
> This is an atomic call, i.e. either all resources are deployed or none of them are.

**Parameters:**

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `data`    | `CreateDeploymentData` |             |
| `kwargs`  | `Any`                  |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DeploymentResult
- **Return type:**
  DeploymentResult

#### Examples

**From files:**

```python
def deploy_resources_example() -> None:
    client = CamundaClient()

    result = client.deploy_resources_from_files(
        ["order-process.bpmn", "decision.dmn"]
    )

    print(f"Deployment key: {result.deployment_key}")
    for process in result.processes:
        print(
            f"  Process: {process.process_definition_id} v{process.process_definition_version}"
        )
    for decision in result.decisions:
        print(f"  Decision: {decision.decision_definition_id}")
```

**With tenant ID:**

```python
def deploy_resources_with_tenant_example() -> None:
    client = CamundaClient()

    result = client.deploy_resources_from_files(
        ["order-process.bpmn"],
        tenant_id="my-tenant",
    )

    print(f"Deployment key: {result.deployment_key}")
    print(f"Tenant: {result.tenant_id}")
```

### create_document()

```python
def create_document(*, data, store_id=<camunda_orchestration_sdk.types.Unset object>, document_id=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Upload document

> Upload a document to the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter     | Type                 | Description                                      |
| ------------- | -------------------- | ------------------------------------------------ |
| `store_id`    | `str` \| `Unset`     |                                                  |
| `document_id` | `str` \| `Unset`     | Document Id that uniquely identifies a document. |
| `data`        | `CreateDocumentData` |                                                  |
| `kwargs`      | `Any`                |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnsupportedMediaTypeError** – If the response status code is 415. The server cannot process the request because the media type (Content-Type) of the request payload is not supported by the server for the requested resource and method.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DocumentReference
- **Return type:**
  DocumentReference

#### Examples

**Create a document:**

```python
def create_document_example() -> None:

    client = CamundaClient()

    result = client.create_document(
        data=CreateDocumentData(
            file=File(payload=io.BytesIO(b"hello world"), file_name="example.txt"),
        ),
    )

    print(f"Document ID: {result.document_id}")
```

### create_document_link()

```python
def create_document_link(document_id, *, data=<camunda_orchestration_sdk.types.Unset object>, store_id=<camunda_orchestration_sdk.types.Unset object>, content_hash=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create document link

> Create a link to a document in the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP

**Parameters:**

| Parameter      | Type                             | Description                                      |
| -------------- | -------------------------------- | ------------------------------------------------ |
| `document_id`  | `str`                            | Document Id that uniquely identifies a document. |
| `store_id`     | `str` \| `Unset`                 |                                                  |
| `content_hash` | `str` \| `Unset`                 |                                                  |
| `data`         | `DocumentLinkRequest` \| `Unset` |                                                  |
| `kwargs`       | `Any`                            |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DocumentLink
- **Return type:**
  DocumentLink

#### Examples

**Create a document link:**

```python
def create_document_link_example(document_id: DocumentId) -> None:
    client = CamundaClient()

    result = client.create_document_link(
        document_id=document_id,
        data=DocumentLinkRequest(),
    )

    print(f"Document link: {result.url}")
```

### create_documents()

```python
def create_documents(*, data, store_id=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Upload multiple documents

> Upload multiple documents to the Camunda 8 cluster.
>
> The caller must provide a file name for each document, which will be used in case of a multi-status
> response
> to identify which documents failed to upload. The file name can be provided in the Content-
> Disposition header
> of the file part or in the fileName field of the metadata. You can add a parallel array of
> metadata objects. These
> are matched with the files based on index, and must have the same length as the files array.
> To pass homogenous metadata for all files, spread the metadata over the metadata array.
> A filename value provided explicitly via the metadata array in the request overrides the Content-
> Disposition header
> of the file part.
>
> In case of a multi-status response, the response body will contain a list of
> DocumentBatchProblemDetail objects,
> each of which contains the file name of the document that failed to upload and the reason for the
> failure.
> The client can choose to retry the whole batch or individual documents based on the response.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter  | Type                  | Description |
| ---------- | --------------------- | ----------- |
| `store_id` | `str` \| `Unset`      |             |
| `data`     | `CreateDocumentsData` |             |
| `kwargs`   | `Any`                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnsupportedMediaTypeError** – If the response status code is 415. The server cannot process the request because the media type (Content-Type) of the request payload is not supported by the server for the requested resource and method.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DocumentCreationBatchResponse
- **Return type:**
  DocumentCreationBatchResponse

#### Examples

**Create documents:**

```python
def create_documents_example() -> None:

    client = CamundaClient()

    result = client.create_documents(
        data=CreateDocumentsData(
            files=[
                File(payload=io.BytesIO(b"file one"), file_name="one.txt"),
                File(payload=io.BytesIO(b"file two"), file_name="two.txt"),
            ],
        ),
    )

    if not isinstance(result.created_documents, Unset):
        for doc in result.created_documents:
            print(f"Created document: {doc.document_id}")
```

### create_element_instance_variables()

```python
def create_element_instance_variables(element_instance_key, *, data, **kwargs)
```

Update element instance variables

> Updates all the variables of a particular scope (for example, process instance, element instance)
> with the given variable data.
> Specify the element instance in the elementInstanceKey parameter.
> Variable updates can be delayed by listener-related processing; if processing exceeds the
> request timeout, this endpoint can return 504. Other gateway timeout causes are also
> possible. Retry with backoff and inspect listener worker availability and logs when this
> repeats.

**Parameters:**

| Parameter              | Type                 | Description                                                             |
| ---------------------- | -------------------- | ----------------------------------------------------------------------- |
| `element_instance_key` | `str`                | System-generated key for a element instance. Example: 2251799813686789. |
| `data`                 | `SetVariableRequest` |                                                                         |
| `kwargs`               | `Any`                |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Create element instance variables:**

```python
def create_element_instance_variables_example(
    element_instance_key: ElementInstanceKey,
) -> None:
    client = CamundaClient()

    variables = SetVariableRequestVariables.from_dict({"myVar": "myValue"})
    client.create_element_instance_variables(
        element_instance_key=element_instance_key,
        data=SetVariableRequest(
            variables=variables,
        ),
    )
```

### create_global_cluster_variable()

```python
def create_global_cluster_variable(*, data, **kwargs)
```

Create a global-scoped cluster variable

> Create a global-scoped cluster variable.

**Parameters:**

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `data`    | `CreateClusterVariableRequest` |             |
| `kwargs`  | `Any`                          |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A cluster variable with this name already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Create a global cluster variable:**

```python
def create_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.create_global_cluster_variable(
        data=CreateClusterVariableRequest(
            name=name,
            value=CreateClusterVariableRequestValue.from_dict({"key": "my-value"}),
        ),
    )

    print(f"Created variable: {result.name}")
```

### create_global_task_listener()

```python
def create_global_task_listener(*, data, **kwargs)
```

Create global user task listener

> Create a new global user task listener.

**Parameters:**

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `data`    | `CreateGlobalTaskListenerRequest` |             |
| `kwargs`  | `Any`                             |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A global listener with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerResult
- **Return type:**
  GlobalTaskListenerResult

#### Examples

**Create a global task listener:**

```python
def create_global_task_listener_example() -> None:
    client = CamundaClient()

    result = client.create_global_task_listener(
        data=CreateGlobalTaskListenerRequest(
            id="audit-log-listener",
            event_types=[GlobalTaskListenerEventTypeEnum.COMPLETING],
            type_="my-task-listener",
        ),
    )

    print(f"Task listener: {result.id}")
```

### create_group()

```python
def create_group(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create group

> Create a new group.
>
> The supplied groupId is validated against ^[a-zA-Z0-9_~@.+-]+$
> (max 256 characters) by IdentifierValidator.validateId in the
> runtime. This strict validation applies wherever the Groups API
> is available: in OIDC deployments that set
> camunda.security.authentication.oidc.groupsClaim the Groups
> API (including this endpoint) is disabled entirely, so group
> CRUD never sees externally-minted IdP IDs. The BYOG relaxation
> only loosens validation when a group is referenced _as a member_
> of a role or tenant (assignRoleToGroup,
> assignGroupToTenant); group CRUD itself always uses the strict
> default-id regex. The constraint is not advertised on the
> GroupId schema so that the same schema can be reused at
> member-reference sites without falsely rejecting
> externally-minted IdP group IDs there.

**Parameters:**

| Parameter | Type                            | Description |
| --------- | ------------------------------- | ----------- |
| `data`    | `GroupCreateRequest` \| `Unset` |             |
| `kwargs`  | `Any`                           |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. Group with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupCreateResult
- **Return type:**
  GroupCreateResult

#### Examples

**Create a group:**

```python
def create_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.create_group(
        data=GroupCreateRequest(group_id=group_id, name="Engineering"),
    )

    print(f"Group: {result.group_id}")
```

### create_mapping_rule()

```python
def create_mapping_rule(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create mapping rule

> Create a new mapping rule

**Parameters:**

| Parameter | Type                                  | Description |
| --------- | ------------------------------------- | ----------- |
| `data`    | `MappingRuleCreateRequest` \| `Unset` |             |
| `kwargs`  | `Any`                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. The request to create a mapping rule was denied. More details are provided in the response body.
  - **errors.NotFoundError** – If the response status code is 404. The request to create a mapping rule was denied.
  - **errors.ConflictError** – If the response status code is 409. Mapping rule with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleCreateResult
- **Return type:**
  MappingRuleCreateResult

#### Examples

**Create a mapping rule:**

```python
def create_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    result = client.create_mapping_rule(
        data=MappingRuleCreateRequest(
            mapping_rule_id=mapping_rule_id,
            claim_name="groups",
            claim_value="engineering",
            name="Engineering Group Mapping",
        ),
    )

    print(f"Mapping rule: {result.mapping_rule_id}")
```

### create_process_instance()

```python
def create_process_instance(*, data, **kwargs)
```

Create process instance

> Creates and starts an instance of the specified process.
>
> The process definition to use to create the instance can be specified either using its unique key
> (as returned by Deploy resources), or using the BPMN process id and a version.
>
> Waits for the completion of the process instance before returning a result
> when awaitCompletion is enabled.

**Parameters:**

| Parameter | Type                                            | Description                                                                                                   |
| --------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `data`    | `ProcessCreationById` \| `ProcessCreationByKey` | Instructions for creating a process instance. The process definition can be specified either by id or by key. |
| `kwargs`  | `Any`                                           |                                                                                                               |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ConflictError** – If the response status code is 409. The process instance creation was rejected due to a business ID uniqueness conflict. This can happen only when Business ID Uniqueness Control is enabled and an active root process instance with the provided business ID already exists for the same process definition and tenant.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The process instance creation request timed out in the gateway. This can happen if the awaitCompletion request parameter is set to true and the created process instance did not complete within the defined request timeout. This often happens when the created instance is not fully automated or contains wait states.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  CreateProcessInstanceResult
- **Return type:**
  CreateProcessInstanceResult

#### Examples

**By key:**

```python
def create_process_instance_by_key_example() -> None:
    client = CamundaClient()

    # Deploy a process and obtain the typed key from the response
    deployment = client.deploy_resources_from_files(["order-process.bpmn"])
    process_key = deployment.processes[0].process_definition_key

    # Use the typed key directly — no manual string lifting needed
    result = client.create_process_instance(
        data=ProcessCreationByKey(
            process_definition_key=process_key,
        )
    )

    print(f"Process instance key: {result.process_instance_key}")
```

**By stored key:**

```python
def create_process_instance_by_key_from_storage_example() -> None:
    client = CamundaClient()

    # When restoring a key from a database or message queue,
    # wrap the raw string with the semantic type constructor:
    stored_key = "2251799813685249"  # e.g. from a DB row
    result = client.create_process_instance(
        data=ProcessCreationByKey(
            process_definition_key=ProcessDefinitionKey(stored_key),
        )
    )

    print(f"Process instance key: {result.process_instance_key}")
```

**By ID:**

```python
def create_process_instance_by_id_example(process_definition_id: ProcessDefinitionId) -> None:
    client = CamundaClient()

    result = client.create_process_instance(
        data=ProcessCreationById(
            process_definition_id=process_definition_id,
        )
    )

    print(f"Process instance key: {result.process_instance_key}")
```

### create_role()

```python
def create_role(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Create role

> Create a new role.

**Parameters:**

| Parameter | Type                           | Description |
| --------- | ------------------------------ | ----------- |
| `data`    | `RoleCreateRequest` \| `Unset` |             |
| `kwargs`  | `Any`                          |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. Role with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleCreateResult
- **Return type:**
  RoleCreateResult

#### Examples

**Create a role:**

```python
def create_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.create_role(
        data=RoleCreateRequest(role_id=role_id, name="Developer"),
    )

    print(f"Role: {result.role_id}")
```

### create_tenant()

```python
def create_tenant(*, data, **kwargs)
```

Create tenant

> Creates a new tenant.

**Parameters:**

| Parameter | Type                  | Description |
| --------- | --------------------- | ----------- |
| `data`    | `TenantCreateRequest` |             |
| `kwargs`  | `Any`                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The resource was not found.
  - **errors.ConflictError** – If the response status code is 409. Tenant with this id already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantCreateResult
- **Return type:**
  TenantCreateResult

#### Examples

**Create a tenant:**

```python
def create_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.create_tenant(
        data=TenantCreateRequest(
            tenant_id=tenant_id,
            name="Acme Corporation",
        ),
    )

    print(f"Tenant: {result.tenant_id}")
```

### create_tenant_cluster_variable()

```python
def create_tenant_cluster_variable(tenant_id, *, data, **kwargs)
```

Create a tenant-scoped cluster variable

> Create a new cluster variable for the given tenant.

**Parameters:**

| Parameter   | Type                           | Description                                                     |
| ----------- | ------------------------------ | --------------------------------------------------------------- |
| `tenant_id` | `str`                          | The unique identifier of the tenant. Example: customer-service. |
| `data`      | `CreateClusterVariableRequest` |                                                                 |
| `kwargs`    | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The tenant with the given ID was not found.
  - **errors.ConflictError** – If the response status code is 409. A cluster variable with this name already exists for the given tenant.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Create a tenant cluster variable:**

```python
def create_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.create_tenant_cluster_variable(
        tenant_id=tenant_id,
        data=CreateClusterVariableRequest(
            name=name,
            value=CreateClusterVariableRequestValue.from_dict({"key": "tenant-value"}),
        ),
    )

    print(f"Created variable: {result.name}")
```

### create_user()

```python
def create_user(*, data, **kwargs)
```

Create user

> Create a new user.

**Parameters:**

| Parameter | Type          | Description |
| --------- | ------------- | ----------- |
| `data`    | `UserRequest` |             |
| `kwargs`  | `Any`         |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.ConflictError** – If the response status code is 409. A user with this username already exists.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserCreateResult
- **Return type:**
  UserCreateResult

#### Examples

**Create a user:**

```python
def create_user_example(username: Username) -> None:
    client = CamundaClient()

    result = client.create_user(
        data=UserRequest(
            username=username,
            name="Jane Doe",
            email="jdoe@example.com",
            password="secure-password",
        ),
    )

    print(f"Created user: {result.username}")
```

### delete_authorization()

```python
def delete_authorization(authorization_key, **kwargs)
```

Delete authorization

> Deletes the authorization with the given key.

**Parameters:**

| Parameter           | Type  | Description                                                           |
| ------------------- | ----- | --------------------------------------------------------------------- |
| `authorization_key` | `str` | System-generated key for an authorization. Example: 2251799813684332. |
| `kwargs`            | `Any` |                                                                       |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The authorization with the authorizationKey was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete an authorization:**

```python
def delete_authorization_example(authorization_key: AuthorizationKey) -> None:
    client = CamundaClient()

    client.delete_authorization(
        authorization_key=authorization_key,
    )
```

### delete_decision_instance()

```python
def delete_decision_instance(decision_evaluation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete decision instance

> Delete all associated decision evaluations based on provided key.

**Parameters:**

| Parameter                 | Type                                                 | Description                                                                |
| ------------------------- | ---------------------------------------------------- | -------------------------------------------------------------------------- |
| `decision_evaluation_key` | `str`                                                | System-generated key for a decision evaluation. Example: 2251792362345323. |
| `data`                    | `DeleteDecisionInstanceRequest` \| `None` \| `Unset` |                                                                            |
| `kwargs`                  | `Any`                                                |                                                                            |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a decision instance:**

```python
def delete_decision_instance_example(decision_evaluation_key: DecisionEvaluationKey) -> None:
    client = CamundaClient()

    client.delete_decision_instance(
        decision_evaluation_key=decision_evaluation_key,
    )
```

### delete_decision_instances_batch_operation()

```python
def delete_decision_instances_batch_operation(*, data, **kwargs)
```

Delete decision instances (batch)

> Delete multiple decision instances. This will delete the historic data from secondary storage.
>
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                            | Description                                                                           |
| --------- | ----------------------------------------------- | ------------------------------------------------------------------------------------- |
| `data`    | `DecisionInstanceDeletionBatchOperationRequest` | The decision instance filter that defines which decision instances should be deleted. |
| `kwargs`  | `Any`                                           |                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The decision instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Delete decision instances in batch:**

```python
def delete_decision_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.delete_decision_instances_batch_operation(
        data=DecisionInstanceDeletionBatchOperationRequest(
            filter_=DecisionInstanceDeletionBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### delete_document()

```python
def delete_document(document_id, *, store_id=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete document

> Delete a document from the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter     | Type             | Description                                      |
| ------------- | ---------------- | ------------------------------------------------ |
| `document_id` | `str`            | Document Id that uniquely identifies a document. |
| `store_id`    | `str` \| `Unset` |                                                  |
| `kwargs`      | `Any`            |                                                  |

- **Raises:**
  - **errors.NotFoundError** – If the response status code is 404. The document with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a document:**

```python
def delete_document_example(document_id: DocumentId) -> None:
    client = CamundaClient()

    client.delete_document(document_id=document_id)
```

### delete_global_cluster_variable()

```python
def delete_global_cluster_variable(name, **kwargs)
```

Delete a global-scoped cluster variable

> Delete a global-scoped cluster variable.

**Parameters:**

| Parameter | Type  | Description                                                                                                           |
| --------- | ----- | --------------------------------------------------------------------------------------------------------------------- |
| `name`    | `str` | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `kwargs`  | `Any` |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a global cluster variable:**

```python
def delete_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    client.delete_global_cluster_variable(name=name)
```

### delete_global_task_listener()

```python
def delete_global_task_listener(id, **kwargs)
```

Delete global user task listener

> Deletes a global user task listener.

**Parameters:**

| Parameter | Type  | Description                                                            |
| --------- | ----- | ---------------------------------------------------------------------- |
| `id`      | `str` | The user-defined id for the global listener Example: GlobalListener_1. |
| `kwargs`  | `Any` |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The global user task listener was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a global task listener:**

```python
def delete_global_task_listener_example(listener_id: GlobalListenerId) -> None:
    client = CamundaClient()

    client.delete_global_task_listener(id=listener_id)
```

### delete_group()

```python
def delete_group(group_id, **kwargs)
```

Delete group

> Deletes the group with the given ID.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a group:**

```python
def delete_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    client.delete_group(group_id=group_id)
```

### delete_mapping_rule()

```python
def delete_mapping_rule(mapping_rule_id, **kwargs)
```

Delete a mapping rule

> Deletes the mapping rule with the given ID.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The mapping rule with the mappingRuleId was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a mapping rule:**

```python
def delete_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.delete_mapping_rule(mapping_rule_id=mapping_rule_id)
```

### delete_process_instance()

```python
def delete_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete process instance

> Deletes a process instance. Only instances that are completed or terminated can be deleted.

**Parameters:**

| Parameter              | Type                                                | Description                                                             |
| ---------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                               | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `DeleteProcessInstanceRequest` \| `None` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                               |                                                                         |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance is not in a completed or terminated state and cannot be deleted.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a process instance:**

```python
def delete_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.delete_process_instance(
        process_instance_key=process_instance_key,
    )
```

### delete_process_instances_batch_operation()

```python
def delete_process_instances_batch_operation(*, data, **kwargs)
```

Delete process instances (batch)

> Delete multiple process instances. This will delete the historic data from secondary storage.
>
> Only process instances in a final state (COMPLETED or TERMINATED) can be deleted.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                           | Description                                                                         |
| --------- | ---------------------------------------------- | ----------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceDeletionBatchOperationRequest` | The process instance filter that defines which process instances should be deleted. |
| `kwargs`  | `Any`                                          |                                                                                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Delete process instances in batch:**

```python
def delete_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.delete_process_instances_batch_operation(
        data=ProcessInstanceDeletionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### delete_resource()

```python
def delete_resource(resource_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Delete resource

> Deletes a deployed resource. This can be a process definition, decision requirements
> definition, or form definition deployed using the deploy resources endpoint. Specify the
> resource you want to delete in the resourceKey parameter.
>
> Once a resource has been deleted it cannot be recovered. If the resource needs to be
> available again, a new deployment of the resource is required.
>
> By default, only the resource itself is deleted from the runtime state. To also delete the
> historic data associated with a resource, set the deleteHistory flag in the request body
> to true. The historic data is deleted asynchronously via a batch operation. The details of
> the created batch operation are included in the response. Note that history deletion is only
> supported for process resources; for other resource types this flag is ignored and no history
> will be deleted.

**Parameters:**

| Parameter      | Type                                         | Description                                |
| -------------- | -------------------------------------------- | ------------------------------------------ |
| `resource_key` | `str`                                        | The system-assigned key for this resource. |
| `data`         | `DeleteResourceRequest` \| `None` \| `Unset` |                                            |
| `kwargs`       | `Any`                                        |                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The resource is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DeleteResourceResponse
- **Return type:**
  DeleteResourceResponse

#### Examples

**Delete a resource:**

```python
def delete_resource_example() -> None:
    client = CamundaClient()

    # Use a resource key from a previous deployment response
    client.delete_resource(resource_key="2251799813685249")
```

### delete_role()

```python
def delete_role(role_id, **kwargs)
```

Delete role

> Deletes the role with the given ID.

**Parameters:**

| Parameter | Type  | Description                                      |
| --------- | ----- | ------------------------------------------------ |
| `role_id` | `str` | The unique identifier of a role. Example: admin. |
| `kwargs`  | `Any` |                                                  |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The role with the ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a role:**

```python
def delete_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    client.delete_role(role_id=role_id)
```

### delete_tenant()

```python
def delete_tenant(tenant_id, **kwargs)
```

Delete tenant

> Deletes an existing tenant.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a tenant:**

```python
def delete_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    client.delete_tenant(tenant_id=tenant_id)
```

### delete_tenant_cluster_variable()

```python
def delete_tenant_cluster_variable(tenant_id, name, **kwargs)
```

Delete a tenant-scoped cluster variable

> Delete a tenant-scoped cluster variable.

**Parameters:**

| Parameter   | Type  | Description                                                                                                           |
| ----------- | ----- | --------------------------------------------------------------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service.                                                       |
| `name`      | `str` | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `kwargs`    | `Any` |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a tenant cluster variable:**

```python
def delete_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    client.delete_tenant_cluster_variable(
        tenant_id=tenant_id,
        name=name,
    )
```

### delete_user()

```python
def delete_user(username, **kwargs)
```

Delete user

> Deletes a user.

**Parameters:**

| Parameter  | Type  | Description                                  |
| ---------- | ----- | -------------------------------------------- |
| `username` | `str` | The unique name of a user. Example: swillis. |
| `kwargs`   | `Any` |                                              |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Delete a user:**

```python
def delete_user_example(username: Username) -> None:
    client = CamundaClient()

    client.delete_user(username=username)
```

### deploy_resources_from_files()

```python
def deploy_resources_from_files(files, tenant_id=None)
```

Deploy BPMN/DMN/Form resources from local files.

This is a convenience wrapper around [`create_deployment()`](#create_deployment) that:

- Reads each path in `files` as bytes.
- Wraps the bytes in `camunda_orchestration_sdk.types.File` using the file’s basename
  as `file_name`.
- Builds `camunda_orchestration_sdk.models.CreateDeploymentData` and calls
  [`create_deployment()`](#create_deployment).
- Returns an `ExtendedDeploymentResult`, which is the deployment response plus
  convenience lists (`processes`, `decisions`, `decision_requirements`, `forms`).

**Parameters:**

| Parameter   | Type                | Description                                                              |
| ----------- | ------------------- | ------------------------------------------------------------------------ |
| `files`     | list [str \| Path ] | File paths (`str` or `Path`) to deploy.                                  |
| `tenant_id` | `str` \| `None`     | Optional tenant identifier. If not provided, the default tenant is used. |

- **Returns:**
  The deployment result with extracted resource lists.
- **Return type:**
  ExtendedDeploymentResult
- **Raises:**
  - **FileNotFoundError** – If any file path does not exist.
  - **PermissionError** – If any file path cannot be read.
  - **IsADirectoryError** – If any file path is a directory.
  - **OSError** – For other I/O failures while reading files.
  - **Exception** – Propagates any exception raised by [`create_deployment()`](#create_deployment) (including
    typed API errors in `camunda_orchestration_sdk.errors` and `httpx.TimeoutException`).

### evaluate_conditionals()

```python
def evaluate_conditionals(*, data, **kwargs)
```

Evaluate root level conditional start events

> Evaluates root-level conditional start events for process definitions.
>
> If the evaluation is successful, it will return the keys of all created process instances, along
> with their associated process definition key.
> Multiple root-level conditional start events of the same process definition can trigger if their
> conditions evaluate to true.

**Parameters:**

| Parameter | Type                               | Description |
| --------- | ---------------------------------- | ----------- |
| `data`    | `ConditionalEvaluationInstruction` |             |
| `kwargs`  | `Any`                              |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. The client is not authorized to start process instances for the specified process definition. If a processDefinitionKey is not provided, this indicates that the client is not authorized to start process instances for at least one of the matched process definitions.
  - **errors.NotFoundError** – If the response status code is 404. The process definition was not found for the given processDefinitionKey.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  EvaluateConditionalResult
- **Return type:**
  EvaluateConditionalResult

#### Examples

**Evaluate conditionals:**

```python
def evaluate_conditionals_example() -> None:
    client = CamundaClient()

    result = client.evaluate_conditionals(
        data=ConditionalEvaluationInstruction(
            variables=ConditionalEvaluationInstructionVariables.from_dict({"orderReady": True}),
        ),
    )

    print(f"Result: {result}")
```

### evaluate_decision()

```python
def evaluate_decision(*, data, **kwargs)
```

Evaluate decision

> Evaluates a decision.
>
> You specify the decision to evaluate either by using its unique key (as returned by
> DeployResource), or using the decision ID. When using the decision ID, the latest deployed
> version of the decision is used.

**Parameters:**

| Parameter | Type                                                  | Description |
| --------- | ----------------------------------------------------- | ----------- |
| `data`    | `DecisionEvaluationByID` \| `DecisionEvaluationByKey` |             |
| `kwargs`  | `Any`                                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The decision is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  EvaluateDecisionResult
- **Return type:**
  EvaluateDecisionResult

#### Examples

**By key:**

```python
def evaluate_decision_by_key_example(decision_definition_key: DecisionDefinitionKey) -> None:
    client = CamundaClient()

    result = client.evaluate_decision(
        data=DecisionEvaluationByKey(
            decision_definition_key=decision_definition_key,
        )
    )

    print(f"Decision key: {result.decision_definition_key}")
```

**By ID:**

```python
def evaluate_decision_by_id_example(decision_definition_id: DecisionDefinitionId) -> None:
    client = CamundaClient()

    result = client.evaluate_decision(
        data=DecisionEvaluationByID(
            decision_definition_id=decision_definition_id,
        )
    )

    print(f"Decision key: {result.decision_definition_key}")
```

### evaluate_expression()

```python
def evaluate_expression(*, data, **kwargs)
```

Evaluate an expression

> Evaluates a FEEL expression and returns the result. Supports references to tenant scoped
> cluster variables when a tenant ID is provided. Optionally, provide a scopeKey to make the
> variables of a specific process instance or element instance visible while evaluating the
> expression.

**Parameters:**

| Parameter | Type                          | Description |
| --------- | ----------------------------- | ----------- |
| `data`    | `ExpressionEvaluationRequest` |             |
| `kwargs`  | `Any`                         |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ExpressionEvaluationResult
- **Return type:**
  ExpressionEvaluationResult

#### Examples

**Evaluate an expression:**

```python
def evaluate_expression_example() -> None:
    client = CamundaClient()

    result = client.evaluate_expression(
        data=ExpressionEvaluationRequest(
            expression="= 1 + 2",
        ),
    )

    print(f"Result: {result.result}")
```

### fail_job()

```python
def fail_job(job_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Fail job

> Mark the job as failed.

**Parameters:**

| Parameter | Type                        | Description                                                |
| --------- | --------------------------- | ---------------------------------------------------------- |
| `job_key` | `str`                       | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobFailRequest` \| `Unset` |                                                            |
| `kwargs`  | `Any`                       |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the given jobKey is not found. It was completed by another worker, or the process instance itself was canceled.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state (i.e: not ACTIVATED or ACTIVATABLE). The job was failed by another worker with retries = 0, and the process is now in an incident state.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Fail a job with retry:**

```python
def fail_job_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.fail_job(
        job_key=job_key,
        data=JobFailRequest(
            retries=2,
            error_message="Payment gateway timeout",
            retry_back_off=5000,
        ),
    )
```

### get_agent_instance()

```python
def get_agent_instance(agent_instance_key, *, consistency=None, **kwargs)
```

Get agent instance

> Returns agent instance as JSON.

**Parameters:**

| Parameter            | Type                           | Description                                                            |
| -------------------- | ------------------------------ | ---------------------------------------------------------------------- |
| `agent_instance_key` | `str`                          | System-generated key for an agent instance. Example: 4503599627370496. |
| `consistency`        | `ConsistencyOptions` \| `None` |                                                                        |
| `kwargs`             | `Any`                          |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceResult
- **Return type:**
  AgentInstanceResult

#### Examples

**Get an agent instance:**

```python
def get_agent_instance_example(agent_instance_key: AgentInstanceKey) -> None:
    client = CamundaClient()

    agent_instance = client.get_agent_instance(agent_instance_key=agent_instance_key)

    print(f"Agent instance status: {agent_instance.status}")
```

### get_audit_log()

```python
def get_audit_log(audit_log_key, *, consistency=None, **kwargs)
```

Get audit log

> Get an audit log entry by auditLogKey.

**Parameters:**

| Parameter       | Type                           | Description                                                              |
| --------------- | ------------------------------ | ------------------------------------------------------------------------ |
| `audit_log_key` | `str`                          | System-generated key for an audit log entry. Example: 22517998136843567. |
| `consistency`   | `ConsistencyOptions` \| `None` |                                                                          |
| `kwargs`        | `Any`                          |                                                                          |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The audit log with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuditLogResult
- **Return type:**
  AuditLogResult

#### Examples

**Get an audit log entry:**

```python
def get_audit_log_example(audit_log_key: AuditLogKey) -> None:
    client = CamundaClient()

    result = client.get_audit_log(audit_log_key=audit_log_key)

    print(f"Audit log: {result.audit_log_key}")
```

### get_authentication()

```python
def get_authentication(**kwargs)
```

Get current user

> Retrieves the current authenticated user.

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  CamundaUserResult
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  CamundaUserResult

#### Examples

**Get authentication info:**

```python
def get_authentication_example() -> None:
    client = CamundaClient()

    result = client.get_authentication()

    print(f"Authenticated user: {result.username}")
```

### get_authorization()

```python
def get_authorization(authorization_key, *, consistency=None, **kwargs)
```

Get authorization

> Get authorization by the given key.

**Parameters:**

| Parameter           | Type                           | Description                                                           |
| ------------------- | ------------------------------ | --------------------------------------------------------------------- |
| `authorization_key` | `str`                          | System-generated key for an authorization. Example: 2251799813684332. |
| `consistency`       | `ConsistencyOptions` \| `None` |                                                                       |
| `kwargs`            | `Any`                          |                                                                       |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The authorization with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuthorizationResult
- **Return type:**
  AuthorizationResult

#### Examples

**Get an authorization:**

```python
def get_authorization_example(authorization_key: AuthorizationKey) -> None:
    client = CamundaClient()

    result = client.get_authorization(
        authorization_key=authorization_key,
    )

    print(f"Resource type: {result.resource_type}")
```

### get_batch_operation()

```python
def get_batch_operation(batch_operation_key, *, consistency=None, **kwargs)
```

Get batch operation

> Get batch operation by key.

**Parameters:**

| Parameter             | Type                           | Description                                                             |
| --------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`                          | System-generated key for an batch operation. Example: 2251799813684321. |
| `consistency`         | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`              | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The batch operation is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationResponse
- **Return type:**
  BatchOperationResponse

#### Examples

**Get a batch operation:**

```python
def get_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    result = client.get_batch_operation(
        batch_operation_key=batch_operation_key,
    )

    print(f"Batch operation: {result.batch_operation_key}")
```

### get_decision_definition()

```python
def get_decision_definition(decision_definition_key, *, consistency=None, **kwargs)
```

Get decision definition

> Returns a decision definition by key.

**Parameters:**

| Parameter                 | Type                           | Description                                                                |
| ------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
| `decision_definition_key` | `str`                          | System-generated key for a decision definition. Example: 2251799813326547. |
| `consistency`             | `ConsistencyOptions` \| `None` |                                                                            |
| `kwargs`                  | `Any`                          |                                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionDefinitionResult
- **Return type:**
  DecisionDefinitionResult

#### Examples

**Get a decision definition:**

```python
def get_decision_definition_example(decision_definition_key: DecisionDefinitionKey) -> None:
    client = CamundaClient()

    definition = client.get_decision_definition(
        decision_definition_key=decision_definition_key,
    )

    print(f"Decision: {definition.decision_definition_id}")
```

### get_decision_definition_xml()

```python
def get_decision_definition_xml(decision_definition_key, *, consistency=None, **kwargs)
```

Get decision definition XML

> Returns decision definition as XML.

**Parameters:**

| Parameter                 | Type                           | Description                                                                |
| ------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
| `decision_definition_key` | `str`                          | System-generated key for a decision definition. Example: 2251799813326547. |
| `consistency`             | `ConsistencyOptions` \| `None` |                                                                            |
| `kwargs`                  | `Any`                          |                                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  str
- **Return type:**
  str

#### Examples

**Get decision definition XML:**

```python
def get_decision_definition_xml_example(decision_definition_key: DecisionDefinitionKey) -> None:
    client = CamundaClient()

    xml = client.get_decision_definition_xml(
        decision_definition_key=decision_definition_key,
    )

    print(f"XML length: {len(xml)}")
```

### get_decision_instance()

```python
def get_decision_instance(decision_evaluation_instance_key, *, consistency=None, **kwargs)
```

Get decision instance

> Returns a decision instance.

**Parameters:**

| Parameter                          | Type   | Description |
| ---------------------------------- | ------ | ----------- |
| `decision_evaluation_instance_key` | str) – |             |

    System-generated identifier for a decision
    evaluation instance. It is composed of the
    parent decision evaluation key and the 1-based index of the evaluated decision within
    that evaluation, joined by a hyphen (format: <decisionEvaluationKey>-<index>).
    > Example: 2251799813684367-1.

- **consistency** (_ConsistencyOptions_ _|_ _None_)
- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionInstanceGetQueryResult
- **Return type:**
  DecisionInstanceGetQueryResult

#### Examples

**Get a decision instance:**

```python
def get_decision_instance_example(decision_evaluation_instance_key: DecisionEvaluationInstanceKey) -> None:
    client = CamundaClient()

    result = client.get_decision_instance(
        decision_evaluation_instance_key=decision_evaluation_instance_key,
    )

    print(f"Decision instance: {result.decision_definition_id}")
```

### get_decision_requirements()

```python
def get_decision_requirements(decision_requirements_key, *, consistency=None, **kwargs)
```

Get decision requirements

> Returns Decision Requirements as JSON.

**Parameters:**

| Parameter                   | Type                           | Description                                                                                      |
| --------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------ |
| `decision_requirements_key` | `str`                          | System-generated key for a deployed decision requirements definition. Example: 2251799813683346. |
| `consistency`               | `ConsistencyOptions` \| `None` |                                                                                                  |
| `kwargs`                    | `Any`                          |                                                                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision requirements with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionRequirementsResult
- **Return type:**
  DecisionRequirementsResult

#### Examples

**Get decision requirements:**

```python
def get_decision_requirements_example(decision_requirements_key: DecisionRequirementsKey) -> None:
    client = CamundaClient()

    result = client.get_decision_requirements(
        decision_requirements_key=decision_requirements_key,
    )

    print(f"DRD: {result.decision_requirements_name}")
```

### get_decision_requirements_xml()

```python
def get_decision_requirements_xml(decision_requirements_key, *, consistency=None, **kwargs)
```

Get decision requirements XML

> Returns decision requirements as XML.

**Parameters:**

| Parameter                   | Type                           | Description                                                                                      |
| --------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------ |
| `decision_requirements_key` | `str`                          | System-generated key for a deployed decision requirements definition. Example: 2251799813683346. |
| `consistency`               | `ConsistencyOptions` \| `None` |                                                                                                  |
| `kwargs`                    | `Any`                          |                                                                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The decision requirements with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  str
- **Return type:**
  str

#### Examples

**Get decision requirements XML:**

```python
def get_decision_requirements_xml_example(decision_requirements_key: DecisionRequirementsKey) -> None:
    client = CamundaClient()

    xml = client.get_decision_requirements_xml(
        decision_requirements_key=decision_requirements_key,
    )

    print(f"XML length: {len(xml)}")
```

### get_document()

```python
def get_document(document_id, *, store_id=<camunda_orchestration_sdk.types.Unset object>, content_hash=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Download document

> Download a document from the Camunda 8 cluster.
>
> Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-
> production), local (non-production)

**Parameters:**

| Parameter      | Type             | Description                                      |
| -------------- | ---------------- | ------------------------------------------------ |
| `document_id`  | `str`            | Document Id that uniquely identifies a document. |
| `store_id`     | `str` \| `Unset` |                                                  |
| `content_hash` | `str` \| `Unset` |                                                  |
| `kwargs`       | `Any`            |                                                  |

- **Raises:**
  - **errors.NotFoundError** – If the response status code is 404. The document with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  File
- **Return type:**
  File

#### Examples

**Get a document:**

```python
def get_document_example(document_id: DocumentId) -> None:
    client = CamundaClient()

    result = client.get_document(document_id=document_id)

    print(f"File name: {result.file_name}")
```

### get_element_instance()

```python
def get_element_instance(element_instance_key, *, consistency=None, **kwargs)
```

Get element instance

> Returns element instance as JSON.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `element_instance_key` | `str`                          | System-generated key for a element instance. Example: 2251799813686789. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The element instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ElementInstanceResult
- **Return type:**
  ElementInstanceResult

#### Examples

**Get an element instance:**

```python
def get_element_instance_example(element_instance_key: ElementInstanceKey) -> None:
    client = CamundaClient()

    result = client.get_element_instance(
        element_instance_key=element_instance_key,
    )

    print(f"Element: {result.element_id}")
```

### get_form_by_key()

```python
def get_form_by_key(form_key, *, consistency=None, **kwargs)
```

Get form by key

> Get a form by its unique form key.

**Parameters:**

| Parameter     | Type                           | Description                                                          |
| ------------- | ------------------------------ | -------------------------------------------------------------------- |
| `form_key`    | `str`                          | System-generated key for a deployed form. Example: 2251799813684365. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                      |
| `kwargs`      | `Any`                          |                                                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The form with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  FormResult
- **Return type:**
  FormResult

#### Examples

**Get a form by key:**

```python
def get_form_by_key_example(form_key: FormKey) -> None:
    client = CamundaClient()

    result = client.get_form_by_key(form_key=form_key)

    print(f"Form: {result.form_id}")
```

### get_global_cluster_variable()

```python
def get_global_cluster_variable(name, *, consistency=None, **kwargs)
```

Get a global-scoped cluster variable

> Get a global-scoped cluster variable.

**Parameters:**

| Parameter     | Type                           | Description                                                                                                           |
| ------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `name`        | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                                                                       |
| `kwargs`      | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Get a global cluster variable:**

```python
def get_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.get_global_cluster_variable(name=name)

    print(f"Variable: {result.name} = {result.value}")
```

### get_global_job_statistics()

```python
def get_global_job_statistics(*, from_, to, job_type=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Global job statistics

> Returns global aggregated counts for jobs. Filter by the creation time window (required) and
> optionally by jobType.

**Parameters:**

| Parameter     | Type                           | Description |
| ------------- | ------------------------------ | ----------- |
| `from`        | `datetime.datetime`            |             |
| `to`          | `datetime.datetime`            |             |
| `job_type`    | `str` \| `Unset`               |             |
| `from_`       | `datetime.datetime`            |             |
| `consistency` | `ConsistencyOptions` \| `None` |             |
| `kwargs`      | `Any`                          |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalJobStatisticsQueryResult
- **Return type:**
  GlobalJobStatisticsQueryResult

#### Examples

**Get global job statistics:**

```python
def get_global_job_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_global_job_statistics(
        from_=datetime.datetime(2024, 1, 1),
        to=datetime.datetime(2024, 12, 31),
    )

    print(f"Global job stats: {result}")
```

### get_global_task_listener()

```python
def get_global_task_listener(id, *, consistency=None, **kwargs)
```

Get global user task listener

> Get a global user task listener by its id.

**Parameters:**

| Parameter     | Type                           | Description                                                            |
| ------------- | ------------------------------ | ---------------------------------------------------------------------- |
| `id`          | `str`                          | The user-defined id for the global listener Example: GlobalListener_1. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                        |
| `kwargs`      | `Any`                          |                                                                        |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The global user task listener with the given id was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerResult
- **Return type:**
  GlobalTaskListenerResult

#### Examples

**Get a global task listener:**

```python
def get_global_task_listener_example(listener_id: GlobalListenerId) -> None:
    client = CamundaClient()

    result = client.get_global_task_listener(id=listener_id)

    print(f"Task listener: {result.event_types}")
```

### get_group()

```python
def get_group(group_id, *, consistency=None, **kwargs)
```

Get group

> Get a group by its ID.

**Parameters:**

| Parameter     | Type                           | Description                                             |
| ------------- | ------------------------------ | ------------------------------------------------------- |
| `group_id`    | `str`                          | The unique identifier of a group. Example: engineering. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                         |
| `kwargs`      | `Any`                          |                                                         |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupResult
- **Return type:**
  GroupResult

#### Examples

**Get a group:**

```python
def get_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.get_group(group_id=group_id)

    print(f"Group: {result.name}")
```

### get_incident()

```python
def get_incident(incident_key, *, consistency=None, **kwargs)
```

Get incident

> Returns incident as JSON.

**Parameters:**

| Parameter      | Type                           | Description                                                     |
| -------------- | ------------------------------ | --------------------------------------------------------------- |
| `incident_key` | `str`                          | System-generated key for a incident. Example: 2251799813689432. |
| `consistency`  | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`       | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The incident with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentResult
- **Return type:**
  IncidentResult

#### Examples

**Get an incident:**

```python
def get_incident_example(incident_key: IncidentKey) -> None:
    client = CamundaClient()

    incident = client.get_incident(incident_key=incident_key)

    print(f"Incident error type: {incident.error_type}")
```

### get_job_error_statistics()

```python
def get_job_error_statistics(*, data, consistency=None, **kwargs)
```

Get error metrics for a job type

> Returns aggregated metrics per error for the given jobType.

**Parameters:**

| Parameter     | Type                           | Description                 |
| ------------- | ------------------------------ | --------------------------- |
| `data`        | `JobErrorStatisticsQuery`      | Job error statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                             |
| `kwargs`      | `Any`                          |                             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobErrorStatisticsQueryResult
- **Return type:**
  JobErrorStatisticsQueryResult

#### Examples

**Get job error statistics:**

```python
def get_job_error_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_error_statistics(
        data=JobErrorStatisticsQuery(
            filter_=JobErrorStatisticsFilter(
                from_=datetime.datetime(2024, 1, 1),
                to=datetime.datetime(2024, 12, 31),
                job_type="payment-processing",
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Error: {stat.error_code}")
```

### get_job_time_series_statistics()

```python
def get_job_time_series_statistics(*, data, consistency=None, **kwargs)
```

Get time-series metrics for a job type

> Returns a list of time-bucketed metrics ordered ascending by time.
>
> The from and to fields select the time window of interest.
> Each item in the response corresponds to one time bucket of the requested resolution.

**Parameters:**

| Parameter     | Type                           | Description                       |
| ------------- | ------------------------------ | --------------------------------- |
| `data`        | `JobTimeSeriesStatisticsQuery` | Job time-series statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                                   |
| `kwargs`      | `Any`                          |                                   |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobTimeSeriesStatisticsQueryResult
- **Return type:**
  JobTimeSeriesStatisticsQueryResult

#### Examples

**Get job time series statistics:**

```python
def get_job_time_series_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_time_series_statistics(
        data=JobTimeSeriesStatisticsQuery(
            filter_=JobTimeSeriesStatisticsFilter(
                from_=datetime.datetime(2024, 1, 1),
                to=datetime.datetime(2024, 12, 31),
                job_type="payment-processing",
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Time series: {stat}")
```

### get_job_type_statistics()

```python
def get_job_type_statistics(*, data, consistency=None, **kwargs)
```

Get job statistics by type

> Get statistics about jobs, grouped by job type.

**Parameters:**

| Parameter     | Type                           | Description                |
| ------------- | ------------------------------ | -------------------------- |
| `data`        | `JobTypeStatisticsQuery`       | Job type statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                            |
| `kwargs`      | `Any`                          |                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobTypeStatisticsQueryResult
- **Return type:**
  JobTypeStatisticsQueryResult

#### Examples

**Get job type statistics:**

```python
def get_job_type_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_type_statistics(
        data=JobTypeStatisticsQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Job type: {stat.job_type}")
```

### get_job_worker_statistics()

```python
def get_job_worker_statistics(*, data, consistency=None, **kwargs)
```

Get job statistics by worker

> Get statistics about jobs, grouped by worker, for a given job type.

**Parameters:**

| Parameter     | Type                           | Description                  |
| ------------- | ------------------------------ | ---------------------------- |
| `data`        | `JobWorkerStatisticsQuery`     | Job worker statistics query. |
| `consistency` | `ConsistencyOptions` \| `None` |                              |
| `kwargs`      | `Any`                          |                              |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobWorkerStatisticsQueryResult
- **Return type:**
  JobWorkerStatisticsQueryResult

#### Examples

**Get job worker statistics:**

```python
def get_job_worker_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_job_worker_statistics(
        data=JobWorkerStatisticsQuery(
            filter_=JobWorkerStatisticsFilter(
                from_=datetime.datetime(2024, 1, 1),
                to=datetime.datetime(2024, 12, 31),
                job_type="payment-processing",
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Worker: {stat.worker}")
```

### get_license()

```python
def get_license(**kwargs)
```

Get license status

> Obtains the status of the current Camunda license.

- **Raises:**
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  LicenseResponse
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  LicenseResponse

#### Examples

**Get license information:**

```python
def get_license_example() -> None:
    client = CamundaClient()

    result = client.get_license()

    print(f"License type: {result.license_type}")
```

### get_mapping_rule()

```python
def get_mapping_rule(mapping_rule_id, *, consistency=None, **kwargs)
```

Get a mapping rule

> Gets the mapping rule with the given ID.

**Parameters:**

| Parameter         | Type                           | Description                                                        |
| ----------------- | ------------------------------ | ------------------------------------------------------------------ |
| `mapping_rule_id` | `str`                          | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `consistency`     | `ConsistencyOptions` \| `None` |                                                                    |
| `kwargs`          | `Any`                          |                                                                    |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The mapping rule with the mappingRuleId was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleResult
- **Return type:**
  MappingRuleResult

#### Examples

**Get a mapping rule:**

```python
def get_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    result = client.get_mapping_rule(mapping_rule_id=mapping_rule_id)

    print(f"Mapping rule: {result.name}")
```

### get_process_definition()

```python
def get_process_definition(process_definition_key, *, consistency=None, **kwargs)
```

Get process definition

> Returns process definition as JSON.

**Parameters:**

| Parameter                | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                          | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `consistency`            | `ConsistencyOptions` \| `None` |                                                                                    |
| `kwargs`                 | `Any`                          |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionResult
- **Return type:**
  ProcessDefinitionResult

#### Examples

**Get a process definition:**

```python
def get_process_definition_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_definition(
        process_definition_key=process_definition_key,
    )

    print(f"Process definition: {result.name}")
```

### get_process_definition_instance_statistics()

```python
def get_process_definition_instance_statistics(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get process instance statistics

> Get statistics about process instances, grouped by process definition and tenant.

**Parameters:**

| Parameter     | Type                                                  | Description |
| ------------- | ----------------------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionInstanceStatisticsQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                        |             |
| `kwargs`      | `Any`                                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionInstanceStatisticsQueryResult
- **Return type:**
  ProcessDefinitionInstanceStatisticsQueryResult

#### Examples

**Get process definition instance statistics:**

```python
def get_process_definition_instance_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_process_definition_instance_statistics(
        data=ProcessDefinitionInstanceStatisticsQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Definition: {stat.process_definition_id}")
```

### get_process_definition_instance_version_statistics()

```python
def get_process_definition_instance_version_statistics(*, data, consistency=None, **kwargs)
```

Get process instance statistics by version

> Get statistics about process instances, grouped by version for a given process definition.
>
> The process definition ID must be provided as a required field in the request body filter.

**Parameters:**

| Parameter     | Type                                              | Description |
| ------------- | ------------------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionInstanceVersionStatisticsQuery` |             |
| `consistency` | `ConsistencyOptions` \| `None`                    |             |
| `kwargs`      | `Any`                                             |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionInstanceVersionStatisticsQueryResult
- **Return type:**
  ProcessDefinitionInstanceVersionStatisticsQueryResult

#### Examples

**Get version statistics:**

```python
def get_process_definition_instance_version_statistics_example(
    process_definition_id: ProcessDefinitionId,
) -> None:
    client = CamundaClient()

    result = client.get_process_definition_instance_version_statistics(
        data=ProcessDefinitionInstanceVersionStatisticsQuery(
            filter_=ProcessDefinitionInstanceVersionStatisticsQueryFilter(
                process_definition_id=process_definition_id,
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Version: {stat.process_definition_version}")
```

### get_process_definition_message_subscription_statistics()

```python
def get_process_definition_message_subscription_statistics(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get message subscription statistics

> Get message subscription statistics, grouped by process definition.

**Parameters:**

| Parameter     | Type                                                             | Description |
| ------------- | ---------------------------------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionMessageSubscriptionStatisticsQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                                   |             |
| `kwargs`      | `Any`                                                            |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionMessageSubscriptionStatisticsQueryResult
- **Return type:**
  ProcessDefinitionMessageSubscriptionStatisticsQueryResult

#### Examples

**Get message subscription statistics:**

```python
def get_process_definition_message_subscription_statistics_example() -> None:
    client = CamundaClient()

    result = client.get_process_definition_message_subscription_statistics(
        data=ProcessDefinitionMessageSubscriptionStatisticsQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(
                f"Definition: {stat.process_definition_id}, subscriptions: {stat.active_subscriptions}"
            )
```

### get_process_definition_statistics()

```python
def get_process_definition_statistics(process_definition_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get process definition statistics

> Get statistics about elements in currently running process instances by process definition key and
> search filter.

**Parameters:**

| Parameter                | Type                                                 | Description                                                                        |
| ------------------------ | ---------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                                                | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `data`                   | `ProcessDefinitionElementStatisticsQuery` \| `Unset` | Process definition element statistics request.                                     |
| `consistency`            | `ConsistencyOptions` \| `None`                       |                                                                                    |
| `kwargs`                 | `Any`                                                |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionElementStatisticsQueryResult
- **Return type:**
  ProcessDefinitionElementStatisticsQueryResult

#### Examples

**Get process definition element statistics:**

```python
def get_process_definition_statistics_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_definition_statistics(
        process_definition_key=process_definition_key,
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Element: {stat.element_id}")
```

### get_process_definition_xml()

```python
def get_process_definition_xml(process_definition_key, *, consistency=None, **kwargs)
```

Get process definition XML

> Returns process definition as XML.

**Parameters:**

| Parameter                | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                          | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `consistency`            | `ConsistencyOptions` \| `None` |                                                                                    |
| `kwargs`                 | `Any`                          |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process definition with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  str
- **Return type:**
  str

#### Examples

**Get process definition XML:**

```python
def get_process_definition_xml_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    xml = client.get_process_definition_xml(
        process_definition_key=process_definition_key,
    )

    print(f"XML length: {len(xml)}")
```

### get_process_instance()

```python
def get_process_instance(process_instance_key, *, consistency=None, **kwargs)
```

Get process instance

> Get the process instance by the process instance key.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceResult
- **Return type:**
  ProcessInstanceResult

#### Examples

**Get a process instance:**

```python
def get_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    result = client.get_process_instance(
        process_instance_key=process_instance_key,
    )

    print(f"Process instance: {result.process_definition_id}")
```

### get_process_instance_call_hierarchy()

```python
def get_process_instance_call_hierarchy(process_instance_key, *, consistency=None, **kwargs)
```

Get call hierarchy

> Returns the call hierarchy for a given process instance, showing its ancestry up to the root
> instance.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  list[Any]
- **Return type:**
  list[Any]

#### Examples

**Get process instance call hierarchy:**

```python
def get_process_instance_call_hierarchy_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_call_hierarchy(
        process_instance_key=process_instance_key,
    )

    for entry in result:
        print(f"Call hierarchy entry: {entry}")
```

### get_process_instance_sequence_flows()

```python
def get_process_instance_sequence_flows(process_instance_key, *, consistency=None, **kwargs)
```

Get sequence flows

> Get sequence flows taken by the process instance.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceSequenceFlowsQueryResult
- **Return type:**
  ProcessInstanceSequenceFlowsQueryResult

#### Examples

**Get process instance sequence flows:**

```python
def get_process_instance_sequence_flows_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_sequence_flows(
        process_instance_key=process_instance_key,
    )

    if not isinstance(result.items, Unset):
        for flow in result.items:
            print(f"Sequence flow: {flow}")
```

### get_process_instance_statistics()

```python
def get_process_instance_statistics(process_instance_key, *, consistency=None, **kwargs)
```

Get element instance statistics

> Get statistics about elements by the process instance key.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceElementStatisticsQueryResult
- **Return type:**
  ProcessInstanceElementStatisticsQueryResult

#### Examples

**Get process instance statistics:**

```python
def get_process_instance_statistics_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_statistics(
        process_instance_key=process_instance_key,
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Element: {stat.element_id}, Active: {stat.active}")
```

### get_process_instance_statistics_by_definition()

```python
def get_process_instance_statistics_by_definition(*, data, consistency=None, **kwargs)
```

Get process instance statistics by definition

> Returns statistics for active process instances with incidents, grouped by process
> definition. The result set is scoped to a specific incident error hash code, which must be
> provided as a filter in the request body.

**Parameters:**

| Parameter     | Type                                                 | Description |
| ------------- | ---------------------------------------------------- | ----------- |
| `data`        | `IncidentProcessInstanceStatisticsByDefinitionQuery` |             |
| `consistency` | `ConsistencyOptions` \| `None`                       |             |
| `kwargs`      | `Any`                                                |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentProcessInstanceStatisticsByDefinitionQueryResult
- **Return type:**
  IncidentProcessInstanceStatisticsByDefinitionQueryResult

#### Examples

**Get instance statistics by definition:**

```python
def get_process_instance_statistics_by_definition_example() -> None:
    client = CamundaClient()

    result = client.get_process_instance_statistics_by_definition(
        data=IncidentProcessInstanceStatisticsByDefinitionQuery(
            filter_=IncidentProcessInstanceStatisticsByDefinitionQueryFilter(
                error_hash_code=12345,
            ),
        ),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Definition: {stat.process_definition_key}")
```

### get_process_instance_statistics_by_error()

```python
def get_process_instance_statistics_by_error(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get process instance statistics by error

> Returns statistics for active process instances that currently have active incidents,
> grouped by incident error hash code.

**Parameters:**

| Parameter     | Type                                                       | Description |
| ------------- | ---------------------------------------------------------- | ----------- |
| `data`        | `IncidentProcessInstanceStatisticsByErrorQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                             |             |
| `kwargs`      | `Any`                                                      |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentProcessInstanceStatisticsByErrorQueryResult
- **Return type:**
  IncidentProcessInstanceStatisticsByErrorQueryResult

#### Examples

**Get instance statistics by error:**

```python
def get_process_instance_statistics_by_error_example() -> None:
    client = CamundaClient()

    result = client.get_process_instance_statistics_by_error(
        data=IncidentProcessInstanceStatisticsByErrorQuery(),
    )

    if not isinstance(result.items, Unset):
        for stat in result.items:
            print(f"Error: {stat.error_message}")
```

### get_process_instance_wait_state_statistics()

```python
def get_process_instance_wait_state_statistics(process_instance_key, *, consistency=None, **kwargs)
```

Get wait state statistics

> Get statistics about waiting element instances by the process instance key, grouped by element id.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                          | System-generated key for a process instance. Example: 2251799813690746. |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceWaitStateStatisticsQueryResult
- **Return type:**
  ProcessInstanceWaitStateStatisticsQueryResult

#### Examples

**Get process instance wait state statistics:**

```python
def get_process_instance_wait_state_statistics_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.get_process_instance_wait_state_statistics(
        process_instance_key=process_instance_key,
    )

    for stat in result.items:
        print(f"Element: {stat.element_id}, Waiting: {stat.waiting_count}")
```

### get_resource()

```python
def get_resource(resource_key, *, consistency=None, **kwargs)
```

Get resource

> Returns a deployed resource.

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective APIs.
:::

- **resource_key**: The system-assigned key for this resource.

````

* **Raises:**
  * **errors.NotFoundError** – If the response status code is 404. A resource with the given key was not found.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  ResourceResult
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `resource_key` | `str` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  ResourceResult

#### Examples

**Get a resource:**

```python
def get_resource_example() -> None:
    client = CamundaClient()

    result = client.get_resource(resource_key="123456")

    print(f"Resource: {result.resource_name}")
````

### get_resource_content()

```python
def get_resource_content(resource_key, *, consistency=None, **kwargs)
```

Get RPA resource content (deprecated)

> **Deprecated** — use /resources/{resourceKey}/content/binary instead, which supports all
> resource types and returns content as binary (octet-stream).
>
> Returns the content of a deployed RPA resource as JSON.

:::info
This endpoint only supports RPA resources. For generic resource content in binary format,
use the /resources/{resourceKey}/content/binary endpoint.
:::

- **resource_key**: The system-assigned key for this resource.

````

* **Raises:**
  * **errors.NotFoundError** – If the response status code is 404. A resource with the given key was not found.
  * **errors.NotAcceptableError** – If the response status code is 406. The resource exists but is not an RPA resource.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  GetResourceContentResponse200
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `resource_key` | `str` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  GetResourceContentResponse200

#### Examples

**Get resource content:**

```python
def get_resource_content_example() -> None:
    client = CamundaClient()

    content = client.get_resource_content(resource_key="123456")

    print(f"Content: {content}")
````

### get_resource_content_binary()

```python
def get_resource_content_binary(resource_key, *, consistency=None, **kwargs)
```

Get resource content as binary

> Returns the content of a deployed resource in binary format (octet-stream).

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective APIs.
:::

- **resource_key**: The system-assigned key for this resource.

````

* **Raises:**
  * **errors.NotFoundError** – If the response status code is 404. A resource with the given key was not found.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  File
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `resource_key` | `str` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  File

#### Examples

**Get resource content as binary:**

```python
def get_resource_content_binary_example() -> None:
    client = CamundaClient()

    content = client.get_resource_content_binary(resource_key="123456")

    print(f"Binary content size: {len(content.payload.read())}")
````

### get_role()

```python
def get_role(role_id, *, consistency=None, **kwargs)
```

Get role

> Get a role by its ID.

**Parameters:**

| Parameter     | Type                           | Description                                      |
| ------------- | ------------------------------ | ------------------------------------------------ |
| `role_id`     | `str`                          | The unique identifier of a role. Example: admin. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                  |
| `kwargs`      | `Any`                          |                                                  |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleResult
- **Return type:**
  RoleResult

#### Examples

**Get a role:**

```python
def get_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.get_role(role_id=role_id)

    print(f"Role: {result.name}")
```

### get_start_process_form()

```python
def get_start_process_form(process_definition_key, *, consistency=None, **kwargs)
```

Get process start form

> Get the start form of a process.
>
> Note that this endpoint will only return linked forms. This endpoint does not support embedded
> forms.

**Parameters:**

| Parameter                | Type                           | Description                                                                        |
| ------------------------ | ------------------------------ | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                          | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `consistency`            | `ConsistencyOptions` \| `None` |                                                                                    |
| `kwargs`                 | `Any`                          |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  FormResult
- **Return type:**
  FormResult

#### Examples

**Get start process form:**

```python
def get_start_process_form_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.get_start_process_form(
        process_definition_key=process_definition_key,
    )

    print(f"Form: {result.form_key}")
```

### get_status()

```python
def get_status(**kwargs)
```

Get cluster status

- **Raises:**
  - **errors.ServiceUnavailableError** – If the response status code is 503.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  None

#### Examples

**Check cluster status:**

```python
def get_status_example() -> None:
    client = CamundaClient()

    client.get_status()

    print("Cluster is healthy")
```

### get_system_configuration()

```python
def get_system_configuration(**kwargs)
```

System configuration (alpha)

> Returns the current system configuration. The response is an envelope
> that groups settings by feature area.
>
> This endpoint is an alpha feature and may be subject to change
> in future releases.

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  SystemConfigurationResponse
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  SystemConfigurationResponse

#### Examples

**Get system configuration:**

```python
def get_system_configuration_example() -> None:
    client = CamundaClient()

    result = client.get_system_configuration()

    print(f"System config: {result}")
```

### get_tenant()

```python
def get_tenant(tenant_id, *, consistency=None, **kwargs)
```

Get tenant

> Retrieves a single tenant by tenant ID.

**Parameters:**

| Parameter     | Type                           | Description                                                     |
| ------------- | ------------------------------ | --------------------------------------------------------------- |
| `tenant_id`   | `str`                          | The unique identifier of the tenant. Example: customer-service. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`      | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Tenant not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantResult
- **Return type:**
  TenantResult

#### Examples

**Get a tenant:**

```python
def get_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.get_tenant(tenant_id=tenant_id)

    print(f"Tenant: {result.name}")
```

### get_tenant_cluster_variable()

```python
def get_tenant_cluster_variable(tenant_id, name, *, consistency=None, **kwargs)
```

Get a tenant-scoped cluster variable

> Get a tenant-scoped cluster variable.

**Parameters:**

| Parameter     | Type                           | Description                                                                                                           |
| ------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `tenant_id`   | `str`                          | The unique identifier of the tenant. Example: customer-service.                                                       |
| `name`        | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `consistency` | `ConsistencyOptions` \| `None` |                                                                                                                       |
| `kwargs`      | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Get a tenant cluster variable:**

```python
def get_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.get_tenant_cluster_variable(
        tenant_id=tenant_id,
        name=name,
    )

    print(f"Variable: {result.name} = {result.value}")
```

### get_topology()

```python
def get_topology(**kwargs)
```

Get cluster topology

> Obtains the current topology of the cluster the gateway is part of.

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TopologyResponse
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  TopologyResponse

#### Examples

**Get cluster topology:**

```python
def get_topology_example() -> None:
    client = CamundaClient()

    result = client.get_topology()

    print(f"Topology: {result}")
```

### get_usage_metrics()

```python
def get_usage_metrics(*, start_time, end_time, tenant_id=<camunda_orchestration_sdk.types.Unset object>, with_tenants=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Get usage metrics

> Retrieve the usage metrics based on given criteria.

**Parameters:**

| Parameter      | Type                           | Description                                                     |
| -------------- | ------------------------------ | --------------------------------------------------------------- |
| `start_time`   | `datetime.datetime`            | Example: 2025-06-07T13:14:15Z.                                  |
| `end_time`     | `datetime.datetime`            | Example: 2025-06-07T13:14:15Z.                                  |
| `tenant_id`    | `str` \| `Unset`               | The unique identifier of the tenant. Example: customer-service. |
| `with_tenants` | `bool` \| `Unset`              |                                                                 |
| `consistency`  | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`       | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UsageMetricsResponse
- **Return type:**
  UsageMetricsResponse

#### Examples

**Get usage metrics:**

```python
def get_usage_metrics_example() -> None:
    client = CamundaClient()

    result = client.get_usage_metrics(
        start_time=datetime.datetime(2024, 1, 1),
        end_time=datetime.datetime(2024, 12, 31),
    )

    print(f"Metrics: {result}")
```

### get_user()

```python
def get_user(username, *, consistency=None, **kwargs)
```

Get user

> Get a user by its username.

**Parameters:**

| Parameter     | Type                           | Description                                  |
| ------------- | ------------------------------ | -------------------------------------------- |
| `username`    | `str`                          | The unique name of a user. Example: swillis. |
| `consistency` | `ConsistencyOptions` \| `None` |                                              |
| `kwargs`      | `Any`                          |                                              |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The user with the given username was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserResult
- **Return type:**
  UserResult

#### Examples

**Get a user:**

```python
def get_user_example(username: Username) -> None:
    client = CamundaClient()

    result = client.get_user(username=username)

    print(f"User: {result.username}")
```

### get_user_task()

```python
def get_user_task(user_task_key, *, consistency=None, **kwargs)
```

Get user task

> Get the user task by the user task key.

**Parameters:**

| Parameter       | Type                           | Description                           |
| --------------- | ------------------------------ | ------------------------------------- |
| `user_task_key` | `str`                          | System-generated key for a user task. |
| `consistency`   | `ConsistencyOptions` \| `None` |                                       |
| `kwargs`        | `Any`                          |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserTaskResult
- **Return type:**
  UserTaskResult

#### Examples

**Get a user task:**

```python
def get_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    task = client.get_user_task(user_task_key=user_task_key)

    print(f"Task: {task.user_task_key}")
```

### get_user_task_form()

```python
def get_user_task_form(user_task_key, *, consistency=None, **kwargs)
```

Get user task form

> Get the form of a user task.
>
> Note that this endpoint will only return linked forms. This endpoint does not support embedded
> forms.

**Parameters:**

| Parameter       | Type                           | Description                           |
| --------------- | ------------------------------ | ------------------------------------- |
| `user_task_key` | `str`                          | System-generated key for a user task. |
| `consistency`   | `ConsistencyOptions` \| `None` |                                       |
| `kwargs`        | `Any`                          |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  FormResult
- **Return type:**
  FormResult

#### Examples

**Get a user task form:**

```python
def get_user_task_form_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.get_user_task_form(
        user_task_key=user_task_key,
    )

    print(f"Form: {result.form_key}")
```

### get_variable()

```python
def get_variable(variable_key, *, consistency=None, **kwargs)
```

Get variable

> Get a variable by its key.
>
> This endpoint returns both process-level and local (element-scoped) variables.
> The variable’s scopeKey indicates whether it’s a process-level variable or scoped to a
> specific element instance.

**Parameters:**

| Parameter      | Type                           | Description                                                     |
| -------------- | ------------------------------ | --------------------------------------------------------------- |
| `variable_key` | `str`                          | System-generated key for a variable. Example: 2251799813683287. |
| `consistency`  | `ConsistencyOptions` \| `None` |                                                                 |
| `kwargs`       | `Any`                          |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableResult
- **Return type:**
  VariableResult

#### Examples

**Get a variable:**

```python
def get_variable_example(variable_key: VariableKey) -> None:
    client = CamundaClient()

    result = client.get_variable(
        variable_key=variable_key,
    )

    print(f"Variable: {result.name} = {result.value}")
```

### migrate_process_instance()

```python
def migrate_process_instance(process_instance_key, *, data, **kwargs)
```

Migrate process instance

> Migrates a process instance to a new process definition.
>
> This request can contain multiple mapping instructions to define mapping between the active
> process instance’s elements and target process definition elements.
>
> Use this to upgrade a process instance to a new version of a process or to
> a different process definition, e.g. to keep your running instances up-to-date with the
> latest process improvements.

**Parameters:**

| Parameter              | Type                                  | Description                                                                                                   |
| ---------------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `process_instance_key` | `str`                                 | System-generated key for a process instance. Example: 2251799813690746.                                       |
| `data`                 | `ProcessInstanceMigrationInstruction` | The migration instructions describe how to migrate a process instance from one process definition to another. |
| `kwargs`               | `Any`                                 |                                                                                                               |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance migration failed. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Migrate a process instance:**

```python
def migrate_process_instance_example(
    process_instance_key: ProcessInstanceKey,
    target_process_definition_key: ProcessDefinitionKey,
    source_element_id: ElementId,
    target_element_id: ElementId,
) -> None:
    client = CamundaClient()

    client.migrate_process_instance(
        process_instance_key=process_instance_key,
        data=ProcessInstanceMigrationInstruction(
            target_process_definition_key=target_process_definition_key,
            mapping_instructions=[
                MigrateProcessInstanceMappingInstruction(
                    source_element_id=source_element_id,
                    target_element_id=target_element_id,
                ),
            ],
        ),
    )
```

### migrate_process_instances_batch_operation()

```python
def migrate_process_instances_batch_operation(*, data, **kwargs)
```

Migrate process instances (batch)

> Migrate multiple process instances.
>
> Since only process instances with ACTIVE state can be migrated, any given
> filters for state are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                            | Description |
| --------- | ----------------------------------------------- | ----------- |
| `data`    | `ProcessInstanceMigrationBatchOperationRequest` |             |
| `kwargs`  | `Any`                                           |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Migrate process instances in batch:**

```python
def migrate_process_instances_batch_operation_example(target_process_definition_key: ProcessDefinitionKey, source_element_id: ElementId, target_element_id: ElementId) -> None:
    client = CamundaClient()

    result = client.migrate_process_instances_batch_operation(
        data=ProcessInstanceMigrationBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
            migration_plan=ProcessInstanceMigrationBatchOperationRequestMigrationPlan(
                target_process_definition_key=target_process_definition_key,
                mapping_instructions=[
                    MigrateProcessInstanceMappingInstruction(
                        source_element_id=source_element_id,
                        target_element_id=target_element_id,
                    ),
                ],
            ),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### modify_process_instance()

```python
def modify_process_instance(process_instance_key, *, data, **kwargs)
```

Modify process instance

> Modifies a running process instance.
>
> This request can contain multiple instructions to activate an element of the process or
> to terminate an active instance of an element.
>
> Use this to repair a process instance that is stuck on an element or took an unintended path.
> For example, because an external system is not available or doesn’t respond as expected.

**Parameters:**

| Parameter              | Type                                     | Description                                                             |
| ---------------------- | ---------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                    | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `ProcessInstanceModificationInstruction` |                                                                         |
| `kwargs`               | `Any`                                    |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Modify a process instance:**

```python
def modify_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.modify_process_instance(
        process_instance_key=process_instance_key,
        data=ProcessInstanceModificationInstruction(),
    )
```

### modify_process_instances_batch_operation()

```python
def modify_process_instances_batch_operation(*, data, **kwargs)
```

Modify process instances (batch)

> Modify multiple process instances.
>
> Since only process instances with ACTIVE state can be modified, any given
> filters for state are ignored and overridden during this batch operation.
> In contrast to single modification operation, it is not possible to add variable instructions or
> modify by element key.
> It is only possible to use the element id of the source and target.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                               | Description                                                                                                                                           |
| --------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceModificationBatchOperationRequest` | The process instance filter to define on which process instances tokens should be moved, and new element instances should be activated or terminated. |
| `kwargs`  | `Any`                                              |                                                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Modify process instances in batch:**

```python
def modify_process_instances_batch_operation_example(source_element_id: ElementId, target_element_id: ElementId) -> None:
    client = CamundaClient()

    result = client.modify_process_instances_batch_operation(
        data=ProcessInstanceModificationBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
            move_instructions=[
                ProcessInstanceModificationMoveBatchOperationInstruction(
                    source_element_id=source_element_id,
                    target_element_id=target_element_id,
                ),
            ],
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### pin_clock()

```python
def pin_clock(*, data, **kwargs)
```

Pin internal clock (alpha)

> Set a precise, static time for the Zeebe engine’s internal clock.
>
> When the clock is pinned, it remains at the specified time and does not advance.
> To change the time, the clock must be pinned again with a new timestamp.
>
> This endpoint is an alpha feature and may be subject to change
> in future releases.

**Parameters:**

| Parameter | Type              | Description |
| --------- | ----------------- | ----------- |
| `data`    | `ClockPinRequest` |             |
| `kwargs`  | `Any`             |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Pin the cluster clock:**

```python
def pin_clock_example() -> None:
    client = CamundaClient()

    client.pin_clock(
        data=ClockPinRequest(
            timestamp=1700000000000,
        ),
    )
```

### publish_message()

```python
def publish_message(*, data, **kwargs)
```

Publish message

> Publishes a single message.
>
> Messages are published to specific partitions computed from their correlation keys.
> Messages can be buffered.
> The endpoint does not wait for a correlation result.
> Use the message correlation endpoint for such use cases.

**Parameters:**

| Parameter | Type                        | Description |
| --------- | --------------------------- | ----------- |
| `data`    | `MessagePublicationRequest` |             |
| `kwargs`  | `Any`                       |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MessagePublicationResult
- **Return type:**
  MessagePublicationResult

#### Examples

**Publish a message:**

```python
def publish_message_example() -> None:
    client = CamundaClient()

    result = client.publish_message(
        data=MessagePublicationRequest(
            name="order-created",
            correlation_key="order-12345",
            time_to_live=60000,
        )
    )

    print(f"Message key: {result.message_key}")
```

### reset_clock()

```python
def reset_clock(**kwargs)
```

Reset internal clock (alpha)

> Resets the Zeebe engine’s internal clock to the current system time, enabling it to tick in real-
> time.
> This operation is useful for returning the clock to
> normal behavior after it has been pinned to a specific time.
>
> This endpoint is an alpha feature and may be subject to change
> in future releases.

- **Raises:**
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Parameters:**
  **kwargs** (_Any_)
- **Return type:**
  None

#### Examples

**Reset the cluster clock:**

```python
def reset_clock_example() -> None:
    client = CamundaClient()

    client.reset_clock()
```

### resolve_incident()

```python
def resolve_incident(incident_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resolve incident

> Marks the incident as resolved; most likely a call to Update job will be necessary
> to reset the job’s retries, followed by this call.

**Parameters:**

| Parameter      | Type                                   | Description                                                     |
| -------------- | -------------------------------------- | --------------------------------------------------------------- |
| `incident_key` | `str`                                  | System-generated key for a incident. Example: 2251799813689432. |
| `data`         | `IncidentResolutionRequest` \| `Unset` |                                                                 |
| `kwargs`       | `Any`                                  |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The incident with the incidentKey is not found.
  - **errors.ConflictError** – If the response status code is 409. The incident cannot be resolved due to an invalid state. For example, the associated job may have no retries left.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Resolve an incident:**

```python
def resolve_incident_example(incident_key: IncidentKey) -> None:
    client = CamundaClient()

    client.resolve_incident(incident_key=incident_key)
```

### resolve_incidents_batch_operation()

```python
def resolve_incidents_batch_operation(*, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resolve related incidents (batch)

> Resolves multiple instances of process instances.
>
> Since only process instances with ACTIVE state can have unresolved incidents, any given
> filters for state are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                                                | Description                                                                                            |
| --------- | ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `data`    | `ProcessInstanceIncidentResolutionBatchOperationRequest` \| `Unset` | The process instance filter that defines which process instances should have their incidents resolved. |
| `kwargs`  | `Any`                                                               |                                                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Resolve incidents in batch:**

```python
def resolve_incidents_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.resolve_incidents_batch_operation(
        data=ProcessInstanceIncidentResolutionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### resolve_process_instance_incidents()

```python
def resolve_process_instance_incidents(process_instance_key, **kwargs)
```

Resolve related incidents

> Creates a batch operation to resolve multiple incidents of a process instance.

**Parameters:**

| Parameter              | Type  | Description                                                             |
| ---------------------- | ----- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str` | System-generated key for a process instance. Example: 2251799813690746. |
| `kwargs`               | `Any` |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Resolve process instance incidents:**

```python
def resolve_process_instance_incidents_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.resolve_process_instance_incidents(
        process_instance_key=process_instance_key,
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### resolve_secrets()

```python
def resolve_secrets(*, data, **kwargs)
```

Resolve secrets (alpha)

> Resolve a deduplicated batch of camunda.secrets.\* references for the caller’s
> physical tenant in a single round-trip.
>
> Each reference is authorized and resolved independently. For valid requests, the endpoint
> always responds with HTTP 200: successfully resolved references are returned in resolved,
> while references that could not be resolved (for example not found, malformed or over-long,
> or the caller lacks SECRET:REVEAL on that reference) are returned in errors. A failure of
> one reference never fails the others. Only structurally invalid requests are rejected with
> HTTP 400: a missing or non-array references field, more than 20 references, or a null entry.
>
> This endpoint is an alpha feature and may be subject to change in future releases.
>
> Phase 1: the secret backend is mocked. Only a fixed allow-list of references resolves;
> every other authorized, valid reference returns NOT_FOUND.

**Parameters:**

| Parameter | Type                   | Description |
| --------- | ---------------------- | ----------- |
| `data`    | `SecretResolveRequest` |             |
| `kwargs`  | `Any`                  |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  SecretResolveResult
- **Return type:**
  SecretResolveResult

#### Examples

**Resolve secrets:**

```python
def resolve_secrets_example() -> None:
    client = CamundaClient()

    # Hands the resolved secret to whatever needs it (an HTTP client, a DB
    # driver, ...) without logging it.
    def use_secret(value: str) -> None: ...

    result = client.resolve_secrets(
        data=SecretResolveRequest(
            references=[
                "camunda.secrets.my_api_token",
                "camunda.secrets.db_password",
            ],
        )
    )

    # Successfully resolved references are returned in `resolved`; references that
    # could not be resolved are returned in `errors`, each with a typed error code.
    # Never log a resolved value -- it holds secret material. Pass it straight to
    # the consumer that needs it instead.
    for resolved in result.resolved:
        print(f"Resolved {resolved.reference} (value redacted)")
        use_secret(resolved.value)

    for error in result.errors:
        print(f"Failed to resolve {error.reference}: {error.code.value} - {error.message}")
```

### restore()

```python
def restore(*, data, **kwargs)
```

Restore from a backup

> Restores the cluster from a backup. The restore is described either by a single backup ID or by a
> time range (from/to) that selects the backups to restore. This endpoint is only accessible while
> the cluster is in recovery mode; requests are rejected otherwise. The request is validated and
> acknowledged, but the restore itself is performed asynchronously.

**Parameters:**

| Parameter | Type             | Description                                                                                                                                                     |
| --------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data`    | `RestoreRequest` | Describes a restore request. Provide either a list of backup IDs or a time range (from/to) that selects the backups to restore; the two are mutually exclusive. |
| `kwargs`  | `Any`            |                                                                                                                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ConflictError** – If the response status code is 409. The cluster is not in recovery mode, so the restore cannot be accepted.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterModeChangeResponse
- **Return type:**
  ClusterModeChangeResponse

#### Examples

**Restore from a backup:**

```python
def restore_example() -> None:
    client = CamundaClient()

    # The cluster must be in recovery mode before a restore is accepted. Provide
    # either a list of backup IDs (one per partition) or a time range (from/to)
    # that selects the backups to restore, but not both.
    result = client.restore(
        data=RestoreRequest(backup_ids=[100, 101]),
    )

    print(f"Cluster change {result.change_id}:")
    for operation in result.planned_changes:
        suffix = f" -> {operation.mode}" if operation.mode else ""
        print(f"  {operation.operation}{suffix}")
```

### resume_batch_operation()

```python
def resume_batch_operation(batch_operation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resume Batch operation

> Resumes a suspended batch operation.
>
> This is done asynchronously, the progress can be tracked using the batch operation status endpoint
> (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter             | Type             | Description                                                             |
| --------------------- | ---------------- | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`            | System-generated key for an batch operation. Example: 2251799813684321. |
| `data`                | `Any` \| `Unset` |                                                                         |
| `kwargs`              | `Any`            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The batch operation was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Resume a batch operation:**

```python
def resume_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    client.resume_batch_operation(
        batch_operation_key=batch_operation_key,
    )
```

### resume_process_instance()

```python
def resume_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Resume process instance

> Resumes a suspended process instance, returning it to the ACTIVE state and continuing processing.
>
> Only process instances in the SUSPENDED state can be resumed.

**Parameters:**

| Parameter              | Type                                                | Description                                                             |
| ---------------------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                               | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `None` \| `ResumeProcessInstanceRequest` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                               |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance is not in the SUSPENDED state and cannot be resumed. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Resume a process instance:**

```python
def resume_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.resume_process_instance(
        process_instance_key=process_instance_key,
    )
```

### resume_process_instances_batch_operation()

```python
def resume_process_instances_batch_operation(*, data, **kwargs)
```

Resume process instances (batch)

> Resumes multiple suspended process instances.
>
> Since only SUSPENDED root instances can be resumed, any given filters for state and
> parentProcessInstanceKey are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                             | Description                                                                         |
| --------- | ------------------------------------------------ | ----------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceResumptionBatchOperationRequest` | The process instance filter that defines which process instances should be resumed. |
| `kwargs`  | `Any`                                            |                                                                                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Resume process instances in batch:**

```python
def resume_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.resume_process_instances_batch_operation(
        data=ProcessInstanceResumptionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### search_agent_instance_history()

```python
def search_agent_instance_history(agent_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search agent instance history

> Searches the conversation history of an agent instance. Committed items
> are returned by default.

**Parameters:**

| Parameter            | Type                                         | Description                                                            |
| -------------------- | -------------------------------------------- | ---------------------------------------------------------------------- |
| `agent_instance_key` | `str`                                        | System-generated key for an agent instance. Example: 4503599627370496. |
| `data`               | `AgentInstanceHistorySearchQuery` \| `Unset` | Agent instance history search request.                                 |
| `consistency`        | `ConsistencyOptions` \| `None`               |                                                                        |
| `kwargs`             | `Any`                                        |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceHistorySearchQueryResult
- **Return type:**
  AgentInstanceHistorySearchQueryResult

#### Examples

**Search agent instance history:**

```python
def search_agent_instance_history_example(agent_instance_key: AgentInstanceKey) -> None:
    client = CamundaClient()

    result = client.search_agent_instance_history(
        agent_instance_key=agent_instance_key,
        data=AgentInstanceHistorySearchQuery(),
    )

    print(f"Found {len(result.items)} history items")
```

### search_agent_instances()

```python
def search_agent_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search agent instances

> Search for agent instances based on given criteria.

**Parameters:**

| Parameter     | Type                                  | Description                    |
| ------------- | ------------------------------------- | ------------------------------ |
| `data`        | `AgentInstanceSearchQuery` \| `Unset` | Agent instance search request. |
| `consistency` | `ConsistencyOptions` \| `None`        |                                |
| `kwargs`      | `Any`                                 |                                |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AgentInstanceSearchQueryResult
- **Return type:**
  AgentInstanceSearchQueryResult

#### Examples

**Search agent instances:**

```python
def search_agent_instances_example() -> None:
    client = CamundaClient()

    result = client.search_agent_instances(data=AgentInstanceSearchQuery())

    if not isinstance(result.items, Unset):
        for agent_instance in result.items:
            print(f"Agent instance key: {agent_instance.agent_instance_key}")
```

### search_audit_logs()

```python
def search_audit_logs(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search audit logs

> Search for audit logs based on given criteria.

**Parameters:**

| Parameter     | Type                                    | Description               |
| ------------- | --------------------------------------- | ------------------------- |
| `data`        | `AuditLogSearchQueryRequest` \| `Unset` | Audit log search request. |
| `consistency` | `ConsistencyOptions` \| `None`          |                           |
| `kwargs`      | `Any`                                   |                           |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuditLogSearchQueryResult
- **Return type:**
  AuditLogSearchQueryResult

#### Examples

**Search audit logs:**

```python
def search_audit_logs_example() -> None:
    client = CamundaClient()

    result = client.search_audit_logs(
        data=AuditLogSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for log in result.items:
            print(f"Audit log: {log.audit_log_key}")
```

### search_authorizations()

```python
def search_authorizations(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search authorizations

> Search for authorizations based on given criteria.

**Parameters:**

| Parameter     | Type                                  | Description |
| ------------- | ------------------------------------- | ----------- |
| `data`        | `AuthorizationSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`        |             |
| `kwargs`      | `Any`                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuthorizationSearchResult
- **Return type:**
  AuthorizationSearchResult

#### Examples

**Search authorizations:**

```python
def search_authorizations_example() -> None:
    client = CamundaClient()

    result = client.search_authorizations(
        data=AuthorizationSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for auth in result.items:
            print(f"Authorization: {auth.authorization_key}")
```

### search_batch_operation_items()

```python
def search_batch_operation_items(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search batch operation items

> Search for batch operation items based on given criteria.

**Parameters:**

| Parameter     | Type                                       | Description                          |
| ------------- | ------------------------------------------ | ------------------------------------ |
| `data`        | `BatchOperationItemSearchQuery` \| `Unset` | Batch operation item search request. |
| `consistency` | `ConsistencyOptions` \| `None`             |                                      |
| `kwargs`      | `Any`                                      |                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationItemSearchQueryResult
- **Return type:**
  BatchOperationItemSearchQueryResult

#### Examples

**Search batch operation items:**

```python
def search_batch_operation_items_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    result = client.search_batch_operation_items(
        batch_operation_key=batch_operation_key,
        data=BatchOperationItemSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for item in result.items:
            print(f"Item: {item.item_key}")
```

### search_batch_operations()

```python
def search_batch_operations(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search batch operations

> Search for batch operations based on given criteria.

**Parameters:**

| Parameter     | Type                                   | Description                     |
| ------------- | -------------------------------------- | ------------------------------- |
| `data`        | `BatchOperationSearchQuery` \| `Unset` | Batch operation search request. |
| `consistency` | `ConsistencyOptions` \| `None`         |                                 |
| `kwargs`      | `Any`                                  |                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationSearchQueryResult
- **Return type:**
  BatchOperationSearchQueryResult

#### Examples

**Search batch operations:**

```python
def search_batch_operations_example() -> None:
    client = CamundaClient()

    result = client.search_batch_operations(
        data=BatchOperationSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for op in result.items:
            print(f"Batch operation: {op.batch_operation_key}")
```

### search_clients_for_group()

```python
def search_clients_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group clients

> Search clients assigned to a group.

**Parameters:**

| Parameter     | Type                                       | Description                                             |
| ------------- | ------------------------------------------ | ------------------------------------------------------- |
| `group_id`    | `str`                                      | The unique identifier of a group. Example: engineering. |
| `data`        | `GroupClientSearchQueryRequest` \| `Unset` |                                                         |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                         |
| `kwargs`      | `Any`                                      |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupClientSearchResult
- **Return type:**
  GroupClientSearchResult

#### Examples

**Search clients in a group:**

```python
def search_clients_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_clients_for_group(
        group_id=group_id,
    )

    if not isinstance(result.items, Unset):
        for c in result.items:
            print(f"Client: {c.client_id}")
```

### search_clients_for_role()

```python
def search_clients_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role clients

> Search clients with assigned role.

**Parameters:**

| Parameter     | Type                                      | Description                                      |
| ------------- | ----------------------------------------- | ------------------------------------------------ |
| `role_id`     | `str`                                     | The unique identifier of a role. Example: admin. |
| `data`        | `RoleClientSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`            |                                                  |
| `kwargs`      | `Any`                                     |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleClientSearchResult
- **Return type:**
  RoleClientSearchResult

#### Examples

**Search clients for a role:**

```python
def search_clients_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_clients_for_role(
        role_id=role_id,
    )

    if not isinstance(result.items, Unset):
        for c in result.items:
            print(f"Client: {c.client_id}")
```

### search_clients_for_tenant()

```python
def search_clients_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search clients for tenant

> Retrieves a filtered and sorted list of clients for a specified tenant.

**Parameters:**

| Parameter     | Type                                        | Description                                                     |
| ------------- | ------------------------------------------- | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                       | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `TenantClientSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`              |                                                                 |
| `kwargs`      | `Any`                                       |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantClientSearchResult
- **Return type:**
  TenantClientSearchResult

#### Examples

**Search clients for a tenant:**

```python
def search_clients_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_clients_for_tenant(
        tenant_id=tenant_id,
    )

    if not isinstance(result.items, Unset):
        for c in result.items:
            print(f"Client: {c.client_id}")
```

### search_cluster_variables()

```python
def search_cluster_variables(*, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search for cluster variables based on given criteria. By default, long variable values in the
response are truncated.

**Parameters:**

| Parameter         | Type                                           | Description                            |
| ----------------- | ---------------------------------------------- | -------------------------------------- |
| `truncate_values` | `bool` \| `Unset`                              |                                        |
| `data`            | `ClusterVariableSearchQueryRequest` \| `Unset` | Cluster variable search query request. |
| `consistency`     | `ConsistencyOptions` \| `None`                 |                                        |
| `kwargs`          | `Any`                                          |                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableSearchQueryResult
- **Return type:**
  ClusterVariableSearchQueryResult

#### Examples

**Search cluster variables:**

```python
def search_cluster_variables_example() -> None:
    client = CamundaClient()

    result = client.search_cluster_variables(
        data=ClusterVariableSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_correlated_message_subscriptions()

```python
def search_correlated_message_subscriptions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search correlated message subscriptions

> Search correlated message subscriptions based on given criteria.

**Parameters:**

| Parameter     | Type                                                  | Description |
| ------------- | ----------------------------------------------------- | ----------- |
| `data`        | `CorrelatedMessageSubscriptionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`                        |             |
| `kwargs`      | `Any`                                                 |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  CorrelatedMessageSubscriptionSearchQueryResult
- **Return type:**
  CorrelatedMessageSubscriptionSearchQueryResult

#### Examples

**Search correlated message subscriptions:**

```python
def search_correlated_message_subscriptions_example() -> None:
    client = CamundaClient()

    result = client.search_correlated_message_subscriptions(
        data=CorrelatedMessageSubscriptionSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for sub in result.items:
            print(f"Correlated subscription: {sub.message_name}")
```

### search_decision_definitions()

```python
def search_decision_definitions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search decision definitions

> Search for decision definitions based on given criteria.

**Parameters:**

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `data`        | `DecisionDefinitionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`             |             |
| `kwargs`      | `Any`                                      |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionDefinitionSearchQueryResult
- **Return type:**
  DecisionDefinitionSearchQueryResult

#### Examples

**Search decision definitions:**

```python
def search_decision_definitions_example() -> None:
    client = CamundaClient()

    result = client.search_decision_definitions(
        data=DecisionDefinitionSearchQuery()
    )

    if not isinstance(result.items, Unset):
        for definition in result.items:
            print(f"Decision: {definition.decision_definition_id}")
```

### search_decision_instances()

```python
def search_decision_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search decision instances

> Search for decision instances based on given criteria.

**Parameters:**

| Parameter     | Type                                     | Description |
| ------------- | ---------------------------------------- | ----------- |
| `data`        | `DecisionInstanceSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`           |             |
| `kwargs`      | `Any`                                    |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionInstanceSearchQueryResult
- **Return type:**
  DecisionInstanceSearchQueryResult

#### Examples

**Search decision instances:**

```python
def search_decision_instances_example() -> None:
    client = CamundaClient()

    result = client.search_decision_instances(
        data=DecisionInstanceSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for di in result.items:
            print(f"Decision instance: {di.decision_definition_id}")
```

### search_decision_requirements()

```python
def search_decision_requirements(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search decision requirements

> Search for decision requirements based on given criteria.

**Parameters:**

| Parameter     | Type                                         | Description |
| ------------- | -------------------------------------------- | ----------- |
| `data`        | `DecisionRequirementsSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`               |             |
| `kwargs`      | `Any`                                        |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  DecisionRequirementsSearchQueryResult
- **Return type:**
  DecisionRequirementsSearchQueryResult

#### Examples

**Search decision requirements:**

```python
def search_decision_requirements_example() -> None:
    client = CamundaClient()

    result = client.search_decision_requirements(
        data=DecisionRequirementsSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for drd in result.items:
            print(f"DRD: {drd.decision_requirements_name}")
```

### search_element_instance_incidents()

```python
def search_element_instance_incidents(element_instance_key, *, data, consistency=None, **kwargs)
```

Search for incidents of a specific element instance

> Search for incidents caused by the specified element instance, including incidents of any child
> instances created from this element instance.
>
> Although the elementInstanceKey is provided as a path parameter to indicate the root element
> instance,
> you may also include an elementInstanceKey within the filter object to narrow results to specific
> child element instances. This is useful, for example, if you want to isolate incidents associated
> with
> nested or subordinate elements within the given element instance while excluding incidents directly
> tied
> to the root element itself.

**Parameters:**

| Parameter              | Type                           | Description                                                             |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------- |
| `element_instance_key` | `str`                          | System-generated key for a element instance. Example: 2251799813686789. |
| `data`                 | `IncidentSearchQuery`          |                                                                         |
| `consistency`          | `ConsistencyOptions` \| `None` |                                                                         |
| `kwargs`               | `Any`                          |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The element instance with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentSearchQueryResult
- **Return type:**
  IncidentSearchQueryResult

#### Examples

**Search element instance incidents:**

```python
def search_element_instance_incidents_example(
    element_instance_key: ElementInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.search_element_instance_incidents(
        element_instance_key=element_instance_key,
        data=IncidentSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for incident in result.items:
            print(f"Incident: {incident.incident_key}")
```

### search_element_instance_wait_states()

```python
def search_element_instance_wait_states(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search element instance wait states

> Returns the wait states for element instances matching the given filter.

**Parameters:**

| Parameter     | Type                                       | Description                          |
| ------------- | ------------------------------------------ | ------------------------------------ |
| `data`        | `ElementInstanceWaitStateQuery` \| `Unset` | Element instance inspection request. |
| `consistency` | `ConsistencyOptions` \| `None`             |                                      |
| `kwargs`      | `Any`                                      |                                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ElementInstanceWaitStateQueryResult
- **Return type:**
  ElementInstanceWaitStateQueryResult

#### Examples

**Search element instance wait states:**

```python
def search_element_instance_wait_states_example() -> None:
    client = CamundaClient()

    result = client.search_element_instance_wait_states(
        data=ElementInstanceWaitStateQuery(),
    )

    for wait_state in result.items:
        details = wait_state.details
        if isinstance(details, JobWaitStateDetails):
            info = f"waiting on job '{details.job_type}'"
        elif isinstance(details, MessageWaitStateDetails):
            info = f"waiting for message '{details.message_name}'"
        else:
            info = f"waiting ({details.wait_state_type})"
        print(
            f"Element {wait_state.element_id} "
            f"(instance {wait_state.element_instance_key}) {info}"
        )
```

### search_element_instances()

```python
def search_element_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search element instances

> Search for element instances based on given criteria.

**Parameters:**

| Parameter     | Type                                    | Description                      |
| ------------- | --------------------------------------- | -------------------------------- |
| `data`        | `ElementInstanceSearchQuery` \| `Unset` | Element instance search request. |
| `consistency` | `ConsistencyOptions` \| `None`          |                                  |
| `kwargs`      | `Any`                                   |                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ElementInstanceSearchQueryResult
- **Return type:**
  ElementInstanceSearchQueryResult

#### Examples

**Search element instances:**

```python
def search_element_instances_example() -> None:
    client = CamundaClient()

    result = client.search_element_instances(
        data=ElementInstanceSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for ei in result.items:
            print(f"Element instance: {ei.element_instance_key}")
```

### search_global_task_listeners()

```python
def search_global_task_listeners(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search global user task listeners

> Search for global user task listeners based on given criteria.

**Parameters:**

| Parameter     | Type                                              | Description                           |
| ------------- | ------------------------------------------------- | ------------------------------------- |
| `data`        | `GlobalTaskListenerSearchQueryRequest` \| `Unset` | Global listener search query request. |
| `consistency` | `ConsistencyOptions` \| `None`                    |                                       |
| `kwargs`      | `Any`                                             |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerSearchQueryResult
- **Return type:**
  GlobalTaskListenerSearchQueryResult

#### Examples

**Search global task listeners:**

```python
def search_global_task_listeners_example() -> None:
    client = CamundaClient()

    result = client.search_global_task_listeners(
        data=GlobalTaskListenerSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for listener in result.items:
            print(f"Listener: {listener.id}")
```

### search_group_ids_for_tenant()

```python
def search_group_ids_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search groups for tenant

> Retrieves a filtered and sorted list of groups for a specified tenant.

**Parameters:**

| Parameter     | Type                                       | Description                                                     |
| ------------- | ------------------------------------------ | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                      | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `TenantGroupSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                                 |
| `kwargs`      | `Any`                                      |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantGroupSearchResult
- **Return type:**
  TenantGroupSearchResult

#### Examples

**Search groups for a tenant:**

```python
def search_group_ids_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_group_ids_for_tenant(
        tenant_id=tenant_id,
        data=TenantGroupSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for group in result.items:
            print(f"Group: {group.group_id}")
```

### search_groups()

```python
def search_groups(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search groups

> Search for groups based on given criteria.

**Parameters:**

| Parameter     | Type                                 | Description           |
| ------------- | ------------------------------------ | --------------------- |
| `data`        | `GroupSearchQueryRequest` \| `Unset` | Group search request. |
| `consistency` | `ConsistencyOptions` \| `None`       |                       |
| `kwargs`      | `Any`                                |                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupSearchQueryResult
- **Return type:**
  GroupSearchQueryResult

#### Examples

**Search groups:**

```python
def search_groups_example() -> None:
    client = CamundaClient()

    result = client.search_groups(
        data=GroupSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for group in result.items:
            print(f"Group: {group.name}")
```

### search_groups_for_role()

```python
def search_groups_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role groups

> Search groups with assigned role.

**Parameters:**

| Parameter     | Type                                     | Description                                      |
| ------------- | ---------------------------------------- | ------------------------------------------------ |
| `role_id`     | `str`                                    | The unique identifier of a role. Example: admin. |
| `data`        | `RoleGroupSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`           |                                                  |
| `kwargs`      | `Any`                                    |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleGroupSearchResult
- **Return type:**
  RoleGroupSearchResult

#### Examples

**Search groups for a role:**

```python
def search_groups_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_groups_for_role(
        role_id=role_id,
        data=RoleGroupSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for group in result.items:
            print(f"Group: {group.group_id}")
```

### search_incidents()

```python
def search_incidents(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search incidents

> Search for incidents based on given criteria.

**Parameters:**

| Parameter     | Type                             | Description |
| ------------- | -------------------------------- | ----------- |
| `data`        | `IncidentSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`   |             |
| `kwargs`      | `Any`                            |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentSearchQueryResult
- **Return type:**
  IncidentSearchQueryResult

#### Examples

**Search incidents:**

```python
def search_incidents_example() -> None:
    client = CamundaClient()

    result = client.search_incidents(
        data=IncidentSearchQuery()
    )

    if not isinstance(result.items, Unset):
        for incident in result.items:
            print(f"Incident key: {incident.incident_key}")
```

### search_jobs()

```python
def search_jobs(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search jobs

> Search for jobs based on given criteria.

**Parameters:**

| Parameter     | Type                           | Description         |
| ------------- | ------------------------------ | ------------------- |
| `data`        | `JobSearchQuery` \| `Unset`    | Job search request. |
| `consistency` | `ConsistencyOptions` \| `None` |                     |
| `kwargs`      | `Any`                          |                     |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  JobSearchQueryResult
- **Return type:**
  JobSearchQueryResult

#### Examples

**Search jobs:**

```python
def search_jobs_example() -> None:
    client = CamundaClient()

    result = client.search_jobs(
        data=JobSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for job in result.items:
            print(f"Job: {job.job_key}")
```

### search_mapping_rule()

```python
def search_mapping_rule(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search mapping rules

> Search for mapping rules based on given criteria.

**Parameters:**

| Parameter     | Type                                       | Description |
| ------------- | ------------------------------------------ | ----------- |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`             |             |
| `kwargs`      | `Any`                                      |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleSearchQueryResult
- **Return type:**
  MappingRuleSearchQueryResult

#### Examples

**Search mapping rules:**

```python
def search_mapping_rule_example() -> None:
    client = CamundaClient()

    result = client.search_mapping_rule(
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.name}")
```

### search_mapping_rules_for_group()

```python
def search_mapping_rules_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group mapping rules

> Search mapping rules assigned to a group.

**Parameters:**

| Parameter     | Type                                       | Description                                             |
| ------------- | ------------------------------------------ | ------------------------------------------------------- |
| `group_id`    | `str`                                      | The unique identifier of a group. Example: engineering. |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |                                                         |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                         |
| `kwargs`      | `Any`                                      |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupMappingRuleSearchResult
- **Return type:**
  GroupMappingRuleSearchResult

#### Examples

**Search mapping rules for a group:**

```python
def search_mapping_rules_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_mapping_rules_for_group(
        group_id=group_id,
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.mapping_rule_id}")
```

### search_mapping_rules_for_role()

```python
def search_mapping_rules_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role mapping rules

> Search mapping rules with assigned role.

**Parameters:**

| Parameter     | Type                                       | Description                                      |
| ------------- | ------------------------------------------ | ------------------------------------------------ |
| `role_id`     | `str`                                      | The unique identifier of a role. Example: admin. |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                  |
| `kwargs`      | `Any`                                      |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleMappingRuleSearchResult
- **Return type:**
  RoleMappingRuleSearchResult

#### Examples

**Search mapping rules for a role:**

```python
def search_mapping_rules_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_mapping_rules_for_role(
        role_id=role_id,
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.mapping_rule_id}")
```

### search_mapping_rules_for_tenant()

```python
def search_mapping_rules_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search mapping rules for tenant

> Retrieves a filtered and sorted list of MappingRules for a specified tenant.

**Parameters:**

| Parameter     | Type                                       | Description                                                     |
| ------------- | ------------------------------------------ | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                      | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `MappingRuleSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`             |                                                                 |
| `kwargs`      | `Any`                                      |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantMappingRuleSearchResult
- **Return type:**
  TenantMappingRuleSearchResult

#### Examples

**Search mapping rules for a tenant:**

```python
def search_mapping_rules_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_mapping_rules_for_tenant(
        tenant_id=tenant_id,
        data=MappingRuleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for rule in result.items:
            print(f"Mapping rule: {rule.mapping_rule_id}")
```

### search_message_subscriptions()

```python
def search_message_subscriptions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search message subscriptions

> Search for message subscriptions based on given criteria.
>
> By default, both start and intermediate event subscriptions are returned. Use the
> messageSubscriptionType filter to restrict results to a single type.
>
> **Version notes:**

- Start event subscriptions are only captured for deployments made with 8.10 or later.
- The messageSubscriptionType field is only populated for data created

> with Camunda 8.10 or later. For pre-8.10 data, intermediate event entries have no
> messageSubscriptionType value stored. For convenience, the API returns PROCESS_EVENT
> as a default for such search results, though.

- Searching for intermediate event subscriptions **including legacy data** can be achieved
  by filtering for messageSubscriptionType not matching START_EVENT.

**Parameters:**

| Parameter     | Type                                        | Description |
| ------------- | ------------------------------------------- | ----------- |
| `data`        | `MessageSubscriptionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`              |             |
| `kwargs`      | `Any`                                       |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MessageSubscriptionSearchQueryResult
- **Return type:**
  MessageSubscriptionSearchQueryResult

#### Examples

**Search message subscriptions:**

```python
def search_message_subscriptions_example() -> None:
    client = CamundaClient()

    result = client.search_message_subscriptions(
        data=MessageSubscriptionSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for sub in result.items:
            print(f"Subscription: {sub.message_name}")
```

### search_process_definition_variable_names()

```python
def search_process_definition_variable_names(process_definition_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search process definition variable names

> Search for distinct variable names defined on a process definition, optionally narrowed by the name
> filter.

**Parameters:**

| Parameter                | Type                                                  | Description                                                                        |
| ------------------------ | ----------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `process_definition_key` | `str`                                                 | System-generated key for a deployed process definition. Example: 2251799813686749. |
| `data`                   | `ProcessDefinitionVariableNameSearchQuery` \| `Unset` | Process definition variable name search query request.                             |
| `consistency`            | `ConsistencyOptions` \| `None`                        |                                                                                    |
| `kwargs`                 | `Any`                                                 |                                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionVariableNameSearchQueryResult
- **Return type:**
  ProcessDefinitionVariableNameSearchQueryResult

#### Examples

**Search process definition variable names:**

```python
def search_process_definition_variable_names_example(
    process_definition_key: ProcessDefinitionKey,
) -> None:
    client = CamundaClient()

    result = client.search_process_definition_variable_names(
        process_definition_key=process_definition_key,
        data=ProcessDefinitionVariableNameSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for variable in result.items:
            print(f"Variable name: {variable.name}")
```

### search_process_definitions()

```python
def search_process_definitions(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search process definitions

> Search for process definitions based on given criteria.

**Parameters:**

| Parameter     | Type                                      | Description |
| ------------- | ----------------------------------------- | ----------- |
| `data`        | `ProcessDefinitionSearchQuery` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`            |             |
| `kwargs`      | `Any`                                     |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessDefinitionSearchQueryResult
- **Return type:**
  ProcessDefinitionSearchQueryResult

#### Examples

**Search process definitions:**

```python
def search_process_definitions_example() -> None:
    client = CamundaClient()

    result = client.search_process_definitions(
        data=ProcessDefinitionSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for pd in result.items:
            print(f"Process definition: {pd.name}")
```

### search_process_instance_incidents()

```python
def search_process_instance_incidents(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search related incidents

> Search for incidents caused by the process instance or any of its called process or decision
> instances.
>
> Although the processInstanceKey is provided as a path parameter to indicate the root process
> instance,
> you may also include a processInstanceKey within the filter object to narrow results to specific
> child process instances. This is useful, for example, if you want to isolate incidents associated
> with
> subprocesses or called processes under the root instance while excluding incidents directly tied to
> the root.

**Parameters:**

| Parameter              | Type                             | Description                                                             |
| ---------------------- | -------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                            | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `IncidentSearchQuery` \| `Unset` |                                                                         |
| `consistency`          | `ConsistencyOptions` \| `None`   |                                                                         |
| `kwargs`               | `Any`                            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The process instance with the given key was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  IncidentSearchQueryResult
- **Return type:**
  IncidentSearchQueryResult

#### Examples

**Search process instance incidents:**

```python
def search_process_instance_incidents_example(
    process_instance_key: ProcessInstanceKey,
) -> None:
    client = CamundaClient()

    result = client.search_process_instance_incidents(
        process_instance_key=process_instance_key,
        data=IncidentSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for incident in result.items:
            print(f"Incident: {incident.incident_key}")
```

### search_process_instances()

```python
def search_process_instances(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search process instances

> Search for process instances based on given criteria.

**Parameters:**

| Parameter     | Type                                    | Description                      |
| ------------- | --------------------------------------- | -------------------------------- |
| `data`        | `ProcessInstanceSearchQuery` \| `Unset` | Process instance search request. |
| `consistency` | `ConsistencyOptions` \| `None`          |                                  |
| `kwargs`      | `Any`                                   |                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ProcessInstanceSearchQueryResult
- **Return type:**
  ProcessInstanceSearchQueryResult

#### Examples

**Search process instances:**

```python
def search_process_instances_example() -> None:
    client = CamundaClient()

    result = client.search_process_instances(
        data=ProcessInstanceSearchQuery(
            filter_=ProcessInstanceSearchQueryFilter(
                process_definition_id="order-process",
            ),
            sort=[
                ProcessInstanceSearchQuerySortRequest(
                    field=ProcessInstanceSearchQuerySortRequestField.STARTDATE,
                    order=SortOrderEnum.DESC,
                )
            ],
            page=LimitBasedPagination(limit=10),
        )
    )

    for instance in result.items:
        print(f"{instance.process_instance_key}: {instance.state}")
    print(f"Total: {result.page.total_items}")
```

### search_resources()

```python
def search_resources(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search resources

> Search for deployed resources based on given criteria.

:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective search APIs.
:::

- **data**: :type data: ResourceSearchQuery | Unset

````

* **Raises:**
  * **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  * **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  * **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  * **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  * **errors.UnexpectedStatus** – If the response status code is not documented.
  * **httpx.TimeoutException** – If the request takes longer than Client.timeout.
* **Returns:**
  ResourceSearchQueryResult
**Parameters:**

| Parameter | Type | Description |
| --- | --- | --- |
| `data` | `ResourceSearchQuery` \| `Unset` |  |
| `consistency` | `ConsistencyOptions` \| `None` |  |
| `kwargs` | `Any` |  |

* **Return type:**
  ResourceSearchQueryResult

#### Examples

**Search resources:**

```python
def search_resources_example() -> None:
    client = CamundaClient()

    result = client.search_resources(
        data=ResourceSearchQuery(),
    )

    if not isinstance(result.items, Unset):
        for resource in result.items:
            print(f"Resource: {resource.resource_name}")
````

### search_roles()

```python
def search_roles(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search roles

> Search for roles based on given criteria.

**Parameters:**

| Parameter     | Type                                | Description          |
| ------------- | ----------------------------------- | -------------------- |
| `data`        | `RoleSearchQueryRequest` \| `Unset` | Role search request. |
| `consistency` | `ConsistencyOptions` \| `None`      |                      |
| `kwargs`      | `Any`                               |                      |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleSearchQueryResult
- **Return type:**
  RoleSearchQueryResult

#### Examples

**Search roles:**

```python
def search_roles_example() -> None:
    client = CamundaClient()

    result = client.search_roles(
        data=RoleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for role in result.items:
            print(f"Role: {role.name}")
```

### search_roles_for_group()

```python
def search_roles_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group roles

> Search roles assigned to a group.

**Parameters:**

| Parameter     | Type                                | Description                                             |
| ------------- | ----------------------------------- | ------------------------------------------------------- |
| `group_id`    | `str`                               | The unique identifier of a group. Example: engineering. |
| `data`        | `RoleSearchQueryRequest` \| `Unset` | Role search request.                                    |
| `consistency` | `ConsistencyOptions` \| `None`      |                                                         |
| `kwargs`      | `Any`                               |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupRoleSearchResult
- **Return type:**
  GroupRoleSearchResult

#### Examples

**Search roles for a group:**

```python
def search_roles_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_roles_for_group(
        group_id=group_id,
        data=RoleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for role in result.items:
            print(f"Role: {role.name}")
```

### search_roles_for_tenant()

```python
def search_roles_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search roles for tenant

> Retrieves a filtered and sorted list of roles for a specified tenant.

**Parameters:**

| Parameter     | Type                                | Description                                                     |
| ------------- | ----------------------------------- | --------------------------------------------------------------- |
| `tenant_id`   | `str`                               | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `RoleSearchQueryRequest` \| `Unset` | Role search request.                                            |
| `consistency` | `ConsistencyOptions` \| `None`      |                                                                 |
| `kwargs`      | `Any`                               |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantRoleSearchResult
- **Return type:**
  TenantRoleSearchResult

#### Examples

**Search roles for a tenant:**

```python
def search_roles_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_roles_for_tenant(
        tenant_id=tenant_id,
        data=RoleSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for role in result.items:
            print(f"Role: {role.name}")
```

### search_tenants()

```python
def search_tenants(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search tenants

> Retrieves a filtered and sorted list of tenants.

**Parameters:**

| Parameter     | Type                                  | Description           |
| ------------- | ------------------------------------- | --------------------- |
| `data`        | `TenantSearchQueryRequest` \| `Unset` | Tenant search request |
| `consistency` | `ConsistencyOptions` \| `None`        |                       |
| `kwargs`      | `Any`                                 |                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantSearchQueryResult
- **Return type:**
  TenantSearchQueryResult

#### Examples

**Search tenants:**

```python
def search_tenants_example() -> None:
    client = CamundaClient()

    result = client.search_tenants(
        data=TenantSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for tenant in result.items:
            print(f"Tenant: {tenant.name}")
```

### search_user_task_audit_logs()

```python
def search_user_task_audit_logs(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user task audit logs

> Search for user task audit logs based on given criteria.

**Parameters:**

| Parameter       | Type                                            | Description                           |
| --------------- | ----------------------------------------------- | ------------------------------------- |
| `user_task_key` | `str`                                           | System-generated key for a user task. |
| `data`          | `UserTaskAuditLogSearchQueryRequest` \| `Unset` | User task search query request.       |
| `consistency`   | `ConsistencyOptions` \| `None`                  |                                       |
| `kwargs`        | `Any`                                           |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  AuditLogSearchQueryResult
- **Return type:**
  AuditLogSearchQueryResult

#### Examples

**Search user task audit logs:**

```python
def search_user_task_audit_logs_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.search_user_task_audit_logs(
        user_task_key=user_task_key,
        data=UserTaskAuditLogSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for log in result.items:
            print(f"Audit log: {log.audit_log_key}")
```

### search_user_task_effective_variables()

```python
def search_user_task_effective_variables(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user task effective variables

> Search for the effective variables of a user task. This endpoint returns deduplicated
> variables where each variable name appears at most once. When the same variable name exists
> at multiple scope levels in the scope hierarchy, the value from the innermost scope (closest
> to the user task) takes precedence. This is useful for retrieving the actual runtime state
> of variables as seen by the user task. By default, long variable values in the response are
> truncated.

**Parameters:**

| Parameter         | Type                                                     | Description                                                                           |
| ----------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| `user_task_key`   | `str`                                                    | System-generated key for a user task.                                                 |
| `truncate_values` | `bool` \| `Unset`                                        |                                                                                       |
| `data`            | `UserTaskEffectiveVariableSearchQueryRequest` \| `Unset` | User task effective variable search query request. Uses offset-based pagination only. |
| `consistency`     | `ConsistencyOptions` \| `None`                           |                                                                                       |
| `kwargs`          | `Any`                                                    |                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableSearchQueryResult
- **Return type:**
  VariableSearchQueryResult

#### Examples

**Search user task effective variables:**

```python
def search_user_task_effective_variables_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.search_user_task_effective_variables(
        user_task_key=user_task_key,
    )

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_user_task_variables()

```python
def search_user_task_variables(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user task variables

> Search for user task variables based on given criteria. This endpoint returns all variable
> documents visible from the user task’s scope, including variables from parent scopes in the
> scope hierarchy. If the same variable name exists at multiple scope levels, each scope’s
> variable is returned as a separate result. Use the
> /user-tasks/{userTaskKey}/effective-variables/search endpoint to get deduplicated variables
> where the innermost scope takes precedence. By default, long variable values in the response
> are truncated.

**Parameters:**

| Parameter         | Type                                            | Description                           |
| ----------------- | ----------------------------------------------- | ------------------------------------- |
| `user_task_key`   | `str`                                           | System-generated key for a user task. |
| `truncate_values` | `bool` \| `Unset`                               |                                       |
| `data`            | `UserTaskVariableSearchQueryRequest` \| `Unset` | User task search query request.       |
| `consistency`     | `ConsistencyOptions` \| `None`                  |                                       |
| `kwargs`          | `Any`                                           |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableSearchQueryResult
- **Return type:**
  VariableSearchQueryResult

#### Examples

**Search user task variables:**

```python
def search_user_task_variables_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    result = client.search_user_task_variables(
        user_task_key=user_task_key,
    )

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_user_tasks()

```python
def search_user_tasks(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search user tasks

> Search for user tasks based on given criteria.

**Parameters:**

| Parameter     | Type                             | Description                     |
| ------------- | -------------------------------- | ------------------------------- |
| `data`        | `UserTaskSearchQuery` \| `Unset` | User task search query request. |
| `consistency` | `ConsistencyOptions` \| `None`   |                                 |
| `kwargs`      | `Any`                            |                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserTaskSearchQueryResult
- **Return type:**
  UserTaskSearchQueryResult

#### Examples

**Search user tasks:**

```python
def search_user_tasks_example() -> None:
    client = CamundaClient()

    result = client.search_user_tasks(
        data=UserTaskSearchQuery()
    )

    if not isinstance(result.items, Unset):
        for task in result.items:
            print(f"Task: {task.user_task_key}")
```

### search_users()

```python
def search_users(*, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search users

> Search for users based on given criteria.

**Parameters:**

| Parameter     | Type                                | Description |
| ------------- | ----------------------------------- | ----------- |
| `data`        | `UserSearchQueryRequest` \| `Unset` |             |
| `consistency` | `ConsistencyOptions` \| `None`      |             |
| `kwargs`      | `Any`                               |             |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserSearchResult
- **Return type:**
  UserSearchResult

#### Examples

**Search users:**

```python
def search_users_example() -> None:
    client = CamundaClient()

    result = client.search_users(
        data=UserSearchQueryRequest(),
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_users_for_group()

```python
def search_users_for_group(group_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search group users

> Search users assigned to a group.

**Parameters:**

| Parameter     | Type                                     | Description                                             |
| ------------- | ---------------------------------------- | ------------------------------------------------------- |
| `group_id`    | `str`                                    | The unique identifier of a group. Example: engineering. |
| `data`        | `GroupUserSearchQueryRequest` \| `Unset` |                                                         |
| `consistency` | `ConsistencyOptions` \| `None`           |                                                         |
| `kwargs`      | `Any`                                    |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupUserSearchResult
- **Return type:**
  GroupUserSearchResult

#### Examples

**Search users in a group:**

```python
def search_users_for_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    result = client.search_users_for_group(
        group_id=group_id,
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_users_for_role()

```python
def search_users_for_role(role_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search role users

> Search users with assigned role.

**Parameters:**

| Parameter     | Type                                    | Description                                      |
| ------------- | --------------------------------------- | ------------------------------------------------ |
| `role_id`     | `str`                                   | The unique identifier of a role. Example: admin. |
| `data`        | `RoleUserSearchQueryRequest` \| `Unset` |                                                  |
| `consistency` | `ConsistencyOptions` \| `None`          |                                                  |
| `kwargs`      | `Any`                                   |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleUserSearchResult
- **Return type:**
  RoleUserSearchResult

#### Examples

**Search users for a role:**

```python
def search_users_for_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    result = client.search_users_for_role(
        role_id=role_id,
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_users_for_tenant()

```python
def search_users_for_tenant(tenant_id, *, data=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search users for tenant

> Retrieves a filtered and sorted list of users for a specified tenant.

**Parameters:**

| Parameter     | Type                                      | Description                                                     |
| ------------- | ----------------------------------------- | --------------------------------------------------------------- |
| `tenant_id`   | `str`                                     | The unique identifier of the tenant. Example: customer-service. |
| `data`        | `TenantUserSearchQueryRequest` \| `Unset` |                                                                 |
| `consistency` | `ConsistencyOptions` \| `None`            |                                                                 |
| `kwargs`      | `Any`                                     |                                                                 |

- **Raises:**
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantUserSearchResult
- **Return type:**
  TenantUserSearchResult

#### Examples

**Search users for a tenant:**

```python
def search_users_for_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    result = client.search_users_for_tenant(
        tenant_id=tenant_id,
    )

    if not isinstance(result.items, Unset):
        for user in result.items:
            print(f"User: {user.username}")
```

### search_variables()

```python
def search_variables(*, data=<camunda_orchestration_sdk.types.Unset object>, truncate_values=<camunda_orchestration_sdk.types.Unset object>, consistency=None, **kwargs)
```

Search variables

> Search for variables based on given criteria.
>
> This endpoint returns variables that exist directly at the specified scopes - it does not
> include variables from parent scopes that would be visible through the scope hierarchy.
>
> Variables can be process-level (scoped to the process instance) or local (scoped to specific
> BPMN elements like tasks, subprocesses, etc.).
>
> By default, long variable values in the response are truncated.

**Parameters:**

| Parameter         | Type                             | Description                    |
| ----------------- | -------------------------------- | ------------------------------ |
| `truncate_values` | `bool` \| `Unset`                |                                |
| `data`            | `VariableSearchQuery` \| `Unset` | Variable search query request. |
| `consistency`     | `ConsistencyOptions` \| `None`   |                                |
| `kwargs`          | `Any`                            |                                |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  VariableSearchQueryResult
- **Return type:**
  VariableSearchQueryResult

#### Examples

**Search variables:**

```python
def search_variables_example() -> None:
    client = CamundaClient()

    result = client.search_variables()

    if not isinstance(result.items, Unset):
        for var in result.items:
            print(f"Variable: {var.name}")
```

### search_variables_as_dto()

```python
def search_variables_as_dto(dto, *, process_instance_key, scope_key=None, tenant_id=None, page_size=100, consistency=None)
```

Fetch the variables declared by a Pydantic model for a process instance.

Derives a `name $in [...]` filter from the fields of `dto` (honouring
Pydantic aliases), so only the declared variables are fetched — memory is
bounded by the model shape, not by the total variable count. The result is
a `camunda_orchestration_sdk.runtime.typed_variables.VariableMap`,
which offers lenient access via `.get(name)` and strict, fully-typed
access via `.validate()` (which constructs `dto` and raises
`pydantic.ValidationError` on missing or invalid values).

**Parameters:**

| Parameter              | Type                           | Description                                                                                                                                                                                                                                                                                                                                                 |
| ---------------------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `dto`                  | type [ \_VarDtoT ]             | A `pydantic.BaseModel` subclass describing the variables of interest.                                                                                                                                                                                                                                                                                       |
| `process_instance_key` | `str`                          | The process instance whose variables to search.                                                                                                                                                                                                                                                                                                             |
| `scope_key`            | `str` \| `None`                | Optional scope key to disambiguate variables that exist at multiple scopes. Required when a variable name collides across scopes.                                                                                                                                                                                                                           |
| `tenant_id`            | `str` \| `None`                | Optional tenant identifier to filter by.                                                                                                                                                                                                                                                                                                                    |
| `page_size`            | `int`                          | Page size used while paginating to exhaustion. Defaults to 100.                                                                                                                                                                                                                                                                                             |
| `consistency`          | `ConsistencyOptions` \| `None` | Optional eventual-consistency budget. When supplied, the whole collection is re-read until every declared variable is visible or `wait_up_to_ms` expires (the best snapshot is returned on expiry). Variable indexes update asynchronously, so a freshly written variable may not be visible immediately; without this the variables are read exactly once. |

- **Returns:**
  The parsed variable map keyed by the declared field names.
- **Return type:**
  VariableMap
- **Raises:**
  - **TypeError** – If `dto` is not a pydantic `BaseModel` subclass.
  - **camunda_orchestration_sdk.runtime.typed_variables.VariableScopeCollisionError** – If a declared variable is found at more than one scope and no
    `scope_key` was supplied.
  - **camunda_orchestration_sdk.runtime.typed_variables.VariableDeserializationError** – If a returned variable value is present but not valid JSON.

### suspend_batch_operation()

```python
def suspend_batch_operation(batch_operation_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Suspend Batch operation

> Suspends a running batch operation.
>
> This is done asynchronously, the progress can be tracked using the batch operation status endpoint
> (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter             | Type             | Description                                                             |
| --------------------- | ---------------- | ----------------------------------------------------------------------- |
| `batch_operation_key` | `str`            | System-generated key for an batch operation. Example: 2251799813684321. |
| `data`                | `Any` \| `Unset` |                                                                         |
| `kwargs`              | `Any`            |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The batch operation was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Suspend a batch operation:**

```python
def suspend_batch_operation_example(batch_operation_key: BatchOperationKey) -> None:
    client = CamundaClient()

    client.suspend_batch_operation(
        batch_operation_key=batch_operation_key,
    )
```

### suspend_process_instance()

```python
def suspend_process_instance(process_instance_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Suspend process instance

> Suspends a running process instance, pausing further processing until it is resumed.
>
> Only process instances in the ACTIVE state can be suspended.

**Parameters:**

| Parameter              | Type                                                 | Description                                                             |
| ---------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------- |
| `process_instance_key` | `str`                                                | System-generated key for a process instance. Example: 2251799813690746. |
| `data`                 | `None` \| `SuspendProcessInstanceRequest` \| `Unset` |                                                                         |
| `kwargs`               | `Any`                                                |                                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The process instance is not found.
  - **errors.ConflictError** – If the response status code is 409. The process instance is not in the ACTIVE state and cannot be suspended. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Suspend a process instance:**

```python
def suspend_process_instance_example(process_instance_key: ProcessInstanceKey) -> None:
    client = CamundaClient()

    client.suspend_process_instance(
        process_instance_key=process_instance_key,
    )
```

### suspend_process_instances_batch_operation()

```python
def suspend_process_instances_batch_operation(*, data, **kwargs)
```

Suspend process instances (batch)

> Suspends multiple running process instances.
>
> Since only ACTIVE root instances can be suspended, any given filters for state and
> parentProcessInstanceKey are ignored and overridden during this batch operation.
> This is done asynchronously, the progress can be tracked using the batchOperationKey from the
> response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                                             | Description                                                                           |
| --------- | ------------------------------------------------ | ------------------------------------------------------------------------------------- |
| `data`    | `ProcessInstanceSuspensionBatchOperationRequest` | The process instance filter that defines which process instances should be suspended. |
| `kwargs`  | `Any`                                            |                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The process instance batch operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Suspend process instances in batch:**

```python
def suspend_process_instances_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.suspend_process_instances_batch_operation(
        data=ProcessInstanceSuspensionBatchOperationRequest(
            filter_=ProcessInstanceCancellationBatchOperationRequestFilter(),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### throw_job_error()

```python
def throw_job_error(job_key, *, data, **kwargs)
```

Throw error for job

> Reports a business error (i.e. non-technical) that occurs while processing a job.

**Parameters:**

| Parameter | Type              | Description                                                |
| --------- | ----------------- | ---------------------------------------------------------- |
| `job_key` | `str`             | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobErrorRequest` |                                                            |
| `kwargs`  | `Any`             |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the given key was not found or is not activated.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Throw a job error:**

```python
def throw_job_error_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.throw_job_error(
        job_key=job_key,
        data=JobErrorRequest(
            error_code="VALIDATION_ERROR",
            error_message="Input validation failed",
        ),
    )
```

### unassign_client_from_group()

```python
def unassign_client_from_group(group_id, client_id, **kwargs)
```

Unassign a client from a group

> Unassigns a client from a group.
>
> The client is removed as a group member, with associated authorizations, roles, and tenant
> assignments no longer applied.

**Parameters:**

| Parameter   | Type   | Description                                             |
| ----------- | ------ | ------------------------------------------------------- |
| `group_id`  | `str`  | The unique identifier of a group. Example: engineering. |
| `client_id` | str) – |                                                         |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found, or the client is not assigned to this group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a client from a group:**

```python
def unassign_client_from_group_example(group_id: GroupId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.unassign_client_from_group(
        group_id=group_id,
        client_id=client_id,
    )
```

### unassign_client_from_tenant()

```python
def unassign_client_from_tenant(tenant_id, client_id, **kwargs)
```

Unassign a client from a tenant

> Unassigns the client from the specified tenant.
>
> The client can no longer access tenant data.

**Parameters:**

| Parameter   | Type   | Description                                                     |
| ----------- | ------ | --------------------------------------------------------------- |
| `tenant_id` | `str`  | The unique identifier of the tenant. Example: customer-service. |
| `client_id` | str) – |                                                                 |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The tenant does not exist or the client was not assigned to it.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a client from a tenant:**

```python
def unassign_client_from_tenant_example(tenant_id: TenantId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.unassign_client_from_tenant(
        tenant_id=tenant_id,
        client_id=client_id,
    )
```

### unassign_group_from_tenant()

```python
def unassign_group_from_tenant(tenant_id, group_id, **kwargs)
```

Unassign a group from a tenant

> Unassigns a group from a specified tenant.
>
> Members of the group (users, clients) will no longer have access to the tenant’s data - except they
> are assigned directly to the tenant.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `group_id`  | `str` | The unique identifier of a group. Example: engineering.         |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or group was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a group from a tenant:**

```python
def unassign_group_from_tenant_example(tenant_id: TenantId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.unassign_group_from_tenant(
        tenant_id=tenant_id,
        group_id=group_id,
    )
```

### unassign_mapping_rule_from_group()

```python
def unassign_mapping_rule_from_group(group_id, mapping_rule_id, **kwargs)
```

Unassign a mapping rule from a group

> Unassigns a mapping rule from a group.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `group_id`        | `str` | The unique identifier of a group. Example: engineering.            |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or mapping rule with the given ID was not found, or the mapping rule is not assigned to this group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a mapping rule from a group:**

```python
def unassign_mapping_rule_from_group_example(group_id: GroupId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.unassign_mapping_rule_from_group(
        group_id=group_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### unassign_mapping_rule_from_tenant()

```python
def unassign_mapping_rule_from_tenant(tenant_id, mapping_rule_id, **kwargs)
```

Unassign a mapping rule from a tenant

> Unassigns a single mapping rule from a specified tenant without deleting the rule.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `tenant_id`       | `str` | The unique identifier of the tenant. Example: customer-service.    |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or mapping rule was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a mapping rule from a tenant:**

```python
def unassign_mapping_rule_from_tenant_example(tenant_id: TenantId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.unassign_mapping_rule_from_tenant(
        tenant_id=tenant_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### unassign_role_from_client()

```python
def unassign_role_from_client(role_id, client_id, **kwargs)
```

Unassign a role from a client

> Unassigns the specified role from the client. The client will no longer inherit the authorizations
> associated with this role.

**Parameters:**

| Parameter   | Type   | Description                                      |
| ----------- | ------ | ------------------------------------------------ |
| `role_id`   | `str`  | The unique identifier of a role. Example: admin. |
| `client_id` | str) – |                                                  |

    The unique identifier of an OAuth client.
    Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
    with OIDC by the external identity provider (e.g. EntraID, Keycloak,
    Okta). In Self-Managed with Basic authentication, machine-to-machine
    applications are modelled as users instead — see the user identifier.
    > Example: my-application.

- **kwargs** (_Any_)
- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or client with the given ID or username was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a client:**

```python
def unassign_role_from_client_example(role_id: RoleId, client_id: ClientId) -> None:
    client = CamundaClient()

    client.unassign_role_from_client(
        role_id=role_id,
        client_id=client_id,
    )
```

### unassign_role_from_group()

```python
def unassign_role_from_group(role_id, group_id, **kwargs)
```

Unassign a role from a group

> Unassigns the specified role from the group. All group members (user or client) no longer inherit
> the authorizations associated with this role.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `role_id`  | `str` | The unique identifier of a role. Example: admin.        |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a group:**

```python
def unassign_role_from_group_example(role_id: RoleId, group_id: GroupId) -> None:
    client = CamundaClient()

    client.unassign_role_from_group(
        role_id=role_id,
        group_id=group_id,
    )
```

### unassign_role_from_mapping_rule()

```python
def unassign_role_from_mapping_rule(role_id, mapping_rule_id, **kwargs)
```

Unassign a role from a mapping rule

> Unassigns a role from a mapping rule.

**Parameters:**

| Parameter         | Type  | Description                                                        |
| ----------------- | ----- | ------------------------------------------------------------------ |
| `role_id`         | `str` | The unique identifier of a role. Example: admin.                   |
| `mapping_rule_id` | `str` | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `kwargs`          | `Any` |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or mapping rule with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a mapping rule:**

```python
def unassign_role_from_mapping_rule_example(role_id: RoleId, mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.unassign_role_from_mapping_rule(
        role_id=role_id,
        mapping_rule_id=mapping_rule_id,
    )
```

### unassign_role_from_tenant()

```python
def unassign_role_from_tenant(tenant_id, role_id, **kwargs)
```

Unassign a role from a tenant

> Unassigns a role from a specified tenant.
>
> Users, Clients or Groups, that have the role assigned, will no longer have access to the
> tenant’s data - unless they are assigned directly to the tenant.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `role_id`   | `str` | The unique identifier of a role. Example: admin.                |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or role was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a tenant:**

```python
def unassign_role_from_tenant_example(tenant_id: TenantId, role_id: RoleId) -> None:
    client = CamundaClient()

    client.unassign_role_from_tenant(
        tenant_id=tenant_id,
        role_id=role_id,
    )
```

### unassign_role_from_user()

```python
def unassign_role_from_user(role_id, username, **kwargs)
```

Unassign a role from a user

> Unassigns a role from a user. The user will no longer inherit the authorizations associated with
> this role.

**Parameters:**

| Parameter  | Type  | Description                                      |
| ---------- | ----- | ------------------------------------------------ |
| `role_id`  | `str` | The unique identifier of a role. Example: admin. |
| `username` | `str` | The unique name of a user. Example: swillis.     |
| `kwargs`   | `Any` |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The role or user with the given ID or username was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a role from a user:**

```python
def unassign_role_from_user_example(role_id: RoleId, username: Username) -> None:
    client = CamundaClient()

    client.unassign_role_from_user(
        role_id=role_id,
        username=username,
    )
```

### unassign_user_from_group()

```python
def unassign_user_from_group(group_id, username, **kwargs)
```

Unassign a user from a group

> Unassigns a user from a group.
>
> The user is removed as a group member, with associated authorizations, roles, and tenant assignments
> no longer applied.

**Parameters:**

| Parameter  | Type  | Description                                             |
| ---------- | ----- | ------------------------------------------------------- |
| `group_id` | `str` | The unique identifier of a group. Example: engineering. |
| `username` | `str` | The unique name of a user. Example: swillis.            |
| `kwargs`   | `Any` |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The group or user with the given ID was not found, or the user is not assigned to this group.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a user from a group:**

```python
def unassign_user_from_group_example(group_id: GroupId, username: Username) -> None:
    client = CamundaClient()

    client.unassign_user_from_group(
        group_id=group_id,
        username=username,
    )
```

### unassign_user_from_tenant()

```python
def unassign_user_from_tenant(tenant_id, username, **kwargs)
```

Unassign a user from a tenant

> Unassigns the user from the specified tenant.
>
> The user can no longer access tenant data.

**Parameters:**

| Parameter   | Type  | Description                                                     |
| ----------- | ----- | --------------------------------------------------------------- |
| `tenant_id` | `str` | The unique identifier of the tenant. Example: customer-service. |
| `username`  | `str` | The unique name of a user. Example: swillis.                    |
| `kwargs`    | `Any` |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant or user was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a user from a tenant:**

```python
def unassign_user_from_tenant_example(tenant_id: TenantId, username: Username) -> None:
    client = CamundaClient()

    client.unassign_user_from_tenant(
        tenant_id=tenant_id,
        username=username,
    )
```

### unassign_user_task()

```python
def unassign_user_task(user_task_key, **kwargs)
```

Unassign user task

> Removes the assignee of a task with the given key. Unassignment waits for blocking task listeners on
> this lifecycle transition. If listener processing is delayed beyond the request timeout, this
> endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and
> inspect listener worker availability and logs when this repeats.

**Parameters:**

| Parameter       | Type  | Description                           |
| --------------- | ----- | ------------------------------------- |
| `user_task_key` | `str` | System-generated key for a user task. |
| `kwargs`        | `Any` |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Unassign a user task:**

```python
def unassign_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    client.unassign_user_task(user_task_key=user_task_key)
```

### update_agent_instance()

```python
def update_agent_instance(agent_instance_key, *, data, **kwargs)
```

Update agent instance

> Updates the mutable fields of an agent instance: status, metric counters, and
> tools. Metric values are treated as deltas and applied immediately to the
> aggregate counters. Tool updates replace the existing tool list.

**Parameters:**

| Parameter            | Type                         | Description                                                            |
| -------------------- | ---------------------------- | ---------------------------------------------------------------------- |
| `agent_instance_key` | `str`                        | System-generated key for an agent instance. Example: 4503599627370496. |
| `data`               | `AgentInstanceUpdateRequest` | Request to update the mutable state of an agent instance.              |
| `kwargs`             | `Any`                        |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The agent instance with the given key was not found. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update an agent instance:**

```python
def update_agent_instance_example(
    agent_instance_key: AgentInstanceKey,
    element_instance_key: ElementInstanceKey,
) -> None:
    client = CamundaClient()

    client.update_agent_instance(
        agent_instance_key=agent_instance_key,
        data=AgentInstanceUpdateRequest(
            element_instance_key=element_instance_key,
            status=AgentInstanceUpdateRequestStatus.THINKING,
        ),
    )
```

### update_authorization()

```python
def update_authorization(authorization_key, *, data, **kwargs)
```

Update authorization

> Update the authorization with the given key.

**Parameters:**

| Parameter           | Type                                                                 | Description                                                           |
| ------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `authorization_key` | `str`                                                                | System-generated key for an authorization. Example: 2251799813684332. |
| `data`              | `AuthorizationIdBasedRequest` \| `AuthorizationPropertyBasedRequest` |                                                                       |
| `kwargs`            | `Any`                                                                |                                                                       |

- **Raises:**
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The authorization with the authorizationKey was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update an authorization:**

```python
def update_authorization_example(authorization_key: AuthorizationKey) -> None:
    client = CamundaClient()

    client.update_authorization(
        authorization_key=authorization_key,
        data=AuthorizationIdBasedRequest(
            resource_type=AuthorizationIdBasedRequestResourceType.PROCESS_DEFINITION,
            permission_types=[
                AuthorizationIdBasedRequestPermissionTypesItem.READ,
                AuthorizationIdBasedRequestPermissionTypesItem.UPDATE,
                AuthorizationIdBasedRequestPermissionTypesItem.DELETE,
            ],
            resource_id="my-process",
            owner_type=OwnerTypeEnum.USER,
            owner_id="user@example.com",
        ),
    )
```

### update_global_cluster_variable()

```python
def update_global_cluster_variable(name, *, data, **kwargs)
```

Update a global-scoped cluster variable

> Updates the value of an existing global cluster variable.
>
> The variable must exist, otherwise a 404 error is returned.

**Parameters:**

| Parameter | Type                           | Description                                                                                                           |
| --------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `name`    | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `data`    | `UpdateClusterVariableRequest` |                                                                                                                       |
| `kwargs`  | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Update a global cluster variable:**

```python
def update_global_cluster_variable_example(name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.update_global_cluster_variable(
        name=name,
        data=UpdateClusterVariableRequest(
            value=UpdateClusterVariableRequestValue.from_dict({"key": "updated-value"}),
        ),
    )

    print(f"Updated variable: {result.name}")
```

### update_global_task_listener()

```python
def update_global_task_listener(id, *, data, **kwargs)
```

Update global user task listener

> Updates a global user task listener.

**Parameters:**

| Parameter | Type                              | Description                                                            |
| --------- | --------------------------------- | ---------------------------------------------------------------------- |
| `id`      | `str`                             | The user-defined id for the global listener Example: GlobalListener_1. |
| `data`    | `UpdateGlobalTaskListenerRequest` |                                                                        |
| `kwargs`  | `Any`                             |                                                                        |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The global user task listener was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GlobalTaskListenerResult
- **Return type:**
  GlobalTaskListenerResult

#### Examples

**Update a global task listener:**

```python
def update_global_task_listener_example(listener_id: GlobalListenerId) -> None:
    client = CamundaClient()

    result = client.update_global_task_listener(
        id=listener_id,
        data=UpdateGlobalTaskListenerRequest(
            event_types=[GlobalTaskListenerEventTypeEnum.COMPLETING],
            type_="updated-task-listener",
        ),
    )

    print(f"Updated listener: {result.id}")
```

### update_group()

```python
def update_group(group_id, *, data, **kwargs)
```

Update group

> Update a group with the given ID.

**Parameters:**

| Parameter  | Type                 | Description                                             |
| ---------- | -------------------- | ------------------------------------------------------- |
| `group_id` | `str`                | The unique identifier of a group. Example: engineering. |
| `data`     | `GroupUpdateRequest` |                                                         |
| `kwargs`   | `Any`                |                                                         |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The group with the given ID was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  GroupUpdateResult
- **Return type:**
  GroupUpdateResult

#### Examples

**Update a group:**

```python
def update_group_example(group_id: GroupId) -> None:
    client = CamundaClient()

    client.update_group(
        group_id=group_id,
        data=GroupUpdateRequest(name="engineering-team"),
    )
```

### update_job()

```python
def update_job(job_key, *, data, **kwargs)
```

Update job

> Update a job with the given key.

**Parameters:**

| Parameter | Type               | Description                                                |
| --------- | ------------------ | ---------------------------------------------------------- |
| `job_key` | `str`              | System-generated key for a job. Example: 2251799813653498. |
| `data`    | `JobUpdateRequest` |                                                            |
| `kwargs`  | `Any`              |                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The job with the jobKey is not found.
  - **errors.ConflictError** – If the response status code is 409. The job with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update a job:**

```python
def update_job_example(job_key: JobKey) -> None:
    client = CamundaClient()

    client.update_job(
        job_key=job_key,
        data=JobUpdateRequest(
            changeset=JobChangeset(
                retries=3,
            ),
        ),
    )
```

### update_jobs_batch_operation()

```python
def update_jobs_batch_operation(*, data, **kwargs)
```

Update jobs (batch)

> Creates a batch operation to update jobs matching the given filter. At least one changeset field
> must be non-null. This is done asynchronously; the progress can be tracked using the
> batchOperationKey from the response and the batch operation status endpoint (/batch-
> operations/{batchOperationKey}).

**Parameters:**

| Parameter | Type                    | Description                                                                                                                                                                                |
| --------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `data`    | `JobBatchUpdateRequest` | The filter and changeset for a batch job update operation. The filter defines which jobs are updated; the changeset defines what to update. At least one changeset field must be non-null. |
| `kwargs`  | `Any`                   |                                                                                                                                                                                            |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The job batch update operation failed. More details are provided in the response body.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  BatchOperationCreatedResult
- **Return type:**
  BatchOperationCreatedResult

#### Examples

**Update jobs in batch:**

```python
def update_jobs_batch_operation_example() -> None:
    client = CamundaClient()

    result = client.update_jobs_batch_operation(
        data=JobBatchUpdateRequest(
            filter_=JobBatchUpdateRequestFilter(
                type_="my-job-type",
            ),
            changeset=JobBatchUpdateRequestChangeset(
                retries=3,
            ),
        ),
    )

    print(f"Batch operation key: {result.batch_operation_key}")
```

### update_mapping_rule()

```python
def update_mapping_rule(mapping_rule_id, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Update mapping rule

> Update a mapping rule.

**Parameters:**

| Parameter         | Type                                  | Description                                                        |
| ----------------- | ------------------------------------- | ------------------------------------------------------------------ |
| `mapping_rule_id` | `str`                                 | The unique identifier of a mapping rule. Example: my-mapping-rule. |
| `data`            | `MappingRuleUpdateRequest` \| `Unset` |                                                                    |
| `kwargs`          | `Any`                                 |                                                                    |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. The request to update a mapping rule was denied. More details are provided in the response body.
  - **errors.NotFoundError** – If the response status code is 404. The request to update a mapping rule was denied.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  MappingRuleUpdateResult
- **Return type:**
  MappingRuleUpdateResult

#### Examples

**Update a mapping rule:**

```python
def update_mapping_rule_example(mapping_rule_id: MappingRuleId) -> None:
    client = CamundaClient()

    client.update_mapping_rule(
        mapping_rule_id=mapping_rule_id,
        data=MappingRuleUpdateRequest(
            claim_name="groups",
            claim_value="senior-engineering",
            name="Senior Engineering Mapping",
        ),
    )
```

### update_role()

```python
def update_role(role_id, *, data, **kwargs)
```

Update role

> Update a role with the given ID.

**Parameters:**

| Parameter | Type                | Description                                      |
| --------- | ------------------- | ------------------------------------------------ |
| `role_id` | `str`               | The unique identifier of a role. Example: admin. |
| `data`    | `RoleUpdateRequest` |                                                  |
| `kwargs`  | `Any`               |                                                  |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.NotFoundError** – If the response status code is 404. The role with the ID is not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  RoleUpdateResult
- **Return type:**
  RoleUpdateResult

#### Examples

**Update a role:**

```python
def update_role_example(role_id: RoleId) -> None:
    client = CamundaClient()

    client.update_role(
        role_id=role_id,
        data=RoleUpdateRequest(name="senior-developer"),
    )
```

### update_tenant()

```python
def update_tenant(tenant_id, *, data, **kwargs)
```

Update tenant

> Updates an existing tenant.

**Parameters:**

| Parameter   | Type                  | Description                                                     |
| ----------- | --------------------- | --------------------------------------------------------------- |
| `tenant_id` | `str`                 | The unique identifier of the tenant. Example: customer-service. |
| `data`      | `TenantUpdateRequest` |                                                                 |
| `kwargs`    | `Any`                 |                                                                 |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Not found. The tenant was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  TenantUpdateResult
- **Return type:**
  TenantUpdateResult

#### Examples

**Update a tenant:**

```python
def update_tenant_example(tenant_id: TenantId) -> None:
    client = CamundaClient()

    client.update_tenant(
        tenant_id=tenant_id,
        data=TenantUpdateRequest(name="Acme Corp International"),
    )
```

### update_tenant_cluster_variable()

```python
def update_tenant_cluster_variable(tenant_id, name, *, data, **kwargs)
```

Update a tenant-scoped cluster variable

> Updates the value of an existing tenant-scoped cluster variable.
>
> The variable must exist, otherwise a 404 error is returned.

**Parameters:**

| Parameter   | Type                           | Description                                                                                                           |
| ----------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| `tenant_id` | `str`                          | The unique identifier of the tenant. Example: customer-service.                                                       |
| `name`      | `str`                          | The name of a cluster variable. Unique within its scope (global or tenant- specific). Example: feature-flag-checkout. |
| `data`      | `UpdateClusterVariableRequest` |                                                                                                                       |
| `kwargs`    | `Any`                          |                                                                                                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.UnauthorizedError** – If the response status code is 401. The request lacks valid authentication credentials.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. Cluster variable not found
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  ClusterVariableResult
- **Return type:**
  ClusterVariableResult

#### Examples

**Update a tenant cluster variable:**

```python
def update_tenant_cluster_variable_example(tenant_id: TenantId, name: ClusterVariableName) -> None:
    client = CamundaClient()

    result = client.update_tenant_cluster_variable(
        tenant_id=tenant_id,
        name=name,
        data=UpdateClusterVariableRequest(
            value=UpdateClusterVariableRequestValue.from_dict({"key": "updated-tenant-value"}),
        ),
    )

    print(f"Updated variable: {result.name}")
```

### update_user()

```python
def update_user(username, *, data, **kwargs)
```

Update user

> Updates a user.

**Parameters:**

| Parameter  | Type                | Description                                  |
| ---------- | ------------------- | -------------------------------------------- |
| `username` | `str`               | The unique name of a user. Example: swillis. |
| `data`     | `UserUpdateRequest` |                                              |
| `kwargs`   | `Any`               |                                              |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.ForbiddenError** – If the response status code is 403. Forbidden. The request is not allowed.
  - **errors.NotFoundError** – If the response status code is 404. The user was not found.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  UserUpdateResult
- **Return type:**
  UserUpdateResult

#### Examples

**Update a user:**

```python
def update_user_example(username: Username) -> None:
    client = CamundaClient()

    client.update_user(
        username=username,
        data=UserUpdateRequest(
            name="Jane Smith",
            email="jsmith@example.com",
        ),
    )
```

### update_user_task()

```python
def update_user_task(user_task_key, *, data=<camunda_orchestration_sdk.types.Unset object>, **kwargs)
```

Update user task

> Update a user task with the given key. Updates wait for blocking task listeners on this lifecycle
> transition. If listener processing is delayed beyond the request timeout, this endpoint can return

504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker
     availability and logs when this repeats.

**Parameters:**

| Parameter       | Type                               | Description                           |
| --------------- | ---------------------------------- | ------------------------------------- |
| `user_task_key` | `str`                              | System-generated key for a user task. |
| `data`          | `UserTaskUpdateRequest` \| `Unset` |                                       |
| `kwargs`        | `Any`                              |                                       |

- **Raises:**
  - **errors.BadRequestError** – If the response status code is 400. The provided data is not valid.
  - **errors.NotFoundError** – If the response status code is 404. The user task with the given key was not found.
  - **errors.ConflictError** – If the response status code is 409. The user task with the given key is in the wrong state currently. More details are provided in the response body.
  - **errors.InternalServerErrorError** – If the response status code is 500. An internal error occurred while processing the request.
  - **errors.ServiceUnavailableError** – If the response status code is 503. The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server’s compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains RESOURCE_EXHAUSTED. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: [internal processing](../../../components/zeebe/technical-concepts/internal-processing.md#handling-backpressure) .
  - **errors.GatewayTimeoutError** – If the response status code is 504. The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response. Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists
  - **errors.UnexpectedStatus** – If the response status code is not documented.
  - **httpx.TimeoutException** – If the request takes longer than Client.timeout.
- **Returns:**
  None
- **Return type:**
  None

#### Examples

**Update a user task:**

```python
def update_user_task_example(user_task_key: UserTaskKey) -> None:
    client = CamundaClient()

    client.update_user_task(
        user_task_key=user_task_key,
        data=UserTaskUpdateRequest(
            changeset=Changeset(
                due_date=datetime.datetime(2025, 12, 31, 23, 59, 59),
            ),
        ),
    )
```

---

## Configuration(3)


## Client

```python
class Client(base_url, , raise_on_unexpected_status=False, cookies=NOTHING, headers=NOTHING, timeout=None, verify_ssl=True, follow_redirects=False, httpx_args=NOTHING)
```

Bases: `object`

A class for keeping track of data related to the API

The following are accepted as keyword arguments and will be used to construct httpx Clients internally:

> `base_url`: The base URL for the API, all requests are made to a relative path to this URL

> `cookies`: A dictionary of cookies to be sent with every request

> `headers`: A dictionary of headers to be sent with every request

> `timeout`: The maximum amount of a time a request can take. API functions will raise
> httpx.TimeoutException if this is exceeded.

> `verify_ssl`: Whether or not to verify the SSL certificate of the API server. This should be True in production,
> but can be set to False for testing purposes.

> `follow_redirects`: Whether or not to follow redirects. Default value is False.

> `httpx_args`: A dictionary of additional arguments to be passed to the `httpx.Client` and `httpx.AsyncClient` constructor.

**Parameters:**

| Parameter                    | Type                                | Description |
| ---------------------------- | ----------------------------------- | ----------- |
| `base_url`                   | `str`                               |             |
| `raise_on_unexpected_status` | `bool`                              |             |
| `cookies`                    | dict [str , str ]                   |             |
| `headers`                    | dict [str , str ]                   |             |
| `timeout`                    | `httpx.Timeout` \| `None`           |             |
| `verify_ssl`                 | `str` \| `bool` \| `ssl.SSLContext` |             |
| `follow_redirects`           | `bool`                              |             |
| `httpx_args`                 | dict [str , Any ]                   |             |

### raise_on_unexpected_status

Whether or not to raise an errors.UnexpectedStatus if the API returns a
status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
argument to the constructor.

- **Type:**
  bool

### get_async_httpx_client()

```python
def get_async_httpx_client()
```

Get the underlying httpx.AsyncClient, constructing a new one if not previously set

- **Return type:**
  _AsyncClient_

### get_httpx_client()

```python
def get_httpx_client()
```

Get the underlying httpx.Client, constructing a new one if not previously set

- **Return type:**
  _Client_

### raise_on_unexpected_status

```python
raise_on_unexpected_status: bool
```

### set_async_httpx_client()

```python
def set_async_httpx_client(async_client)
```

Manually set the underlying httpx.AsyncClient

**NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.

- **Parameters:**
  **async_client** (_AsyncClient_)
- **Return type:**
  [_Client_](#client)

### set_httpx_client()

```python
def set_httpx_client(client)
```

Manually set the underlying httpx.Client

**NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.

- **Parameters:**
  **client** (_Client_)
- **Return type:**
  [_Client_](#client)

### with_cookies()

```python
def with_cookies(cookies)
```

Get a new client matching this one with additional cookies

- **Parameters:**
  **cookies** (_dict_ _[__str_ _,_ _str_ _]_)
- **Return type:**
  [_Client_](#client)

### with_headers()

```python
def with_headers(headers)
```

Get a new client matching this one with additional headers

- **Parameters:**
  **headers** (_dict_ _[__str_ _,_ _str_ _]_)
- **Return type:**
  [_Client_](#client)

### with_timeout()

```python
def with_timeout(timeout)
```

Get a new client matching this one with a new timeout configuration

- **Parameters:**
  **timeout** (_Timeout_)
- **Return type:**
  [_Client_](#client)

## AuthenticatedClient

```python
class AuthenticatedClient(base_url, token, prefix='Bearer', auth_header_name='Authorization', , raise_on_unexpected_status=False, cookies=NOTHING, headers=NOTHING, timeout=None, verify_ssl=True, follow_redirects=False, httpx_args=NOTHING)
```

Bases: `object`

A Client which has been authenticated for use on secured endpoints

The following are accepted as keyword arguments and will be used to construct httpx Clients internally:

> `base_url`: The base URL for the API, all requests are made to a relative path to this URL

> `cookies`: A dictionary of cookies to be sent with every request

> `headers`: A dictionary of headers to be sent with every request

> `timeout`: The maximum amount of a time a request can take. API functions will raise
> httpx.TimeoutException if this is exceeded.

> `verify_ssl`: Whether or not to verify the SSL certificate of the API server. This should be True in production,
> but can be set to False for testing purposes.

> `follow_redirects`: Whether or not to follow redirects. Default value is False.

> `httpx_args`: A dictionary of additional arguments to be passed to the `httpx.Client` and `httpx.AsyncClient` constructor.

**Parameters:**

| Parameter                    | Type                                | Description |
| ---------------------------- | ----------------------------------- | ----------- |
| `base_url`                   | `str`                               |             |
| `token`                      | `str`                               |             |
| `prefix`                     | `str`                               |             |
| `auth_header_name`           | `str`                               |             |
| `raise_on_unexpected_status` | `bool`                              |             |
| `cookies`                    | dict [str , str ]                   |             |
| `headers`                    | dict [str , str ]                   |             |
| `timeout`                    | `httpx.Timeout` \| `None`           |             |
| `verify_ssl`                 | `str` \| `bool` \| `ssl.SSLContext` |             |
| `follow_redirects`           | `bool`                              |             |
| `httpx_args`                 | dict [str , Any ]                   |             |

### raise_on_unexpected_status

Whether or not to raise an errors.UnexpectedStatus if the API returns a
status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
argument to the constructor.

- **Type:**
  bool

### token

The token to use for authentication

- **Type:**
  str

### prefix

The prefix to use for the Authorization header

- **Type:**
  str

### auth_header_name

The name of the Authorization header

- **Type:**
  str

### auth_header_name

```python
auth_header_name: str
```

### get_async_httpx_client()

```python
def get_async_httpx_client()
```

Get the underlying httpx.AsyncClient, constructing a new one if not previously set

- **Return type:**
  _AsyncClient_

### get_httpx_client()

```python
def get_httpx_client()
```

Get the underlying httpx.Client, constructing a new one if not previously set

- **Return type:**
  _Client_

### prefix

```python
prefix: str
```

### raise_on_unexpected_status

```python
raise_on_unexpected_status: bool
```

### set_async_httpx_client()

```python
def set_async_httpx_client(async_client)
```

Manually set the underlying httpx.AsyncClient

**NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.

- **Parameters:**
  **async_client** (_AsyncClient_)
- **Return type:**
  [_AuthenticatedClient_](#authenticatedclient)

### set_httpx_client()

```python
def set_httpx_client(client)
```

Manually set the underlying httpx.Client

**NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.

- **Parameters:**
  **client** (_Client_)
- **Return type:**
  [_AuthenticatedClient_](#authenticatedclient)

### token

```python
token: str
```

### with_cookies()

```python
def with_cookies(cookies)
```

Get a new client matching this one with additional cookies

- **Parameters:**
  **cookies** (_dict_ _[__str_ _,_ _str_ _]_)
- **Return type:**
  [_AuthenticatedClient_](#authenticatedclient)

### with_headers()

```python
def with_headers(headers)
```

Get a new client matching this one with additional headers

- **Parameters:**
  **headers** (_dict_ _[__str_ _,_ _str_ _]_)
- **Return type:**
  [_AuthenticatedClient_](#authenticatedclient)

### with_timeout()

```python
def with_timeout(timeout)
```

Get a new client matching this one with a new timeout configuration

- **Parameters:**
  **timeout** (_Timeout_)
- **Return type:**
  [_AuthenticatedClient_](#authenticatedclient)

---

## Python SDK API Reference

# API Reference

- [CamundaClient](client.md)
  - [`CamundaClient`](client.md#camunda_orchestration_sdk.CamundaClient)
- [CamundaAsyncClient](async-client.md)
  - [`CamundaAsyncClient`](async-client.md#camunda_orchestration_sdk.CamundaAsyncClient)
- [Configuration](configuration.md)
  - [`Client`](configuration.md#camunda_orchestration_sdk.Client)
  - [`AuthenticatedClient`](configuration.md#camunda_orchestration_sdk.AuthenticatedClient)
- [Runtime](runtime.md)
  - [Authentication](runtime.md#module-camunda_orchestration_sdk.runtime.auth)
  - [Logging](runtime.md#module-camunda_orchestration_sdk.runtime.logging)
  - [Job Worker](runtime.md#module-camunda_orchestration_sdk.runtime.job_worker)
  - [Configuration Resolver](runtime.md#module-camunda_orchestration_sdk.runtime.configuration_resolver)
- [Semantic Types](types.md)
  - [`AgentHistoryItemKey`](types.md#camunda_orchestration_sdk.semantic_types.AgentHistoryItemKey)
  - [`AgentInstanceKey`](types.md#camunda_orchestration_sdk.semantic_types.AgentInstanceKey)
  - [`AuditLogEntityKey`](types.md#camunda_orchestration_sdk.semantic_types.AuditLogEntityKey)
  - [`AuditLogKey`](types.md#camunda_orchestration_sdk.semantic_types.AuditLogKey)
  - [`AuthorizationKey`](types.md#camunda_orchestration_sdk.semantic_types.AuthorizationKey)
  - [`BatchOperationKey`](types.md#camunda_orchestration_sdk.semantic_types.BatchOperationKey)
  - [`BusinessId`](types.md#camunda_orchestration_sdk.semantic_types.BusinessId)
  - [`ClientId`](types.md#camunda_orchestration_sdk.semantic_types.ClientId)
  - [`ClusterVariableName`](types.md#camunda_orchestration_sdk.semantic_types.ClusterVariableName)
  - [`ConditionalEvaluationKey`](types.md#camunda_orchestration_sdk.semantic_types.ConditionalEvaluationKey)
  - [`DecisionDefinitionId`](types.md#camunda_orchestration_sdk.semantic_types.DecisionDefinitionId)
  - [`DecisionDefinitionKey`](types.md#camunda_orchestration_sdk.semantic_types.DecisionDefinitionKey)
  - [`DecisionEvaluationInstanceKey`](types.md#camunda_orchestration_sdk.semantic_types.DecisionEvaluationInstanceKey)
  - [`DecisionEvaluationKey`](types.md#camunda_orchestration_sdk.semantic_types.DecisionEvaluationKey)
  - [`DecisionInstanceKey`](types.md#camunda_orchestration_sdk.semantic_types.DecisionInstanceKey)
  - [`DecisionRequirementsKey`](types.md#camunda_orchestration_sdk.semantic_types.DecisionRequirementsKey)
  - [`DeploymentKey`](types.md#camunda_orchestration_sdk.semantic_types.DeploymentKey)
  - [`DocumentId`](types.md#camunda_orchestration_sdk.semantic_types.DocumentId)
  - [`ElementId`](types.md#camunda_orchestration_sdk.semantic_types.ElementId)
  - [`ElementInstanceKey`](types.md#camunda_orchestration_sdk.semantic_types.ElementInstanceKey)
  - [`EndCursor`](types.md#camunda_orchestration_sdk.semantic_types.EndCursor)
  - [`FormId`](types.md#camunda_orchestration_sdk.semantic_types.FormId)
  - [`FormKey`](types.md#camunda_orchestration_sdk.semantic_types.FormKey)
  - [`GlobalListenerId`](types.md#camunda_orchestration_sdk.semantic_types.GlobalListenerId)
  - [`GroupId`](types.md#camunda_orchestration_sdk.semantic_types.GroupId)
  - [`IncidentKey`](types.md#camunda_orchestration_sdk.semantic_types.IncidentKey)
  - [`JobKey`](types.md#camunda_orchestration_sdk.semantic_types.JobKey)
  - [`MappingRuleId`](types.md#camunda_orchestration_sdk.semantic_types.MappingRuleId)
  - [`MessageKey`](types.md#camunda_orchestration_sdk.semantic_types.MessageKey)
  - [`MessageSubscriptionKey`](types.md#camunda_orchestration_sdk.semantic_types.MessageSubscriptionKey)
  - [`ProcessDefinitionId`](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionId)
  - [`ProcessDefinitionKey`](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionKey)
  - [`ProcessInstanceKey`](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey)
  - [`RoleId`](types.md#camunda_orchestration_sdk.semantic_types.RoleId)
  - [`SignalKey`](types.md#camunda_orchestration_sdk.semantic_types.SignalKey)
  - [`StartCursor`](types.md#camunda_orchestration_sdk.semantic_types.StartCursor)
  - [`Tag`](types.md#camunda_orchestration_sdk.semantic_types.Tag)
  - [`TenantId`](types.md#camunda_orchestration_sdk.semantic_types.TenantId)
  - [`UserTaskKey`](types.md#camunda_orchestration_sdk.semantic_types.UserTaskKey)
  - [`Username`](types.md#camunda_orchestration_sdk.semantic_types.Username)
  - [`VariableKey`](types.md#camunda_orchestration_sdk.semantic_types.VariableKey)
  - [`lift_resource_key()`](types.md#camunda_orchestration_sdk.semantic_types.lift_resource_key)
  - [`lift_scope_key()`](types.md#camunda_orchestration_sdk.semantic_types.lift_scope_key)
  - [`try_lift_resource_key()`](types.md#camunda_orchestration_sdk.semantic_types.try_lift_resource_key)
  - [`try_lift_scope_key()`](types.md#camunda_orchestration_sdk.semantic_types.try_lift_scope_key)

---

## Runtime(Api-reference)


## Authentication

## AsyncAuthProvider

```python
class AsyncAuthProvider(*args, **kwargs)
```

Bases: `Protocol`

Async auth provider variant.

If an auth provider implements this protocol, async clients will prefer it.

### aget_headers()

```python
async def aget_headers()
```

- **Return type:**
  _Mapping_[str, str]

## AsyncOAuthClientCredentialsAuthProvider

```python
class AsyncOAuthClientCredentialsAuthProvider(, oauth_url, client_id, client_secret, audience, cache_dir=None, disk_cache_disable=False, saas_401_cooldown_s=30.0, transport=None, timeout=None, logger=None)
```

Bases: `object`

OAuth 2.0 Client Credentials provider with in-memory caching.

This is designed for async clients.

**Parameters:**

| Parameter             | Type                                 | Description |
| --------------------- | ------------------------------------ | ----------- |
| `oauth_url`           | `str`                                |             |
| `client_id`           | `str`                                |             |
| `client_secret`       | `str`                                |             |
| `audience`            | `str`                                |             |
| `cache_dir`           | `str` \| `None`                      |             |
| `disk_cache_disable`  | `bool`                               |             |
| `saas_401_cooldown_s` | `float`                              |             |
| `transport`           | `httpx.AsyncBaseTransport` \| `None` |             |
| `timeout`             | `float` \| `None`                    |             |
| `logger`              | [SdkLogger](#sdklogger) \| `None`    |             |

### aclose()

```python
async def aclose()
```

Close the underlying async HTTP client used for token requests.

- **Return type:**
  None

### aget_headers()

```python
async def aget_headers()
```

- **Return type:**
  _Mapping_[str, str]

### get_headers()

```python
def get_headers()
```

Sync fallback satisfying the `AuthProvider` protocol.

Returns cached token headers if a valid token is already held,
otherwise returns empty headers (the next async request hook will
call `aget_headers` to fetch a fresh token).

- **Return type:**
  _Mapping_[str, str]

## AuthProvider

```python
class AuthProvider(*args, **kwargs)
```

Bases: `Protocol`

Provides per-request authentication headers.

Implementations are expected to be lightweight and safe to call for every request.

### get_headers()

```python
def get_headers()
```

- **Return type:**
  _Mapping_[str, str]

## BasicAuthProvider

```python
class BasicAuthProvider(, username, password)
```

Bases: `object`

HTTP Basic auth provider.

**Parameters:**

| Parameter  | Type  | Description |
| ---------- | ----- | ----------- |
| `username` | `str` |             |
| `password` | `str` |             |

### get_headers()

```python
def get_headers()
```

- **Return type:**
  _Mapping_[str, str]

## NullAuthProvider

```python
class NullAuthProvider
```

Bases: `object`

Default auth provider that adds no headers.

### get_headers()

```python
def get_headers()
```

- **Return type:**
  dict[str, str]

## OAuthClientCredentialsAuthProvider

```python
class OAuthClientCredentialsAuthProvider(, oauth_url, client_id, client_secret, audience, cache_dir=None, disk_cache_disable=False, saas_401_cooldown_s=30.0, transport=None, timeout=None, logger=None)
```

Bases: `object`

OAuth 2.0 Client Credentials provider with in-memory caching.

This is designed for sync clients.

**Parameters:**

| Parameter             | Type                              | Description |
| --------------------- | --------------------------------- | ----------- |
| `oauth_url`           | `str`                             |             |
| `client_id`           | `str`                             |             |
| `client_secret`       | `str`                             |             |
| `audience`            | `str`                             |             |
| `cache_dir`           | `str` \| `None`                   |             |
| `disk_cache_disable`  | `bool`                            |             |
| `saas_401_cooldown_s` | `float`                           |             |
| `transport`           | `httpx.BaseTransport` \| `None`   |             |
| `timeout`             | `float` \| `None`                 |             |
| `logger`              | [SdkLogger](#sdklogger) \| `None` |             |

### close()

```python
def close()
```

Close the underlying HTTP client used for token requests.

Call this when the application is shutting down if you created a provider
instance yourself (or if you want deterministic cleanup in tests).

- **Return type:**
  None

### get_headers()

```python
def get_headers()
```

- **Return type:**
  _Mapping_[str, str]

### inject_auth_event_hooks()

```python
def inject_auth_event_hooks(httpx_args, auth_provider, *, async_client=False, log_level=None, logger=None)
```

Return a copy of httpx_args with a request hook that applies auth headers.

This uses httpx event hooks so we don’t have to inject headers in every generated API call.

**Parameters:**

| Parameter       | Type                              | Description |
| --------------- | --------------------------------- | ----------- |
| `httpx_args`    | dict [str , Any ] \| `None`       |             |
| `auth_provider` | `object`                          |             |
| `async_client`  | `bool`                            |             |
| `log_level`     | `str` \| `None`                   |             |
| `logger`        | [SdkLogger](#sdklogger) \| `None` |             |

- **Return type:**
  dict[str, _Any_]

## Logging

Pluggable logger abstraction for the Camunda SDK.

Users can inject any logger that implements [`CamundaLogger`](#camundalogger) (stdlib
`logging.Logger`, `loguru.logger`, or a custom object with
`debug`/`info`/`warning`/`error` methods).

When no logger is provided, loguru is used if installed, otherwise logging is
silently disabled.

## CamundaLogger

```python
class CamundaLogger(*args, **kwargs)
```

Bases: `Protocol`

Protocol for a logger injectable into the SDK.

Compatible with Python’s `logging.Logger`, `loguru.logger`, or any
object that exposes these four methods.

### debug()

```python
def debug(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### error()

```python
def error(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### info()

```python
def info(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### warning()

```python
def warning(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

## NullLogger

```python
class NullLogger
```

Bases: `object`

Logger that silently discards all messages.

### debug()

```python
def debug(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### error()

```python
def error(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### info()

```python
def info(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### trace()

```python
def trace(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### warning()

```python
def warning(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

## SdkLogger

```python
class SdkLogger(logger, prefix='')
```

Bases: `object`

Internal wrapper that normalises logger implementations.

Adds `trace()` support (falls back to `debug()` on loggers that lack
it) and `bind()` support (uses loguru’s native `bind` when available,
otherwise prepends a `[key=value ...]` prefix to messages).

**Parameters:**

| Parameter | Type                            | Description |
| --------- | ------------------------------- | ----------- |
| `logger`  | [CamundaLogger](#camundalogger) |             |
| `prefix`  | `str`                           |             |

### bind()

```python
def bind(**kwargs)
```

Create a child logger with additional context.

If the underlying logger supports `bind()` (e.g. loguru), the native
method is used. Otherwise context is rendered as a `[k=v ...]`
prefix on each message.

- **Parameters:**
  **kwargs** (_str_)
- **Return type:**
  [_SdkLogger_](#sdklogger)

### debug()

```python
def debug(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### error()

```python
def error(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### info()

```python
def info(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### trace()

```python
def trace(msg)
```

- **Parameters:**
  **msg** (_str_)
- **Return type:**
  None

### warning()

```python
def warning(msg, *args, **kwargs)
```

**Parameters:**

| Parameter | Type  | Description |
| --------- | ----- | ----------- |
| `msg`     | `str` |             |
| `args`    | `Any` |             |
| `kwargs`  | `Any` |             |

- **Return type:**
  None

### create_logger()

```python
def create_logger(logger=None)
```

Create an [`SdkLogger`](#sdklogger).

- **Parameters:**
  **logger** ([_CamundaLogger_](#camundalogger) _|_ _None_) – A user-supplied logger. When `None`, loguru is used if installed,
  otherwise a [`NullLogger`](#nulllogger) is used.
- **Return type:**
  [_SdkLogger_](#sdklogger)

## Job Worker

### AsyncJobContext

alias of [`ConnectedJobContext`](#connectedjobcontext)

## ConnectedJobContext

```python
class ConnectedJobContext(type_, process_definition_id, process_definition_version, element_id, custom_headers, worker, retries, deadline, variables, tenant_id, physical_tenant_id, job_key, process_instance_key, process_definition_key, element_instance_key, kind, listener_event_type, user_task, tags, root_process_instance_key, business_id, priority, lease_token, log=NOTHING, , client)
```

Bases: [`JobContext`](#jobcontext)

Context for **async** handlers — includes an async client reference.

Extends [`JobContext`](#jobcontext) with a `client` attribute that provides
access to the Camunda API from within an async job handler. Use
`await job.client.method(...)` to call API methods.

This context is provided when the execution strategy is `"async"`.
For `"thread"` handlers, see [`SyncJobContext`](#syncjobcontext).
For `"process"` handlers, see [`JobContext`](#jobcontext).

**Parameters:**

| Parameter                    | Type                                                                                                 | Description |
| ---------------------------- | ---------------------------------------------------------------------------------------------------- | ----------- |
| `type_`                      | `str`                                                                                                |             |
| `process_definition_id`      | [ProcessDefinitionId](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionId)         |             |
| `process_definition_version` | `int`                                                                                                |             |
| `element_id`                 | [ElementId](types.md#camunda_orchestration_sdk.semantic_types.ElementId)                             |             |
| `custom_headers`             | `ActivatedJobResultCustomHeaders`                                                                    |             |
| `worker`                     | `str`                                                                                                |             |
| `retries`                    | `int`                                                                                                |             |
| `deadline`                   | `int`                                                                                                |             |
| `variables`                  | `ActivatedJobResultVariables`                                                                        |             |
| `tenant_id`                  | [TenantId](types.md#camunda_orchestration_sdk.semantic_types.TenantId)                               |             |
| `physical_tenant_id`         | `str`                                                                                                |             |
| `job_key`                    | [JobKey](types.md#camunda_orchestration_sdk.semantic_types.JobKey)                                   |             |
| `process_instance_key`       | [ProcessInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey)           |             |
| `process_definition_key`     | [ProcessDefinitionKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionKey)       |             |
| `element_instance_key`       | [ElementInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ElementInstanceKey)           |             |
| `kind`                       | `JobKindEnum`                                                                                        |             |
| `listener_event_type`        | `JobListenerEventTypeEnum`                                                                           |             |
| `user_task`                  | `ActivatedJobResultUserTask` \| `None`                                                               |             |
| `tags`                       | list [str ]                                                                                          |             |
| `root_process_instance_key`  | `None` \| [ProcessInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey) |             |
| `business_id`                | `None` \| [BusinessId](types.md#camunda_orchestration_sdk.semantic_types.BusinessId)                 |             |
| `priority`                   | `int`                                                                                                |             |
| `lease_token`                | `None` \| `str`                                                                                      |             |
| `log`                        | [SdkLogger](#sdklogger)                                                                              |             |
| `client`                     | [CamundaAsyncClient](async-client.md#camunda_orchestration_sdk.CamundaAsyncClient)                   |             |

### client

```python
client: [CamundaAsyncClient](async-client.md#camunda_orchestration_sdk.CamundaAsyncClient)
```

### _classmethod_ create(job, client, logger=None)

**Parameters:**

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `job`     | `ActivatedJobResult`              |             |
| `client`  | `Any`                             |             |
| `logger`  | [SdkLogger](#sdklogger) \| `None` |             |

- **Return type:**
  [_ConnectedJobContext_](#connectedjobcontext)

## JobContext

```python
class JobContext(type_, process_definition_id, process_definition_version, element_id, custom_headers, worker, retries, deadline, variables, tenant_id, physical_tenant_id, job_key, process_instance_key, process_definition_key, element_instance_key, kind, listener_event_type, user_task, tags, root_process_instance_key, business_id, priority, lease_token, log=NOTHING)
```

Bases: `ActivatedJobResult`

Read-only context for a job execution.

**Parameters:**

| Parameter                    | Type                                                                                                 | Description |
| ---------------------------- | ---------------------------------------------------------------------------------------------------- | ----------- |
| `type_`                      | `str`                                                                                                |             |
| `process_definition_id`      | [ProcessDefinitionId](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionId)         |             |
| `process_definition_version` | `int`                                                                                                |             |
| `element_id`                 | [ElementId](types.md#camunda_orchestration_sdk.semantic_types.ElementId)                             |             |
| `custom_headers`             | `ActivatedJobResultCustomHeaders`                                                                    |             |
| `worker`                     | `str`                                                                                                |             |
| `retries`                    | `int`                                                                                                |             |
| `deadline`                   | `int`                                                                                                |             |
| `variables`                  | `ActivatedJobResultVariables`                                                                        |             |
| `tenant_id`                  | [TenantId](types.md#camunda_orchestration_sdk.semantic_types.TenantId)                               |             |
| `physical_tenant_id`         | `str`                                                                                                |             |
| `job_key`                    | [JobKey](types.md#camunda_orchestration_sdk.semantic_types.JobKey)                                   |             |
| `process_instance_key`       | [ProcessInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey)           |             |
| `process_definition_key`     | [ProcessDefinitionKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionKey)       |             |
| `element_instance_key`       | [ElementInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ElementInstanceKey)           |             |
| `kind`                       | `JobKindEnum`                                                                                        |             |
| `listener_event_type`        | `JobListenerEventTypeEnum`                                                                           |             |
| `user_task`                  | `ActivatedJobResultUserTask` \| `None`                                                               |             |
| `tags`                       | list [str ]                                                                                          |             |
| `root_process_instance_key`  | `None` \| [ProcessInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey) |             |
| `business_id`                | `None` \| [BusinessId](types.md#camunda_orchestration_sdk.semantic_types.BusinessId)                 |             |
| `priority`                   | `int`                                                                                                |             |
| `lease_token`                | `None` \| `str`                                                                                      |             |
| `log`                        | [SdkLogger](#sdklogger)                                                                              |             |

### log

A scoped logger bound to this job’s context (job type, job key).
Use `job.log.info(...)` etc. inside your handler to emit
structured log messages.

- **Type:**
  [SdkLogger](#sdklogger)

### _classmethod_ from_job(job, logger=None)

**Parameters:**

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `job`     | `ActivatedJobResult`              |             |
| `logger`  | [SdkLogger](#sdklogger) \| `None` |             |

- **Return type:**
  [_JobContext_](#jobcontext)

### log

```python
log: [SdkLogger](#sdklogger)
```

### _exception_ JobError(error_code, message='', variables=None)

Bases: `Exception`

Raise this exception to throw a BPMN error.

**Parameters:**

| Parameter    | Type                        | Description |
| ------------ | --------------------------- | ----------- |
| `error_code` | `str`                       |             |
| `message`    | `str`                       |             |
| `variables`  | dict [str , Any ] \| `None` |             |

### _exception_ JobFailure(message, retries=None, retry_back_off=0, variables=None)

Bases: `Exception`

Raise this exception to explicitly fail a job with custom retries/backoff.

**Parameters:**

| Parameter        | Type                        | Description |
| ---------------- | --------------------------- | ----------- |
| `message`        | `str`                       |             |
| `retries`        | `int` \| `None`             |             |
| `retry_back_off` | `int`                       |             |
| `variables`      | dict [str , Any ] \| `None` |             |

## JobWorker

```python
class JobWorker(client, callback, config, logger=None, execution_strategy='auto', startup_jitter_max_seconds=0)
```

Bases: `object`

**Parameters:**

| Parameter                    | Type                                                                               | Description |
| ---------------------------- | ---------------------------------------------------------------------------------- | ----------- |
| `client`                     | [CamundaAsyncClient](async-client.md#camunda_orchestration_sdk.CamundaAsyncClient) |             |
| `callback`                   | `JobHandler`                                                                       |             |
| `config`                     | [WorkerConfig](#workerconfig)                                                      |             |
| `logger`                     | [SdkLogger](#sdklogger) \| `None`                                                  |             |
| `execution_strategy`         | `EXECUTION_STRATEGY`                                                               |             |
| `startup_jitter_max_seconds` | `float`                                                                            |             |

### aclose()

```python
async def aclose()
```

Async-aware teardown.

Cancels any in-flight job tasks and awaits their cancellation
(bounded by a timeout) before delegating to the synchronous
`close()`. Prefer this over `stop()`/`close()` from inside
a running event loop — it gives cancelled tasks a chance to
propagate before the pools they depend on are shut down, which
prevents ‘cannot schedule new futures after shutdown’ (and the
post-#150 ‘JobWorker is closed’) errors from surfacing as task
exceptions.

- **Return type:**
  None

### close()

```python
def close()
```

Release any resources this worker lazily allocated.

Safe to call multiple times and from multiple threads concurrently.
Use as a context manager (`with JobWorker(...) as worker:`) or in
a pytest fixture teardown to avoid leaking file descriptors across
many short-lived worker instances (see issue #148).

Blocks until pools have finished shutdown so file descriptors and
worker processes are reliably released before the references are
cleared. If invoked from inside a pool worker thread, falls back
to a non-waiting shutdown for that pool to avoid a self-join
deadlock. If invoked from the worker loop thread, skips joining
the worker thread (same self-join hazard).

After `close()` returns, accessing `thread_pool`,
`process_pool`, or `worker_loop` raises `RuntimeError`;
a closed JobWorker cannot be reused.

- **Return type:**
  None

### poll_loop()

```python
async def poll_loop()
```

Background polling loop - always async

### _property_ process_pool _: ProcessPoolExecutor_

### start()

```python
def start()
```

### stop()

```python
def stop()
```

### _property_ thread_pool _: ThreadPoolExecutor_

### _property_ worker_loop _: AbstractEventLoop_

## SyncJobContext

```python
class SyncJobContext(type_, process_definition_id, process_definition_version, element_id, custom_headers, worker, retries, deadline, variables, tenant_id, physical_tenant_id, job_key, process_instance_key, process_definition_key, element_instance_key, kind, listener_event_type, user_task, tags, root_process_instance_key, business_id, priority, lease_token, log=NOTHING, , client)
```

Bases: [`JobContext`](#jobcontext)

Context for **thread** handlers — includes a sync client reference.

Extends [`JobContext`](#jobcontext) with a `client` attribute that provides
access to the Camunda API from within a synchronous (thread) handler.
Call `job.client.method(...)` directly — no `await` needed.

This context is provided when the execution strategy is `"thread"`.
For `"async"` handlers, see [`ConnectedJobContext`](#connectedjobcontext).
For `"process"` handlers, see [`JobContext`](#jobcontext).

**Parameters:**

| Parameter                    | Type                                                                                                 | Description |
| ---------------------------- | ---------------------------------------------------------------------------------------------------- | ----------- |
| `type_`                      | `str`                                                                                                |             |
| `process_definition_id`      | [ProcessDefinitionId](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionId)         |             |
| `process_definition_version` | `int`                                                                                                |             |
| `element_id`                 | [ElementId](types.md#camunda_orchestration_sdk.semantic_types.ElementId)                             |             |
| `custom_headers`             | `ActivatedJobResultCustomHeaders`                                                                    |             |
| `worker`                     | `str`                                                                                                |             |
| `retries`                    | `int`                                                                                                |             |
| `deadline`                   | `int`                                                                                                |             |
| `variables`                  | `ActivatedJobResultVariables`                                                                        |             |
| `tenant_id`                  | [TenantId](types.md#camunda_orchestration_sdk.semantic_types.TenantId)                               |             |
| `physical_tenant_id`         | `str`                                                                                                |             |
| `job_key`                    | [JobKey](types.md#camunda_orchestration_sdk.semantic_types.JobKey)                                   |             |
| `process_instance_key`       | [ProcessInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey)           |             |
| `process_definition_key`     | [ProcessDefinitionKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessDefinitionKey)       |             |
| `element_instance_key`       | [ElementInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ElementInstanceKey)           |             |
| `kind`                       | `JobKindEnum`                                                                                        |             |
| `listener_event_type`        | `JobListenerEventTypeEnum`                                                                           |             |
| `user_task`                  | `ActivatedJobResultUserTask` \| `None`                                                               |             |
| `tags`                       | list [str ]                                                                                          |             |
| `root_process_instance_key`  | `None` \| [ProcessInstanceKey](types.md#camunda_orchestration_sdk.semantic_types.ProcessInstanceKey) |             |
| `business_id`                | `None` \| [BusinessId](types.md#camunda_orchestration_sdk.semantic_types.BusinessId)                 |             |
| `priority`                   | `int`                                                                                                |             |
| `lease_token`                | `None` \| `str`                                                                                      |             |
| `log`                        | [SdkLogger](#sdklogger)                                                                              |             |
| `client`                     | [CamundaClient](client.md#camunda_orchestration_sdk.CamundaClient)                                   |             |

### client

```python
client: [CamundaClient](client.md#camunda_orchestration_sdk.CamundaClient)
```

### _classmethod_ create(job, client, logger=None)

**Parameters:**

| Parameter | Type                              | Description |
| --------- | --------------------------------- | ----------- |
| `job`     | `ActivatedJobResult`              |             |
| `client`  | `Any`                             |             |
| `logger`  | [SdkLogger](#sdklogger) \| `None` |             |

- **Return type:**
  [_SyncJobContext_](#syncjobcontext)

## WorkerConfig

```python
class WorkerConfig(job_type, job_timeout_milliseconds=None, request_timeout_milliseconds=None, max_concurrent_jobs=None, fetch_variables=None, worker_name=None)
```

Bases: `object`

User-facing configuration.

Fields left as `None` inherit the global default from
`CAMUNDA_WORKER_*` environment variables (or the client constructor),
falling back to the hardcoded SDK default when neither is set.

**Parameters:**

| Parameter                      | Type                  | Description |
| ------------------------------ | --------------------- | ----------- |
| `job_type`                     | `str`                 |             |
| `job_timeout_milliseconds`     | `int` \| `None`       |             |
| `request_timeout_milliseconds` | `int` \| `None`       |             |
| `max_concurrent_jobs`          | `int` \| `None`       |             |
| `fetch_variables`              | list [str ] \| `None` |             |
| `worker_name`                  | `str` \| `None`       |             |

### fetch_variables

```python
fetch_variables: list[str] | None* *= None
```

### job_timeout_milliseconds

```python
job_timeout_milliseconds: int | None* *= None
```

How long the job is reserved for this worker only. Falls back to
`CAMUNDA_WORKER_TIMEOUT` env var if not set.

### job_type

```python
job_type: str
```

Job type to activate and process.

### max_concurrent_jobs

```python
max_concurrent_jobs: int | None* *= None
```

Max jobs executing at once. Falls back to
`CAMUNDA_WORKER_MAX_CONCURRENT_JOBS` env var, then `10`.

### request_timeout_milliseconds

```python
request_timeout_milliseconds: int | None* *= None
```

Long-poll request timeout in milliseconds. Falls back to
`CAMUNDA_WORKER_REQUEST_TIMEOUT` env var, then `0`.

### worker_name

```python
worker_name: str | None* *= None
```

Worker identifier. Falls back to `CAMUNDA_WORKER_NAME` env var,
then `"camunda-python-sdk-worker"`.

### resolve_worker_config()

```python
def resolve_worker_config(config, configuration)
```

Return a new WorkerConfig with `None` fields filled from _configuration_.

Precedence: explicit field value > `CAMUNDA_WORKER_*` config > hardcoded default.
Raises `ValueError` if `job_timeout_milliseconds` is still unset after merging.

**Parameters:**

| Parameter       | Type                          | Description |
| --------------- | ----------------------------- | ----------- |
| `config`        | [WorkerConfig](#workerconfig) |             |
| `configuration` | `Any`                         |             |

- **Return type:**
  [_WorkerConfig_](#workerconfig)

## Configuration Resolver

## CamundaSdkConfigPartial

```python
class CamundaSdkConfigPartial
```

Bases: `TypedDict`

### CAMUNDA_AUTH_STRATEGY

```python
CAMUNDA_AUTH_STRATEGY: Literal['NONE', 'OAUTH', 'BASIC']
```

### CAMUNDA_BASIC_AUTH_PASSWORD

```python
CAMUNDA_BASIC_AUTH_PASSWORD: str
```

### CAMUNDA_BASIC_AUTH_USERNAME

```python
CAMUNDA_BASIC_AUTH_USERNAME: str
```

### CAMUNDA_CLIENT_AUTH_CLIENTID

```python
CAMUNDA_CLIENT_AUTH_CLIENTID: str
```

### CAMUNDA_CLIENT_AUTH_CLIENTSECRET

```python
CAMUNDA_CLIENT_AUTH_CLIENTSECRET: str
```

### CAMUNDA_CLIENT_ID

```python
CAMUNDA_CLIENT_ID: str
```

### CAMUNDA_CLIENT_SECRET

```python
CAMUNDA_CLIENT_SECRET: str
```

### CAMUNDA_LOAD_ENVFILE

```python
CAMUNDA_LOAD_ENVFILE: str
```

### CAMUNDA_MTLS_CA

```python
CAMUNDA_MTLS_CA: str
```

### CAMUNDA_MTLS_CA_PATH

```python
CAMUNDA_MTLS_CA_PATH: str
```

### CAMUNDA_MTLS_CERT

```python
CAMUNDA_MTLS_CERT: str
```

### CAMUNDA_MTLS_CERT_PATH

```python
CAMUNDA_MTLS_CERT_PATH: str
```

### CAMUNDA_MTLS_KEY

```python
CAMUNDA_MTLS_KEY: str
```

### CAMUNDA_MTLS_KEY_PASSPHRASE

```python
CAMUNDA_MTLS_KEY_PASSPHRASE: str
```

### CAMUNDA_MTLS_KEY_PATH

```python
CAMUNDA_MTLS_KEY_PATH: str
```

### CAMUNDA_OAUTH_URL

```python
CAMUNDA_OAUTH_URL: str
```

### CAMUNDA_REST_ADDRESS

```python
CAMUNDA_REST_ADDRESS: str
```

### CAMUNDA_SDK_BACKPRESSURE_PROFILE

```python
CAMUNDA_SDK_BACKPRESSURE_PROFILE: str
```

### CAMUNDA_SDK_LOG_LEVEL

```python
CAMUNDA_SDK_LOG_LEVEL: Literal['silent', 'error', 'warn', 'info', 'debug', 'trace', 'silly']
```

### CAMUNDA_TENANT_ID

```python
CAMUNDA_TENANT_ID: str
```

### CAMUNDA_TENANT_IDS

```python
CAMUNDA_TENANT_IDS: str | list[str]
```

### CAMUNDA_TOKEN_AUDIENCE

```python
CAMUNDA_TOKEN_AUDIENCE: str
```

### CAMUNDA_TOKEN_CACHE_DIR

```python
CAMUNDA_TOKEN_CACHE_DIR: str
```

### CAMUNDA_TOKEN_DISK_CACHE_DISABLE

```python
CAMUNDA_TOKEN_DISK_CACHE_DISABLE: str
```

### CAMUNDA_WORKER_MAX_CONCURRENT_JOBS

```python
CAMUNDA_WORKER_MAX_CONCURRENT_JOBS: str
```

### CAMUNDA_WORKER_NAME

```python
CAMUNDA_WORKER_NAME: str
```

### CAMUNDA_WORKER_REQUEST_TIMEOUT

```python
CAMUNDA_WORKER_REQUEST_TIMEOUT: str
```

### CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS

```python
CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS: str
```

### CAMUNDA_WORKER_TIMEOUT

```python
CAMUNDA_WORKER_TIMEOUT: str
```

### ZEEBE_REST_ADDRESS

```python
ZEEBE_REST_ADDRESS: str
```

## CamundaSdkConfiguration

```python
class CamundaSdkConfiguration(, ZEEBE_REST_ADDRESS='http://localhost:8080/v2', CAMUNDA_REST_ADDRESS='http://localhost:8080/v2', CAMUNDA_TOKEN_AUDIENCE='zeebe.camunda.io', CAMUNDA_OAUTH_URL='https://login.cloud.camunda.io/oauth/token', CAMUNDA_CLIENT_ID=None, CAMUNDA_CLIENT_SECRET=None, CAMUNDA_CLIENT_AUTH_CLIENTID=None, CAMUNDA_CLIENT_AUTH_CLIENTSECRET=None, CAMUNDA_AUTH_STRATEGY='NONE', CAMUNDA_BASIC_AUTH_USERNAME=None, CAMUNDA_BASIC_AUTH_PASSWORD=None, CAMUNDA_SDK_LOG_LEVEL='error', CAMUNDA_TOKEN_CACHE_DIR=None, CAMUNDA_TOKEN_DISK_CACHE_DISABLE=False, CAMUNDA_SDK_BACKPRESSURE_PROFILE='BALANCED', CAMUNDA_TENANT_ID=None, CAMUNDA_TENANT_IDS=None, CAMUNDA_WORKER_TIMEOUT=None, CAMUNDA_WORKER_MAX_CONCURRENT_JOBS=None, CAMUNDA_WORKER_REQUEST_TIMEOUT=None, CAMUNDA_WORKER_NAME=None, CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS=None, CAMUNDA_MTLS_CERT_PATH=None, CAMUNDA_MTLS_KEY_PATH=None, CAMUNDA_MTLS_CA_PATH=None, CAMUNDA_MTLS_CERT=None, CAMUNDA_MTLS_KEY=None, CAMUNDA_MTLS_CA=None, CAMUNDA_MTLS_KEY_PASSPHRASE=None)
```

Bases: `BaseModel`

**Parameters:**

| Parameter                                   | Type                                                                           | Description |
| ------------------------------------------- | ------------------------------------------------------------------------------ | ----------- |
| `ZEEBE_REST_ADDRESS`                        | `str`                                                                          |             |
| `CAMUNDA_REST_ADDRESS`                      | `str`                                                                          |             |
| `CAMUNDA_TOKEN_AUDIENCE`                    | `str`                                                                          |             |
| `CAMUNDA_OAUTH_URL`                         | `str`                                                                          |             |
| `CAMUNDA_CLIENT_ID`                         | `str` \| `None`                                                                |             |
| `CAMUNDA_CLIENT_SECRET`                     | `str` \| `None`                                                                |             |
| `CAMUNDA_CLIENT_AUTH_CLIENTID`              | `str` \| `None`                                                                |             |
| `CAMUNDA_CLIENT_AUTH_CLIENTSECRET`          | `str` \| `None`                                                                |             |
| `CAMUNDA_AUTH_STRATEGY`                     | Literal [ 'NONE' , 'OAUTH' , 'BASIC' ]                                         |             |
| `CAMUNDA_BASIC_AUTH_USERNAME`               | `str` \| `None`                                                                |             |
| `CAMUNDA_BASIC_AUTH_PASSWORD`               | `str` \| `None`                                                                |             |
| `CAMUNDA_SDK_LOG_LEVEL`                     | Literal [ 'silent' , 'error' , 'warn' , 'info' , 'debug' , 'trace' , 'silly' ] |             |
| `CAMUNDA_TOKEN_CACHE_DIR`                   | `str` \| `None`                                                                |             |
| `CAMUNDA_TOKEN_DISK_CACHE_DISABLE`          | `bool`                                                                         |             |
| `CAMUNDA_SDK_BACKPRESSURE_PROFILE`          | Literal [ 'BALANCED' , 'LEGACY' ]                                              |             |
| `CAMUNDA_TENANT_ID`                         | `str` \| `None`                                                                |             |
| `CAMUNDA_TENANT_IDS`                        | list [str ] \| `None`                                                          |             |
| `CAMUNDA_WORKER_TIMEOUT`                    | `int` \| `None`                                                                |             |
| `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS`        | `int` \| `None`                                                                |             |
| `CAMUNDA_WORKER_REQUEST_TIMEOUT`            | `int` \| `None`                                                                |             |
| `CAMUNDA_WORKER_NAME`                       | `str` \| `None`                                                                |             |
| `CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS` | `float` \| `None`                                                              |             |
| `CAMUNDA_MTLS_CERT_PATH`                    | `str` \| `None`                                                                |             |
| `CAMUNDA_MTLS_KEY_PATH`                     | `str` \| `None`                                                                |             |
| `CAMUNDA_MTLS_CA_PATH`                      | `str` \| `None`                                                                |             |
| `CAMUNDA_MTLS_CERT`                         | `str` \| `None`                                                                |             |
| `CAMUNDA_MTLS_KEY`                          | `str` \| `None`                                                                |             |
| `CAMUNDA_MTLS_CA`                           | `str` \| `None`                                                                |             |
| `CAMUNDA_MTLS_KEY_PASSPHRASE`               | `str` \| `None`                                                                |             |

### CAMUNDA_AUTH_STRATEGY

```python
CAMUNDA_AUTH_STRATEGY: CamundaAuthStrategy
```

### CAMUNDA_BASIC_AUTH_PASSWORD

```python
CAMUNDA_BASIC_AUTH_PASSWORD: str | None
```

### CAMUNDA_BASIC_AUTH_USERNAME

```python
CAMUNDA_BASIC_AUTH_USERNAME: str | None
```

### CAMUNDA_CLIENT_AUTH_CLIENTID

```python
CAMUNDA_CLIENT_AUTH_CLIENTID: str | None
```

### CAMUNDA_CLIENT_AUTH_CLIENTSECRET

```python
CAMUNDA_CLIENT_AUTH_CLIENTSECRET: str | None
```

### CAMUNDA_CLIENT_ID

```python
CAMUNDA_CLIENT_ID: str | None
```

### CAMUNDA_CLIENT_SECRET

```python
CAMUNDA_CLIENT_SECRET: str | None
```

### CAMUNDA_MTLS_CA

```python
CAMUNDA_MTLS_CA: str | None
```

### CAMUNDA_MTLS_CA_PATH

```python
CAMUNDA_MTLS_CA_PATH: str | None
```

### CAMUNDA_MTLS_CERT

```python
CAMUNDA_MTLS_CERT: str | None
```

### CAMUNDA_MTLS_CERT_PATH

```python
CAMUNDA_MTLS_CERT_PATH: str | None
```

### CAMUNDA_MTLS_KEY

```python
CAMUNDA_MTLS_KEY: str | None
```

### CAMUNDA_MTLS_KEY_PASSPHRASE

```python
CAMUNDA_MTLS_KEY_PASSPHRASE: str | None
```

### CAMUNDA_MTLS_KEY_PATH

```python
CAMUNDA_MTLS_KEY_PATH: str | None
```

### CAMUNDA_OAUTH_URL

```python
CAMUNDA_OAUTH_URL: str
```

### CAMUNDA_REST_ADDRESS

```python
CAMUNDA_REST_ADDRESS: str
```

### CAMUNDA_SDK_BACKPRESSURE_PROFILE

```python
CAMUNDA_SDK_BACKPRESSURE_PROFILE: CamundaBackpressureProfile
```

### CAMUNDA_SDK_LOG_LEVEL

```python
CAMUNDA_SDK_LOG_LEVEL: CamundaSdkLogLevel
```

### CAMUNDA_TENANT_ID

```python
CAMUNDA_TENANT_ID: str | None
```

### CAMUNDA_TENANT_IDS

```python
CAMUNDA_TENANT_IDS: list[str] | None
```

### CAMUNDA_TOKEN_AUDIENCE

```python
CAMUNDA_TOKEN_AUDIENCE: str
```

### CAMUNDA_TOKEN_CACHE_DIR

```python
CAMUNDA_TOKEN_CACHE_DIR: str | None
```

### CAMUNDA_TOKEN_DISK_CACHE_DISABLE

```python
CAMUNDA_TOKEN_DISK_CACHE_DISABLE: bool
```

### CAMUNDA_WORKER_MAX_CONCURRENT_JOBS

```python
CAMUNDA_WORKER_MAX_CONCURRENT_JOBS: int | None
```

### CAMUNDA_WORKER_NAME

```python
CAMUNDA_WORKER_NAME: str | None
```

### CAMUNDA_WORKER_REQUEST_TIMEOUT

```python
CAMUNDA_WORKER_REQUEST_TIMEOUT: int | None
```

### CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS

```python
CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS: float | None
```

### CAMUNDA_WORKER_TIMEOUT

```python
CAMUNDA_WORKER_TIMEOUT: int | None
```

### ZEEBE_REST_ADDRESS

```python
ZEEBE_REST_ADDRESS: str
```

### model_config _= {'extra': 'forbid'}_

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

## ConfigurationResolver

```python
class ConfigurationResolver(environment, explicit_configuration=None)
```

Bases: `object`

Resolves an effective configuration from environment + explicit overrides.

**Parameters:**

| Parameter                | Type                                                                                  | Description |
| ------------------------ | ------------------------------------------------------------------------------------- | ----------- |
| `environment`            | [CamundaSdkConfigPartial](#camundasdkconfigpartial) \| Mapping [str , Any ]           |             |
| `explicit_configuration` | [CamundaSdkConfigPartial](#camundasdkconfigpartial) \| Mapping [str , Any ] \| `None` |             |

### resolve()

```python
def resolve()
```

- **Return type:**
  [_ResolvedCamundaSdkConfiguration_](#resolvedcamundasdkconfiguration)

## ResolvedCamundaSdkConfiguration

```python
class ResolvedCamundaSdkConfiguration(effective: 'CamundaSdkConfiguration', environment: 'CamundaSdkConfigPartial', explicit: 'CamundaSdkConfigPartial | None')
```

Bases: `object`

**Parameters:**

| Parameter     | Type                                                          | Description |
| ------------- | ------------------------------------------------------------- | ----------- |
| `effective`   | [CamundaSdkConfiguration](#camundasdkconfiguration)           |             |
| `environment` | [CamundaSdkConfigPartial](#camundasdkconfigpartial)           |             |
| `explicit`    | [CamundaSdkConfigPartial](#camundasdkconfigpartial) \| `None` |             |

### effective

```python
effective: [CamundaSdkConfiguration](#camundasdkconfiguration)
```

### environment

```python
environment: [CamundaSdkConfigPartial](#camundasdkconfigpartial)
```

### explicit

```python
explicit: [CamundaSdkConfigPartial](#camundasdkconfigpartial) | None
```

### read_environment()

```python
def read_environment(environ=None)
```

- **Parameters:**
  **environ** (_Mapping_ _[__str_ _,_ _str_ _]_ _|_ _None_)
- **Return type:**
  [_CamundaSdkConfigPartial_](#camundasdkconfigpartial)

---

## Semantic Types


## AgentHistoryItemKey

```python
class AgentHistoryItemKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [AgentHistoryItemKey](#agenthistoryitemkey)

## AgentInstanceKey

```python
class AgentInstanceKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [AgentInstanceKey](#agentinstancekey)

## AuditLogEntityKey

```python
class AuditLogEntityKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [AuditLogEntityKey](#auditlogentitykey)

## AuditLogKey

```python
class AuditLogKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [AuditLogKey](#auditlogkey)

## AuthorizationKey

```python
class AuthorizationKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [AuthorizationKey](#authorizationkey)

## BatchOperationKey

```python
class BatchOperationKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [BatchOperationKey](#batchoperationkey)

## BusinessId

```python
class BusinessId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [BusinessId](#businessid)

## ClientId

```python
class ClientId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ClientId](#clientid)

## ClusterVariableName

```python
class ClusterVariableName(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ClusterVariableName](#clustervariablename)

## ConditionalEvaluationKey

```python
class ConditionalEvaluationKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ConditionalEvaluationKey](#conditionalevaluationkey)

## DecisionDefinitionId

```python
class DecisionDefinitionId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DecisionDefinitionId](#decisiondefinitionid)

## DecisionDefinitionKey

```python
class DecisionDefinitionKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DecisionDefinitionKey](#decisiondefinitionkey)

## DecisionEvaluationInstanceKey

```python
class DecisionEvaluationInstanceKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DecisionEvaluationInstanceKey](#decisionevaluationinstancekey)

## DecisionEvaluationKey

```python
class DecisionEvaluationKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DecisionEvaluationKey](#decisionevaluationkey)

## DecisionInstanceKey

```python
class DecisionInstanceKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DecisionInstanceKey](#decisioninstancekey)

## DecisionRequirementsKey

```python
class DecisionRequirementsKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DecisionRequirementsKey](#decisionrequirementskey)

## DeploymentKey

```python
class DeploymentKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DeploymentKey](#deploymentkey)

## DocumentId

```python
class DocumentId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [DocumentId](#documentid)

## ElementId

```python
class ElementId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ElementId](#elementid)

## ElementInstanceKey

```python
class ElementInstanceKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ElementInstanceKey](#elementinstancekey)

## EndCursor

```python
class EndCursor(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [EndCursor](#endcursor)

## FormId

```python
class FormId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [FormId](#formid)

## FormKey

```python
class FormKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [FormKey](#formkey)

## GlobalListenerId

```python
class GlobalListenerId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [GlobalListenerId](#globallistenerid)

## GroupId

```python
class GroupId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [GroupId](#groupid)

## IncidentKey

```python
class IncidentKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [IncidentKey](#incidentkey)

## JobKey

```python
class JobKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [JobKey](#jobkey)

## MappingRuleId

```python
class MappingRuleId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [MappingRuleId](#mappingruleid)

## MessageKey

```python
class MessageKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [MessageKey](#messagekey)

## MessageSubscriptionKey

```python
class MessageSubscriptionKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [MessageSubscriptionKey](#messagesubscriptionkey)

## ProcessDefinitionId

```python
class ProcessDefinitionId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ProcessDefinitionId](#processdefinitionid)

## ProcessDefinitionKey

```python
class ProcessDefinitionKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ProcessDefinitionKey](#processdefinitionkey)

## ProcessInstanceKey

```python
class ProcessInstanceKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [ProcessInstanceKey](#processinstancekey)

## RoleId

```python
class RoleId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [RoleId](#roleid)

## SignalKey

```python
class SignalKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [SignalKey](#signalkey)

## StartCursor

```python
class StartCursor(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [StartCursor](#startcursor)

## Tag

```python
class Tag(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [Tag](#tag)

## TenantId

```python
class TenantId(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [TenantId](#tenantid)

## UserTaskKey

```python
class UserTaskKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [UserTaskKey](#usertaskkey)

## Username

```python
class Username(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [Username](#username)

## VariableKey

```python
class VariableKey(value)
```

Bases: `str`

- **Parameters:**
  **value** (_str_)
- **Return type:**
  [VariableKey](#variablekey)

### lift_resource_key()

```python
def lift_resource_key(value)
```

- **Parameters:**
  **value** (_Any_)
- **Return type:**
  [_ProcessDefinitionKey_](#processdefinitionkey) | [_DecisionRequirementsKey_](#decisionrequirementskey) | [_FormKey_](#formkey) | [_DecisionDefinitionKey_](#decisiondefinitionkey)

### lift_scope_key()

```python
def lift_scope_key(value)
```

- **Parameters:**
  **value** (_Any_)
- **Return type:**
  [_ProcessInstanceKey_](#processinstancekey) | [_ElementInstanceKey_](#elementinstancekey)

### try_lift_resource_key()

```python
def try_lift_resource_key(value)
```

- **Parameters:**
  **value** (_Any_)
- **Return type:**
  _Tuple_[bool, [_ProcessDefinitionKey_](#processdefinitionkey) | [_DecisionRequirementsKey_](#decisionrequirementskey) | [_FormKey_](#formkey) | [_DecisionDefinitionKey_](#decisiondefinitionkey) | Exception]

### try_lift_scope_key()

```python
def try_lift_scope_key(value)
```

- **Parameters:**
  **value** (_Any_)
- **Return type:**
  _Tuple_[bool, [_ProcessInstanceKey_](#processinstancekey) | [_ElementInstanceKey_](#elementinstancekey) | Exception]

---

## Authentication(Python-sdk)


The SDK supports three authentication strategies, controlled by `CAMUNDA_AUTH_STRATEGY`:

| Strategy | When to use                                               |
| -------- | --------------------------------------------------------- |
| `NONE`   | Local development with unauthenticated Camunda (default)  |
| `OAUTH`  | Camunda SaaS or any OAuth 2.0 Client Credentials endpoint |
| `BASIC`  | Self-Managed Camunda with Basic auth (username/password)  |

## Auto-detection

If you omit `CAMUNDA_AUTH_STRATEGY`, the SDK infers it from the credentials you provide:

- Only `CAMUNDA_CLIENT_ID` + `CAMUNDA_CLIENT_SECRET` → **OAUTH**
- Only `CAMUNDA_BASIC_AUTH_USERNAME` + `CAMUNDA_BASIC_AUTH_PASSWORD` → **BASIC**
- No credentials → **NONE**
- Both OAuth and Basic credentials present → **error** (set `CAMUNDA_AUTH_STRATEGY` explicitly)

## OAuth 2.0

```bash
CAMUNDA_REST_ADDRESS=https://cluster.example/v2
CAMUNDA_AUTH_STRATEGY=OAUTH
CAMUNDA_CLIENT_ID=your-client-id
CAMUNDA_CLIENT_SECRET=your-client-secret
# Optional:
# CAMUNDA_OAUTH_URL=https://login.cloud.camunda.io/oauth/token
# CAMUNDA_TOKEN_AUDIENCE=zeebe.camunda.io
```

## Basic authentication

```bash
CAMUNDA_REST_ADDRESS=http://localhost:8080/v2
CAMUNDA_AUTH_STRATEGY=BASIC
CAMUNDA_BASIC_AUTH_USERNAME=your-username
CAMUNDA_BASIC_AUTH_PASSWORD=your-password
```

Or programmatically:

<!-- snippet-source: examples/readme.py | regions: ReadmeBasicAuth -->

```python
from camunda_orchestration_sdk import CamundaClient

client = CamundaClient(
    configuration={
        "CAMUNDA_REST_ADDRESS": "http://localhost:8080/v2",
        "CAMUNDA_AUTH_STRATEGY": "BASIC",
        "CAMUNDA_BASIC_AUTH_USERNAME": "your-username",
        "CAMUNDA_BASIC_AUTH_PASSWORD": "your-password",
    }
)
```

---

## Backpressure


The SDK includes built-in adaptive backpressure management that protects the Camunda cluster from overload. When the cluster returns backpressure signals (HTTP 429, 503, or `RESOURCE_EXHAUSTED`), the SDK automatically reduces outbound concurrency. When conditions improve, it gradually recovers — returning to full throughput with no manual intervention.

This is enabled by default with the `BALANCED` profile and requires no configuration. Operations that drain work from the cluster (completing jobs, failing jobs) are never throttled.

| Profile              | Behavior                                                                                        |
| -------------------- | ----------------------------------------------------------------------------------------------- |
| `BALANCED` (default) | Adaptive concurrency gating with AIMD-style permit management and exponential backoff at floor. |
| `LEGACY`             | Observe-only — records severity but never gates or queues requests.                             |

Set the profile via the `CAMUNDA_SDK_BACKPRESSURE_PROFILE` environment variable.

---

## Configuration reference(Python-sdk)


All `CAMUNDA_*` environment variables recognised by the SDK. These can also be passed as keys in the `configuration={...}` dict.

<!-- BEGIN_CONFIG_REFERENCE -->

| Variable                                    | Default                                      | Description                                                                                                                                                                                                                                                               |
| ------------------------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ZEEBE_REST_ADDRESS`                        | `http://localhost:8080/v2`                   | REST API base URL (alias for CAMUNDA_REST_ADDRESS).                                                                                                                                                                                                                       |
| `CAMUNDA_REST_ADDRESS`                      | `http://localhost:8080/v2`                   | REST API base URL. `/v2` is appended automatically if missing.                                                                                                                                                                                                            |
| `CAMUNDA_TOKEN_AUDIENCE`                    | `zeebe.camunda.io`                           | OAuth token audience.                                                                                                                                                                                                                                                     |
| `CAMUNDA_OAUTH_URL`                         | `https://login.cloud.camunda.io/oauth/token` | OAuth token endpoint URL.                                                                                                                                                                                                                                                 |
| `CAMUNDA_CLIENT_ID`                         | —                                            | OAuth client ID.                                                                                                                                                                                                                                                          |
| `CAMUNDA_CLIENT_SECRET`                     | —                                            | OAuth client secret.                                                                                                                                                                                                                                                      |
| `CAMUNDA_CLIENT_AUTH_CLIENTID`              | —                                            | Alias for CAMUNDA_CLIENT_ID.                                                                                                                                                                                                                                              |
| `CAMUNDA_CLIENT_AUTH_CLIENTSECRET`          | —                                            | Alias for CAMUNDA_CLIENT_SECRET.                                                                                                                                                                                                                                          |
| `CAMUNDA_AUTH_STRATEGY`                     | `NONE`                                       | Authentication strategy: NONE, OAUTH, or BASIC. Auto-inferred from credentials if omitted.                                                                                                                                                                                |
| `CAMUNDA_BASIC_AUTH_USERNAME`               | —                                            | Basic auth username. Required when CAMUNDA_AUTH_STRATEGY=BASIC.                                                                                                                                                                                                           |
| `CAMUNDA_BASIC_AUTH_PASSWORD`               | —                                            | Basic auth password. Required when CAMUNDA_AUTH_STRATEGY=BASIC.                                                                                                                                                                                                           |
| `CAMUNDA_SDK_LOG_LEVEL`                     | `error`                                      | SDK log level: silent, error, warn, info, debug, trace, or silly.                                                                                                                                                                                                         |
| `CAMUNDA_TOKEN_CACHE_DIR`                   | —                                            | Directory for OAuth token disk cache. Disabled if unset.                                                                                                                                                                                                                  |
| `CAMUNDA_TOKEN_DISK_CACHE_DISABLE`          | `false`                                      | Disable OAuth token disk caching.                                                                                                                                                                                                                                         |
| `CAMUNDA_SDK_BACKPRESSURE_PROFILE`          | `BALANCED`                                   | Backpressure profile: BALANCED (adaptive gating, default) or LEGACY (observe-only, no gating).                                                                                                                                                                            |
| `CAMUNDA_TENANT_ID`                         | —                                            | Default tenant ID applied to all operations that accept a tenant_id parameter.                                                                                                                                                                                            |
| `CAMUNDA_TENANT_IDS`                        | —                                            | Default tenant IDs applied to operations whose request body accepts a plural `tenantIds` array (currently job activation). Accepts a comma-separated list when supplied via environment variable. Falls back to `[CAMUNDA_TENANT_ID]` when only the singular form is set. |
| `CAMUNDA_WORKER_TIMEOUT`                    | —                                            | Default job timeout in milliseconds for all workers.                                                                                                                                                                                                                      |
| `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS`        | —                                            | Default maximum concurrent jobs per worker.                                                                                                                                                                                                                               |
| `CAMUNDA_WORKER_REQUEST_TIMEOUT`            | —                                            | Default long-poll request timeout in milliseconds for all workers.                                                                                                                                                                                                        |
| `CAMUNDA_WORKER_NAME`                       | —                                            | Default worker name for all workers.                                                                                                                                                                                                                                      |
| `CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS` | —                                            | Default maximum startup jitter in seconds for all workers.                                                                                                                                                                                                                |
| `CAMUNDA_MTLS_CERT_PATH`                    | —                                            | Path to client certificate (PEM) for mTLS.                                                                                                                                                                                                                                |
| `CAMUNDA_MTLS_KEY_PATH`                     | —                                            | Path to client private key (PEM) for mTLS.                                                                                                                                                                                                                                |
| `CAMUNDA_MTLS_CA_PATH`                      | —                                            | Path to CA certificate bundle (PEM) for mTLS. Optional.                                                                                                                                                                                                                   |
| `CAMUNDA_MTLS_CERT`                         | —                                            | Inline PEM client certificate. Overrides CAMUNDA_MTLS_CERT_PATH.                                                                                                                                                                                                          |
| `CAMUNDA_MTLS_KEY`                          | —                                            | Inline PEM client private key. Overrides CAMUNDA_MTLS_KEY_PATH.                                                                                                                                                                                                           |
| `CAMUNDA_MTLS_CA`                           | —                                            | Inline PEM CA bundle. Overrides CAMUNDA_MTLS_CA_PATH.                                                                                                                                                                                                                     |
| `CAMUNDA_MTLS_KEY_PASSPHRASE`               | —                                            | Passphrase for encrypted private key.                                                                                                                                                                                                                                     |
| `CAMUNDA_LOAD_ENVFILE`                      | —                                            | Load configuration from a `.env` file. Set to `true` (or a file path).                                                                                                                                                                                                    |

<!-- END_CONFIG_REFERENCE -->

---

## Creating a Process Instance(Python-sdk)


The recommended pattern is to obtain keys from a prior API response (e.g. a deployment) and pass them directly — no manual lifting needed:

<!-- snippet-source: examples/readme.py | regions: ReadmeCreateProcessInstance -->

```python
from camunda_orchestration_sdk import CamundaClient, ProcessCreationByKey

with CamundaClient() as client:
    # Deploy and capture the typed key
    deployment = client.deploy_resources_from_files(["process.bpmn"])
    process_key = deployment.processes[0].process_definition_key

    # Use it directly — the type flows through without conversion
    result = client.create_process_instance(
        data=ProcessCreationByKey(process_definition_key=process_key)
    )
    print(f"Process instance key: {result.process_instance_key}")
```

If you need to restore a key from external storage (database, message queue, config file), use the semantic type constructor. Validation runs automatically:

<!-- snippet-source: examples/readme.py | regions: ReadmeCreateFromStorage -->

```python
from camunda_orchestration_sdk import CamundaClient, ProcessCreationByKey, ProcessDefinitionKey

with CamundaClient() as client:
    stored_key = "2251799813685249"  # from a DB row or config
    result = client.create_process_instance(
        data=ProcessCreationByKey(process_definition_key=ProcessDefinitionKey(stored_key))
    )
    print(f"Process instance key: {result.process_instance_key}")
```

**Migrating from pre-release versions:** Early pre-release builds exported `lift_*` helper functions (e.g., `lift_process_definition_key`). These have been removed — use the type constructor directly instead: `ProcessDefinitionKey(value)`. The constructor performs the same validation and is the single API surface for semantic types.

---

## Deploying Resources(Python-sdk)


Deploy BPMN, DMN, or Form files from disk:

<!-- snippet-source: examples/readme.py | regions: ReadmeDeployResources -->

```python
from camunda_orchestration_sdk import CamundaClient

with CamundaClient() as client:
    result = client.deploy_resources_from_files(["process.bpmn", "decision.dmn"])

    print(f"Deployment key: {result.deployment_key}")
    for process in result.processes:
        print(f"  Process: {process.process_definition_id} (key: {process.process_definition_key})")
```

---

## Error Handling


The SDK raises typed exceptions for API errors. Each HTTP error status code has a corresponding exception class (e.g. `BadRequestError` for 400, `NotFoundError` for 404). Every exception carries the `operation_id` of the method that raised it:

<!-- snippet-source: examples/readme.py | regions: ReadmeErrorHandling -->

```python
from camunda_orchestration_sdk import CamundaClient, ProcessCreationByKey, ProcessDefinitionKey
from camunda_orchestration_sdk.errors import BadRequestError

process_definition_key = ProcessDefinitionKey("2251799813685249")

with CamundaClient() as client:
    try:
        result = client.create_process_instance(
            data=ProcessCreationByKey(process_definition_key=process_definition_key)
        )
    except BadRequestError as e:
        print(f"Bad request ({e.operation_id}): {e}")
```

---

## Eventual Consistency


Some Camunda endpoints — particularly search and "get by key" operations — are eventually consistent: data written via one API call may not be immediately visible to a follow-up read. Endpoints flagged as eventually consistent in the OpenAPI spec accept an optional `consistency` parameter that transparently polls until the data is visible (or a timeout is reached).

The `consistency` parameter is fully optional and defaults to `None`, so existing call sites continue to work unchanged.

<!-- snippet-source: examples/readme.py | regions: ReadmeEventualConsistency -->

```python
from camunda_orchestration_sdk import CamundaClient
from camunda_orchestration_sdk.models import (
    ProcessInstanceSearchQuery,
    ProcessInstanceSearchQueryFilter,
)
from camunda_orchestration_sdk.runtime.eventual import (
    ConsistencyOptions,
    EventualConsistencyTimeoutError,
)

with CamundaClient() as client:
    try:
        result = client.search_process_instances(
            data=ProcessInstanceSearchQuery(
                filter_=ProcessInstanceSearchQueryFilter(
                    process_definition_id="order-process",
                ),
            ),
            # Opt in to transparent polling. Default predicate accepts the
            # first response whose `items` list is non-empty.
            consistency=ConsistencyOptions(
                wait_up_to_ms=5000,
                poll_interval_ms=200,
            ),
        )
        for instance in result.items:
            print(instance.process_instance_key)
    except EventualConsistencyTimeoutError as exc:
        print(f"Timed out after {exc.elapsed_ms}ms ({exc.attempts} attempts)")
```

For non-GET endpoints (search/list) the default predicate succeeds on the first response whose `items` list is non-empty. For GET endpoints it succeeds on any non-`None` result and transparently retries `404 Not Found` while waiting. Pass a custom `predicate` to wait for a more specific condition:

<!-- snippet-source: examples/readme.py | regions: ReadmeEventualConsistencyPredicate -->

```python
from camunda_orchestration_sdk import CamundaClient
from camunda_orchestration_sdk.models import (
    ProcessInstanceSearchQuery,
    ProcessInstanceSearchQueryFilter,
)
from camunda_orchestration_sdk.runtime.eventual import ConsistencyOptions

with CamundaClient() as client:
    # Wait until at least 3 instances are visible.
    result = client.search_process_instances(
        data=ProcessInstanceSearchQuery(
            filter_=ProcessInstanceSearchQueryFilter(
                process_definition_id="order-process",
            ),
        ),
        consistency=ConsistencyOptions(
            wait_up_to_ms=10_000,
            poll_interval_ms=250,
            predicate=lambda r: len(r.items) >= 3,
        ),
    )
    print(f"Got {len(result.items)} instances")
```

`ConsistencyOptions` fields:

| Field              | Type                          | Default    | Description                                        |
| ------------------ | ----------------------------- | ---------- | -------------------------------------------------- |
| `wait_up_to_ms`    | `int`                         | _required_ | Maximum time to wait. `0` skips polling entirely.  |
| `poll_interval_ms` | `int`                         | `500`      | Delay between polling attempts (minimum 10ms).     |
| `predicate`        | `Callable[[T], bool] \| None` | `None`     | Custom success check. Defaults as described above. |

Polling aborts immediately on `400`, `401`, `403`, `409`, `422`, and `5xx` responses. `429` responses are retried with backoff. On timeout the SDK raises `EventualConsistencyTimeoutError`, which exposes `attempts`, `elapsed_ms`, `last_status`, and `operation_id`.

The same parameter is available on `CamundaAsyncClient` and behaves identically using `asyncio.sleep` for the polling delay.

---

## Installing the SDK to your project


## Requirements

- Python 3.10 or later

## Stable release (recommended for production)

The stable version tracks the latest supported Camunda server release. The first stable release will be **8.9.0**.

```bash
pip install camunda-orchestration-sdk
```

## Pre-release / dev channel

Pre-release versions (e.g. `8.9.0.dev2`) are published from the `main` branch and contain the latest changes targeting the next server minor version. Use these to preview upcoming features or validate your integration ahead of a stable release.

```bash
# pip
pip install --pre camunda-orchestration-sdk

# pin to a specific pre-release
pip install camunda-orchestration-sdk==8.9.0.dev2
```

In a `requirements.txt`:

```text
camunda-orchestration-sdk>=8.9.0.dev1
```

> **Note:** Pre-release versions may contain breaking changes between builds. Pin to a specific version if you need reproducible builds.

## Versioning

This SDK has a different release cadence from the Camunda server. Features and fixes land in the SDK during a server release.

The major version of the SDK signals a 1:1 type coherence with the server API for a Camunda minor release.

SDK version `n.y.z` -> server version `8.n`, so the type surface of SDK version 9.y.z matches the API surface of Camunda 8.9.

Using a later SDK version, for example: SDK version 10.y.z with Camunda 8.9, means that the SDK contains additive surfaces that are not guaranteed at runtime, and the compiler cannot warn of unsupported operations.

Using an earlier SDK version, for example: SDK version 9.y.z with Camunda 8.10, results in slightly degraded compiler reasoning: exhaustiveness checks cannot be guaranteed by the compiler for any extended surfaces (principally, enums with added members).

In the vast majority of use-cases, this will not be an issue; but you should be aware that using the matching SDK major version for the server minor version provides the strongest compiler guarantees about runtime reliability.

**Recommended approach**:

- Check the [CHANGELOG](https://github.com/camunda/orchestration-cluster-api-python/releases).
- As a sanity check during server version upgrade, rebuild applications with the matching SDK major version to identify any affected runtime surfaces.

---

## Job Workers(Python-sdk)


Job workers long-poll for available jobs, execute a callback, and automatically complete or fail the job based on the return value. Workers are available on `CamundaAsyncClient`.

Handlers receive a context object that includes a `client` reference, so your handler can make API calls during job execution. The context type depends on the execution strategy:

- **Async handlers** → `ConnectedJobContext` with `client: CamundaAsyncClient` (use `await`)
- **Thread handlers** → `SyncJobContext` with `client: CamundaClient` (call directly)
- **Process handlers** → plain `JobContext` (no client — cannot be pickled across process boundaries)

<!-- snippet-source: examples/readme.py | regions: ReadmeJobWorker -->

```python

from camunda_orchestration_sdk import CamundaAsyncClient, ConnectedJobContext, WorkerConfig

async def handle_job(job_context: ConnectedJobContext) -> dict[str, object]:
    variables = job_context.variables.to_dict()
    job_context.log.info(f"Processing job {job_context.job_key}: {variables}")
    return {"result": "processed"}

async def main() -> None:
    async with CamundaAsyncClient() as client:
        config = WorkerConfig(
            job_type="my-service-task",
            job_timeout_milliseconds=30_000,
        )
        client.create_job_worker(config=config, callback=handle_job)

        # Keep workers running until cancelled
        await client.run_workers()

asyncio.run(main())
```

## Using the Client in a Job Handler

Because `ConnectedJobContext` and `SyncJobContext` include a `client` reference, your handler can make API calls during job execution — for example, publishing a message to trigger another part of the process.

**Async handlers** (`execution_strategy="async"`) — `await` the client method directly:

<!-- snippet-source: examples/readme.py | regions: ReadmeAsyncHandler -->

```python
from camunda_orchestration_sdk import ConnectedJobContext, MessagePublicationRequest, MessagePublicationRequestVariables

async def handle_order(job: ConnectedJobContext) -> dict[str, object]:
    variables = job.variables.to_dict()
    order_id = variables["orderId"]

    await job.client.publish_message(
        data=MessagePublicationRequest(
            name="order-processed",
            correlation_key=order_id,
            time_to_live=60000,
            variables=MessagePublicationRequestVariables.from_dict({"orderId": order_id, "status": "completed"}),
        )
    )

    job.log.info(f"Published order-processed message for order {order_id}")
    return {"status": "done"}
```

**Sync (thread) handlers** (`execution_strategy="thread"`) — `job.client` is a sync `CamundaClient`, so call methods directly:

<!-- snippet-source: examples/readme.py | regions: ReadmeSyncHandler -->

```python
from camunda_orchestration_sdk import MessagePublicationRequest, MessagePublicationRequestVariables, SyncJobContext

def handle_order(job: SyncJobContext) -> dict[str, object]:
    variables = job.variables.to_dict()
    order_id = variables["orderId"]

    job.client.publish_message(
        data=MessagePublicationRequest(
            name="order-processed",
            correlation_key=order_id,
            time_to_live=60000,
            variables=MessagePublicationRequestVariables.from_dict({"orderId": order_id, "status": "completed"}),
        )
    )

    job.log.info(f"Published order-processed message for order {order_id}")
    return {"status": "done"}
```

> **Note:** The SDK automatically provides the right client type for each strategy — async handlers get `CamundaAsyncClient` (use `await`), thread handlers get `CamundaClient` (call directly). You don't need to create or manage these clients yourself.

## Job Logger

Each `JobContext` exposes a `log` property — a scoped logger automatically bound with the job's context (job type, worker name, and job key). Use it inside your handler for structured, per-job log output:

<!-- snippet-source: examples/readme.py | regions: ReadmeJobLogger -->

```python
async def handler(job: ConnectedJobContext) -> dict[str, object]:
    job.log.info(f"Starting work on {job.job_key}")
    # ... do work ...
    job.log.debug("Work completed successfully")
    return {"done": True}
```

The job logger inherits the SDK's logger configuration (loguru by default, or whatever you passed via `logger=`). If you injected a custom logger into the client, job handlers will use a child of that same logger.

> **Note:** When using the `"process"` execution strategy, the job logger silently degrades to a no-op (`NullLogger`) because loggers cannot be pickled across process boundaries. The worker's main-process logger still records all job lifecycle events (activation, completion, failure, errors). If you need per-job logging from a process-isolated handler, configure a logger inside the handler itself.

## Execution Strategies

Job workers support multiple execution strategies to match your workload type. Pass `execution_strategy` as a keyword argument to `create_job_worker`, or let the SDK auto-detect.

| Strategy           | How it runs your handler                                                       | Context type                              | Best for                                                                                                             |
| ------------------ | ------------------------------------------------------------------------------ | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `"auto"` (default) | Auto-detects: `"async"` for `async def` handlers, `"thread"` for sync handlers | `ConnectedJobContext` or `SyncJobContext` | Most use cases — sensible defaults without configuration                                                             |
| `"async"`          | Runs on the main `asyncio` event loop                                          | `ConnectedJobContext` (async client)      | I/O-bound async work (HTTP calls, database queries). Best throughput for handlers that call remote systems over HTTP |
| `"thread"`         | Runs in a `ThreadPoolExecutor`                                                 | `SyncJobContext` (sync client)            | CPU-bound work, blocking I/O (file system, synchronous HTTP libraries)                                               |
| `"process"`        | Runs in a `ProcessPoolExecutor`                                                | `JobContext` (no client)                  | Heavy CPU-bound work that needs to escape the GIL (image processing, ML inference)                                   |

> **Choosing between `"async"` and `"thread"`:** If your job handler makes HTTP calls to remote systems (APIs, databases, microservices), `"async"` delivers the best performance — it can multiplex many concurrent jobs on a single thread without blocking. Use `"thread"` when your handler performs CPU-bound computation or calls synchronous libraries that would block the event loop.

**Auto-detection logic:** If your handler is an `async def`, the strategy defaults to `"async"`. If it's a regular `def`, the strategy defaults to `"thread"`. You can override this explicitly:

<!-- snippet-source: examples/readme.py | regions: ReadmeExecutionStrategies -->

```python
from camunda_orchestration_sdk import SyncJobContext, JobContext

# Force thread pool for a sync handler (receives SyncJobContext)
def io_handler(job: SyncJobContext) -> dict[str, object]:
    return {"done": True}

client.create_job_worker(
    config=WorkerConfig(job_type="io-bound-task", job_timeout_milliseconds=30_000),
    callback=io_handler,
    execution_strategy="thread",
)

# Force process pool for CPU-heavy work (receives plain JobContext)
def cpu_handler(job: JobContext) -> dict[str, object]:
    return {"computed": True}

client.create_job_worker(
    config=WorkerConfig(job_type="image-processing", job_timeout_milliseconds=120_000),
    callback=cpu_handler,
    execution_strategy="process",
)
```

**Process strategy caveats:** The `"process"` strategy serialises (pickles) your handler and its context to send them to a worker process. Because the SDK client cannot be pickled, handlers running under this strategy receive a plain `JobContext` (without a `client` attribute) instead of `ConnectedJobContext`/`SyncJobContext`. This means:

- Your handler function and its closure must be picklable (top-level functions work; lambdas and closures over unpicklable objects do not).
- Your handler must accept `JobContext`, not `ConnectedJobContext` or `SyncJobContext` — the type checker enforces this via overloaded signatures on `create_job_worker`.
- `job.log` degrades to a silent no-op logger in the child process (see [Job Logger](#job-logger)).
- There is additional overhead per job from serialisation and inter-process communication.

## Worker Configuration

`WorkerConfig` supports:

| Parameter                      | Default                             | Description                                    |
| ------------------------------ | ----------------------------------- | ---------------------------------------------- |
| `job_type`                     | _(required)_                        | The BPMN service task type to poll for         |
| `job_timeout_milliseconds`     | env / _(required)_                  | How long the worker has to complete the job    |
| `request_timeout_milliseconds` | env / `0`                           | Long-poll request timeout (0 = server default) |
| `max_concurrent_jobs`          | env / `10`                          | Maximum jobs executing concurrently            |
| `fetch_variables`              | `None`                              | List of variable names to fetch (None = all)   |
| `worker_name`                  | env / `"camunda-python-sdk-worker"` | Identifier for this worker in Camunda          |

The following are keyword-only arguments on `create_job_worker`, not part of `WorkerConfig`:

| Parameter                    | Default   | Description                                                                                                                                                                                                                                               |
| ---------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `execution_strategy`         | `"auto"`  | `"auto"`, `"async"`, `"thread"`, or `"process"`. Controls how the handler is invoked and which context type it receives.                                                                                                                                  |
| `startup_jitter_max_seconds` | env / `0` | Maximum random delay (in seconds) before the worker starts polling. When multiple application instances restart simultaneously, this spreads out initial activation requests to avoid saturating the server. A value of `0` (the default) means no delay. |

### Heritable Worker Defaults

Worker configuration fields marked "env" in the table above can be set globally via environment variables or the client constructor. Individual `WorkerConfig` values take precedence.

| Environment variable                        | Maps to                        |
| ------------------------------------------- | ------------------------------ |
| `CAMUNDA_WORKER_TIMEOUT`                    | `job_timeout_milliseconds`     |
| `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS`        | `max_concurrent_jobs`          |
| `CAMUNDA_WORKER_REQUEST_TIMEOUT`            | `request_timeout_milliseconds` |
| `CAMUNDA_WORKER_NAME`                       | `worker_name`                  |
| `CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS` | `startup_jitter_max_seconds`   |

**Precedence:** explicit `WorkerConfig` value > environment variable / client constructor > hardcoded default.

Example — set defaults via environment variables:

```bash
export CAMUNDA_WORKER_TIMEOUT=30000
export CAMUNDA_WORKER_MAX_CONCURRENT_JOBS=32
```

<!-- snippet-source: examples/readme.py | regions: ReadmeWorkerDefaultsEnv -->

```python
# No need to set job_timeout_milliseconds on every worker — inherited from env
client.create_job_worker(
    config=WorkerConfig(job_type="payment-service"),
    callback=handle_payment,
)
client.create_job_worker(
    config=WorkerConfig(job_type="notification-service"),
    callback=handle_notification,
)
```

Example — set defaults via client constructor:

<!-- snippet-source: examples/readme.py | regions: ReadmeWorkerDefaultsClient -->

```python
client = CamundaAsyncClient(configuration={
    "CAMUNDA_WORKER_TIMEOUT": "30000",
    "CAMUNDA_WORKER_MAX_CONCURRENT_JOBS": "16",
    "CAMUNDA_WORKER_NAME": "my-app",
})

# Both workers inherit timeout, concurrency, and name
client.create_job_worker(
    config=WorkerConfig(job_type="payment-service"),
    callback=handle_payment,
)
client.create_job_worker(
    config=WorkerConfig(job_type="shipping-service"),
    callback=handle_shipping,
)
```

## Failing a Job

To explicitly fail a job with a custom error message, retry count, and backoff, raise `JobFailure` in your handler:

<!-- snippet-source: examples/readme.py | regions: ReadmeFailJob -->

```python
from camunda_orchestration_sdk import ConnectedJobContext, JobFailure

async def handle_job(job: ConnectedJobContext) -> dict[str, object]:
    if not job.variables.to_dict().get("required_field"):
        raise JobFailure(
            message="Missing required field",
            retries=2,
            retry_back_off=5000,  # milliseconds
        )
    return {"result": "ok"}
```

| Parameter        | Default      | Description                                                       |
| ---------------- | ------------ | ----------------------------------------------------------------- |
| `message`        | _(required)_ | Error message attached to the failure                             |
| `retries`        | `None`       | Remaining retries. `None` decrements the current retry count by 1 |
| `retry_back_off` | `0`          | Backoff before the next retry, in milliseconds                    |

If an unhandled exception escapes your handler, the job is automatically failed with the exception message and the retry count decremented by 1.

## Throwing a BPMN Error

To throw a [BPMN error](../../components/modeler/bpmn/error-events/error-events.md) from a job handler — for example, to trigger an error boundary event — raise `JobError`:

<!-- snippet-source: examples/readme.py | regions: ReadmeBpmnError -->

```python
from camunda_orchestration_sdk import ConnectedJobContext, JobError

async def handle_payment(job: ConnectedJobContext) -> dict[str, object]:
    variables = job.variables.to_dict()
    if variables.get("amount", 0) > 10_000:
        raise JobError(error_code="AMOUNT_TOO_HIGH", message="Payment exceeds limit")
    return {"status": "approved"}
```

| Parameter    | Default      | Description                                                    |
| ------------ | ------------ | -------------------------------------------------------------- |
| `error_code` | _(required)_ | The error code that is matched against BPMN error catch events |
| `message`    | `""`         | An optional error message for logging/diagnostics              |

The `error_code` must match the error code defined on a BPMN error catch event in your process model. If no catch event matches, the job becomes an incident.

## Job Corrections (User Task Listeners)

When a job worker handles a [user task listener](../../components/concepts/user-task-listeners.md), it can correct task properties (assignee, due date, candidate groups, etc.) as part of the completion. Return a `JobCompletionRequest` with a `result` containing `JobResultCorrections`:

<!-- snippet-source: examples/readme.py | regions: ReadmeJobCorrections -->

```python
from camunda_orchestration_sdk import ConnectedJobContext
from camunda_orchestration_sdk.models import (
    JobCompletionRequest,
    JobResultUserTask,
    JobResultCorrections,
)

async def validate_task(job: ConnectedJobContext) -> JobCompletionRequest:
    return JobCompletionRequest(
        result=JobResultUserTask(
            type_="userTask",
            corrections=JobResultCorrections(
                assignee="corrected-user",
                priority=80,
            ),
        ),
    )
```

To deny a task completion (reject the work), set `denied=True`:

<!-- snippet-source: examples/readme.py | regions: ReadmeJobCorrectionsDenied -->

```python
async def review_task(job: ConnectedJobContext) -> JobCompletionRequest:
    return JobCompletionRequest(
        result=JobResultUserTask(
            type_="userTask",
            denied=True,
            denied_reason="Insufficient documentation",
        ),
    )
```

| Correctable attribute | Type          | Clear value       |
| --------------------- | ------------- | ----------------- |
| `assignee`            | `str`         | Empty string `""` |
| `due_date`            | `datetime`    | Empty string `""` |
| `follow_up_date`      | `datetime`    | Empty string `""` |
| `candidate_users`     | `list[str]`   | Empty list `[]`   |
| `candidate_groups`    | `list[str]`   | Empty list `[]`   |
| `priority`            | `int` (0–100) | —                 |

Omitting an attribute or passing `None` preserves the persisted value. This works with all handler types (async, thread, and process).

---

## Logging(Python-sdk)


By default the SDK logs via [loguru](https://github.com/Delgan/loguru). You can inject any logger that exposes `debug`, `info`, `warning`, and `error` methods — including Python's built-in `logging.Logger`.

## Using the default logger (loguru)

No configuration needed. Control verbosity with `CAMUNDA_SDK_LOG_LEVEL` or loguru's own `LOGURU_LEVEL` environment variable:

```bash
CAMUNDA_SDK_LOG_LEVEL=debug python your_script.py
```

## Injecting a custom logger

Pass a `logger=` argument to `CamundaClient` or `CamundaAsyncClient`. The logger is forwarded to all internal components (auth providers, HTTP hooks, job workers).

**stdlib `logging`:**

<!-- snippet-source: examples/readme.py | regions: ReadmeStdlibLogger -->

```python

from camunda_orchestration_sdk import CamundaClient

my_logger = logging.getLogger("my_app.camunda")
my_logger.setLevel(logging.DEBUG)

client = CamundaClient(logger=my_logger)
```

**Custom logger object:**

<!-- snippet-source: examples/readme.py | regions: ReadmeCustomLogger -->

```python
from camunda_orchestration_sdk import CamundaClient

class MyLogger:
    def debug(self, msg: object, *args: object, **kwargs: object) -> None:
        print(f"[DEBUG] {msg}")

    def info(self, msg: object, *args: object, **kwargs: object) -> None:
        print(f"[INFO] {msg}")

    def warning(self, msg: object, *args: object, **kwargs: object) -> None:
        print(f"[WARN] {msg}")

    def error(self, msg: object, *args: object, **kwargs: object) -> None:
        print(f"[ERROR] {msg}")

client = CamundaClient(logger=MyLogger())
```

## Disabling logging

Pass an instance of `NullLogger` to silence all SDK output:

<!-- snippet-source: examples/readme.py | regions: ReadmeDisableLogging -->

```python
from camunda_orchestration_sdk import CamundaClient, NullLogger

client = CamundaClient(logger=NullLogger())
```

---

## Migrating from v9 to v10


v10 tracks Camunda 8.10. The 8.10 OpenAPI spec promotes several identifier and name fields from plain strings to **semantic types**. The SDK enforces them at construction time, so any v9 code that passes a plain `str` to these methods will need to wrap the value with the corresponding brand.

## New branded types

| Brand                 | Used for                   |
| --------------------- | -------------------------- |
| `RoleId`              | Role identifiers           |
| `GroupId`             | Group identifiers          |
| `ClientId`            | OAuth client identifiers   |
| `MappingRuleId`       | Mapping-rule identifiers   |
| `ClusterVariableName` | Cluster variable names     |
| `AgentInstanceKey`    | Agent-instance system keys |

## Migration

<!-- snippet-source: examples/readme.py | regions: V9ToV10Migration -->

```python
from camunda_orchestration_sdk import CamundaClient, GroupId, RoleId

with CamundaClient() as client:
    # v9 — plain strings were accepted:
    # client.assign_role_to_group(role_id="developer", group_id="engineering")

    # v10 — wrap with the branded type constructor at the boundary
    client.assign_role_to_group(
        role_id=RoleId("developer"),
        group_id=GroupId("engineering"),
    )
```

The brand constructors are subclasses of `str`, so the wrapped values remain valid where a `str` is expected (f-strings, logging, JSON serialisation). The wrap exists to enforce the upstream pattern and length constraints once, at the boundary, so a malformed identifier fails fast with `ValueError` instead of producing an HTTP 400 from the cluster.

## Deprecated model class renames

26 model classes were renamed in v10 to match upstream conventions. The old names continue to work with a deprecation warning and will be removed in v11. No action is required to upgrade — but updating imports is recommended.

| Old name (deprecated)                    | New name                                      |
| ---------------------------------------- | --------------------------------------------- |
| `CreateMappingRuleResponse201`           | `MappingRuleCreateResult`                     |
| `GetUserResponse200`                     | `UserResult`                                  |
| `SearchClientsForGroupData`              | `GroupClientSearchQueryRequest`               |
| `SearchClientsForGroupResponse200`       | `GroupClientSearchResult`                     |
| `SearchClientsForRoleData`               | `RoleClientSearchQueryRequest`                |
| `SearchClientsForRoleResponse200`        | `RoleClientSearchResult`                      |
| `SearchClientsForTenantData`             | `TenantClientSearchQueryRequest`              |
| `SearchClientsForTenantResponse200`      | `TenantClientSearchResult`                    |
| `SearchMappingRuleResponse200`           | `MappingRuleSearchQueryResult`                |
| `SearchMappingRulesForGroupResponse200`  | `GroupMappingRuleSearchResult`                |
| `SearchMappingRulesForRoleResponse200`   | `RoleMappingRuleSearchResult`                 |
| `SearchMappingRulesForTenantResponse200` | `TenantMappingRuleSearchResult`               |
| `SearchRolesForGroupResponse200`         | `GroupRoleSearchResult`                       |
| `SearchRolesForTenantResponse200`        | `TenantRoleSearchResult`                      |
| `SearchUserTaskEffectiveVariablesData`   | `UserTaskEffectiveVariableSearchQueryRequest` |
| `SearchUserTaskVariablesData`            | `UserTaskVariableSearchQueryRequest`          |
| `SearchUsersForGroupData`                | `GroupUserSearchQueryRequest`                 |
| `SearchUsersForGroupResponse200`         | `GroupUserSearchResult`                       |
| `SearchUsersForRoleData`                 | `RoleUserSearchQueryRequest`                  |
| `SearchUsersForRoleResponse200`          | `RoleUserSearchResult`                        |
| `SearchUsersForTenantData`               | `TenantUserSearchQueryRequest`                |
| `SearchUsersForTenantResponse200`        | `TenantUserSearchResult`                      |
| `SearchUsersResponse200`                 | `UserSearchResult`                            |
| `SearchVariablesData`                    | `VariableSearchQuery`                         |
| `UpdateMappingRuleResponse200`           | `MappingRuleUpdateResult`                     |
| `UpdateUserResponse200`                  | `UserUpdateResult`                            |

The following 3 request body classes were removed entirely (the upstream operations no longer take a request body). These cannot be aliased and are a hard break:

- `CancelProcessInstanceData`
- `DeleteDecisionInstanceData`
- `DeleteProcessInstanceData`

## What does NOT change

- The wire format is unchanged — all values are still strings on the wire.
- No method signatures changed name or arity.
- Branded values are assignable anywhere a `str` is expected, so existing string-handling code continues to work.
- Existing valid v9 values continue to satisfy the new constraints (the patterns are permissive supersets of typical identifiers).

See [`semantic_types.py`](https://github.com/camunda/orchestration-cluster-api-python/blob/main/generated/camunda_orchestration_sdk/semantic_types.py) for the canonical list of brands and their constraints.

---

## Programmatic configuration (use sparingly)


Only use `configuration={...}` when you must supply or mutate configuration dynamically (e.g. tests, multi-tenant routing, or ephemeral preview environments). Keys mirror their `CAMUNDA_*` environment names.

<!-- snippet-source: examples/readme.py | regions: ReadmeProgrammaticConfig -->

```python
from camunda_orchestration_sdk import CamundaClient

client = CamundaClient(
    configuration={
        "CAMUNDA_REST_ADDRESS": "http://localhost:8080/v2",
        "CAMUNDA_AUTH_STRATEGY": "NONE",
    }
)
```

---

## Quick start (Zero-config – recommended)


Keep configuration out of application code. Let the client read `CAMUNDA_*` variables from the environment (12-factor style). This makes secret rotation, environment promotion (dev → staging → prod), and operational tooling (vaults / secret managers) safer and simpler.

If no configuration is present, the SDK defaults to a local Camunda 8 Run-style endpoint at `http://localhost:8080/v2`.

<!-- snippet-source: examples/readme.py | regions: ReadmeZeroConfig -->

```python
from camunda_orchestration_sdk import CamundaAsyncClient, CamundaClient

# Zero-config construction: reads CAMUNDA_* from the environment
client = CamundaClient()
async_client = CamundaAsyncClient()
```

Typical `.env` (example):

```bash
CAMUNDA_REST_ADDRESS=https://cluster.example/v2
CAMUNDA_AUTH_STRATEGY=OAUTH
CAMUNDA_CLIENT_ID=***
CAMUNDA_CLIENT_SECRET=***
```

### Loading configuration from a `.env` file (`CAMUNDA_LOAD_ENVFILE`)

The SDK can optionally load configuration values from a dotenv file.

- Set `CAMUNDA_LOAD_ENVFILE=true` (or `1` / `yes`) to load `.env` from the current working directory.
- Set `CAMUNDA_LOAD_ENVFILE=/path/to/file.env` to load from an explicit path.
- If the file does not exist, it is silently ignored.
- Precedence is: `.env` < environment variables < explicit `configuration={...}` passed to the client.
- The resolver reads dotenv values without mutating `os.environ`.

Example `.env`:

```bash
CAMUNDA_REST_ADDRESS=http://localhost:8080/v2
CAMUNDA_CLIENT_ID=your-client-id
CAMUNDA_CLIENT_SECRET=your-client-secret
```

Enable loading from the current directory:

```bash
export CAMUNDA_LOAD_ENVFILE=true
python your_script.py
```

Or enable loading from a specific file:

```bash
export CAMUNDA_LOAD_ENVFILE=~/camunda/dev.env
python your_script.py
```

You can also enable it via the explicit configuration dict:

<!-- snippet-source: examples/readme.py | regions: ReadmeEnvFileLoading -->

```python
from camunda_orchestration_sdk import CamundaClient

client = CamundaClient(configuration={"CAMUNDA_LOAD_ENVFILE": "true"})
```

---

## Self-signed TLS / mTLS(Python-sdk)


The SDK supports custom TLS certificates via environment variables. This is useful for:

- **Self-signed server certificates** — trust a CA that signed your server's certificate, without presenting a client identity.
- **Mutual TLS (mTLS)** — present a client certificate and key to prove the client's identity.
- **Both** — trust a custom CA _and_ present client credentials.

## Trusting a self-signed server certificate

Set only the CA certificate to trust the server's self-signed certificate:

```bash
# Path to PEM file:
CAMUNDA_MTLS_CA_PATH=/path/to/ca.pem

# Or inline PEM:
CAMUNDA_MTLS_CA="-----BEGIN CERTIFICATE-----\n..."
```

## Mutual TLS (client certificate)

To present a client certificate for mutual TLS, provide both the certificate and private key:

```bash
CAMUNDA_MTLS_CERT_PATH=/path/to/client.crt
CAMUNDA_MTLS_KEY_PATH=/path/to/client.key

# Optional — passphrase if the key is encrypted:
# CAMUNDA_MTLS_KEY_PASSPHRASE=secret
```

## Full mTLS with custom CA

Combine a custom CA with client credentials:

```bash
CAMUNDA_MTLS_CA_PATH=/path/to/ca.pem
CAMUNDA_MTLS_CERT_PATH=/path/to/client.crt
CAMUNDA_MTLS_KEY_PATH=/path/to/client.key
```

Inline PEM values (`CAMUNDA_MTLS_CERT`, `CAMUNDA_MTLS_KEY`, `CAMUNDA_MTLS_CA`) take precedence over their `_PATH` counterparts.

No code changes are needed — the SDK picks up TLS configuration from environment variables automatically:

<!-- snippet-exempt: trivial env-var usage illustration -->

```python
from camunda_orchestration_sdk import CamundaClient

client = CamundaClient()  # TLS configured from env vars
```

---

## Semantic Types(Python-sdk)


The SDK uses distinct types for identifiers like `ProcessDefinitionKey`, `ProcessInstanceKey`, `JobKey`, `TenantId`, etc., defined in `camunda_orchestration_sdk.semantic_types` and re-exported from the top-level package. These types inherit from `str`, so they serialize transparently to/from JSON and are compatible with any code expecting a string.

## Why they exist

Camunda's API has many operations that accept string keys — process definition keys, process instance keys, incident keys, job keys, and so on. Without semantic types, it is easy to accidentally pass a process instance key where a process definition key is expected, or mix up a job key with an incident key. The type checker cannot help you if everything is `str`.

Semantic types make these identifiers **distinct at the type level**. Pyright (and other type checkers) will flag an error if you pass a `ProcessInstanceKey` where a `ProcessDefinitionKey` is expected, catching bugs before runtime.

## How to use them

Treat semantic types as **opaque identifiers** — receive them from API responses and pass them to subsequent API calls without inspecting or transforming the underlying value:

<!-- snippet-source: examples/readme.py | regions: ReadmeSemanticTypes -->

```python
from camunda_orchestration_sdk import CamundaClient, ProcessCreationByKey

client = CamundaClient()

# Deploy → the response already carries typed keys
deployment = client.deploy_resources_from_files(["process.bpmn"])
process_key = deployment.processes[0].process_definition_key  # ProcessDefinitionKey

# Pass it directly to another call — no conversion needed
result = client.create_process_instance(
    data=ProcessCreationByKey(process_definition_key=process_key)
)

# The result also carries typed keys
instance_key = result.process_instance_key  # ProcessInstanceKey
client.cancel_process_instance(process_instance_key=instance_key)
```

## Serialising in and out of the type system

Semantic types inherit from `str` and validate on construction, so they work transparently:

<!-- snippet-exempt: uses hypothetical db.save/db.load pseudo-code -->

```python
from camunda_orchestration_sdk import ProcessDefinitionKey, ProcessInstanceKey

# --- Serialising out (to storage / JSON / message queue) ---
# A semantic type IS a str, so it works directly with any str API:
process_key: ProcessDefinitionKey = deployment.processes[0].process_definition_key
db.save("process_key", process_key)   # stores the raw string
json.dumps({"key": process_key})      # "2251799813685249"

# --- Deserialising in (from storage / external input) ---
# Wrap the raw string with the type constructor (validates automatically):
raw = db.load("process_key")           # returns a plain str
typed_key = ProcessDefinitionKey(raw)  # validates and wraps the value

result = client.create_process_instance(
    data=ProcessCreationByKey(process_definition_key=typed_key)
)
```

The available semantic types include: `ProcessDefinitionKey`, `ProcessDefinitionId`, `ProcessInstanceKey`, `JobKey`, `IncidentKey`, `DecisionDefinitionKey`, `DecisionDefinitionId`, `DeploymentKey`, `UserTaskKey`, `MessageKey`, `SignalKey`, `TenantId`, `ElementId`, `FormKey`, and others. All are importable from `camunda_orchestration_sdk` or `camunda_orchestration_sdk.semantic_types`.

---

## Using the SDK


The SDK provides two clients with identical API surfaces:

- **`CamundaClient`** — synchronous. Every method blocks until the response arrives. Use this in scripts, CLI tools, Django views, Flask handlers, or anywhere you don't have an async event loop.
- **`CamundaAsyncClient`** — asynchronous (`async`/`await`). Every method is a coroutine. Use this in FastAPI, aiohttp, or any `asyncio`-based application. **Job workers require `CamundaAsyncClient`** because they use `asyncio` for long-polling and concurrent job execution.

Both clients share the same method names and parameters — the only difference is calling convention:

<!-- snippet-source: examples/readme.py | regions: ReadmeSyncClient -->

```python
# Sync
from camunda_orchestration_sdk import CamundaClient

with CamundaClient() as client:
    topology = client.get_topology()
```

<!-- snippet-source: examples/readme.py | regions: ReadmeAsyncClient -->

```python
# Async

from camunda_orchestration_sdk import CamundaAsyncClient

async def main() -> None:
    async with CamundaAsyncClient() as client:
        topology = await client.get_topology()

asyncio.run(main())
```

> **Which one should I use?** If your application already uses `asyncio` (FastAPI, aiohttp, etc.) or you need job workers, use `CamundaAsyncClient`. Otherwise, `CamundaClient` is simpler and works everywhere.

---

## Python SDK

# Camunda Orchestration Cluster API – Python SDK

<!-- WARNING: The content and specific structure of this file drives Docusaurus generation in camunda-docs. Also, code examples are injected during build. Please refer to MAINTAINER.md before editing. -->

A fully typed Python client for the [Camunda 8 Orchestration Cluster REST API](../apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md). Fully compliant with the Camunda OpenAPI spec with hand-written runtime infrastructure for authentication, configuration, and job workers.

- **Sync and async** — `CamundaClient` (synchronous) and `CamundaAsyncClient` (async/await)
- **Strict typing** — ty + pyright compatible with PEP 561 `py.typed` marker
- **Zero-config** — reads `CAMUNDA_*` environment variables (12-factor style)
- **Job workers** — long-poll workers with thread, process, or async execution strategies
- **OAuth & Basic auth** — pluggable authentication with automatic token management
- **Pluggable logging** — inject your own logger (stdlib `logging`, loguru, or custom)

---

## Migrate from the removed Tasklist API

:::warning
The Tasklist API was removed in Camunda 8.10 and is no longer part of the current documentation set.
:::

For the release-level summary of this removal, see the [8.10 release announcement](/reference/announcements-release-notes/8100/8100-announcements.md#removal-of-legacy-apis-tasklist-v1-dependent-features-and-zeebe-process-test).

Use the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) to build current task applications, and review [migrating to the Orchestration Cluster REST API](/apis-tools/migration-manuals/migrate-to-camunda-api.md) if you still have clients that call the removed Tasklist API.

For current Tasklist behavior, see [Tasklist API changes](/components/tasklist/api-versions.md) and [user task authorization](/components/tasklist/user-task-authorization.md).

---

## Assertions

The class `CamundaAssert` is the entry point for all assertions. It is based on [AssertJ](https://github.com/assertj/assertj) and [Awaitility](http://www.awaitility.org/).

The assertions follow the style: `assertThat(object_to_test)` + expected property.

Use the assertions by adding the following static import in your test class:

```java

```

:::info Assertions are blocking
Camunda executes BPMN processes asynchronously. For testing, this means that there might be a delay between creating a process instance and reaching the expected state.

The assertions handle the asynchronous behavior and wait until the expected property is fulfilled. Only if the property is not fulfilled within the given time, the assertion fails.
:::

:::tip
CPT provides the most common assertions. However, if you miss an assertion you can implement a [custom assertion](#custom-assertions) yourself.
:::

## Configuration

You can configure the behavior of the assertions in the following ways.

### Assertion timeout

By default, assertions wait 10 seconds for the expected property to be fulfilled and wait 100 milliseconds between two attempts. You can change these defaults globally in the configuration or per assertion.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

Configure the assertions globally in your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    assertion:
      # Set the assertion timeout to 1 minute
      timeout: PT1M
      # Set the assertion interval to 100 milliseconds
      interval: PT0.1S
```

</TabItem>

<TabItem value='java-client'>

Configure the assertions globally in your `/camunda-container-runtime.properties` file:

```properties
# Set the assertion timeout to 1 minute
assertion.timeout=PT1M
# Set the assertion interval to 100 milliseconds
assertion.interval=PT0.1S
```

</TabItem>

</Tabs>

Alternatively, you can configure the assertions within your test class using `CamundaAssert`.

```java
@BeforeAll
static void configureAssertions() {
    // Set the assertion timeout to 1 minute
    CamundaAssert.setAssertionTimeout(Duration.ofMinutes(1));
    // Set the assertion interval to 100 milliseconds
    CamundaAssert.setAssertionInterval(Duration.ofMillis(100));
}
```

You can override the global timeout for an assertion using `withAssertionTimeout()`. The given timeout applies only to subsequent assertions in the calling chain.

```java
assertThat(processInstance)
    .withAssertionTimeout(Duration.ofMinutes(1))
    .isCompleted();
```

### Element selector

By default, the element instance assertions identify the BPMN elements by their ID. You can change
the [ElementSelector](utilities.md#element-selector) globally in your test class using `CamundaAssert`.

```java
@BeforeAll
static void configureAssertions() {
    // Identify the BPMN elements by their name
    CamundaAssert.setElementSelector(ElementSelectors::byName);
}
```

### Judge configuration

Override the global [judge configuration](configuration.md#judge-configuration) for a single assertion chain using `withJudgeConfig`.

```java
assertThat(processInstance)
    .withJudgeConfig(config -> config.withThreshold(0.9))
    .hasVariableSatisfiesJudge("result", "Contains a valid JSON response with status OK.");
```

### Semantic similarity configuration

Override the global [semantic similarity configuration](configuration.md#semantic-similarity-configuration) for a single assertion chain using `withSemanticSimilarityConfig`.

```java
assertThat(processInstance)
    .withSemanticSimilarityConfig(config -> config.withThreshold(0.9))
    .hasVariableSimilarTo("greeting", "Hello, how can I help you today?");
```

## Process instance assertions

You can verify the process instance state and other properties using `CamundaAssert.assertThat()` or
`CamundaAssert.assertThatProcessInstance()`. Use the process instance creation event or
a [ProcessInstanceSelector](utilities.md#process-instance-selector) to identify the process instance.

### With process instance event

Use the creation event of the create instance command to identify the process instance:

```java
// given/when
ProcessInstanceEvent processInstance =
    client
        .newCreateInstanceCommand()
        .bpmnProcessId("my-process")
        .latestVersion()
        .send()
        .join();

// then
assertThat(processInstance).isActive();
```

### With process instance result

Use the result event of the create instance command to identify the process instance:

```java
// given/when
ProcessInstanceResult processInstance =
    client
        .newCreateInstanceCommand()
        .bpmnProcessId("my-process")
        .latestVersion()
        .withResult()
        .send()
        .join();

// then
assertThat(processInstance).isActive();
```

### With process instance selector

Use a [ProcessInstanceSelector](utilities.md#process-instance-selector) to identify the process instance.

```java
// by process instance key
assertThatProcessInstance(ProcessInstanceSelectors.byKey(processInstanceKey)).isActive();

// by process ID
assertThatProcessInstance(ProcessInstanceSelectors.byProcessId("my-process")).isActive();
```

### isActive

Assert that the process instance is active. The assertion fails if the process instance is completed, terminated, or not created.

```java
assertThat(processInstance).isActive();
```

### isCompleted

Assert that the process instance is completed. The assertion fails if the process instance is active, terminated, or not created.

```java
assertThat(processInstance).isCompleted();
```

### isTerminated

Assert that the process instance is terminated. The assertion fails if the process instance is active, completed, or not created.

```java
assertThat(processInstance).isTerminated();
```

### isCreated

Assert that the process instance is created and either active, completed, or terminated. The assertion fails if the process instance is not created.

```java
assertThat(processInstance).isCreated();
```

### hasActiveIncidents

Assert that the process instance has at least one active incident. The assertion fails if there is no active incident.

```java
assertThat(processInstance).hasActiveIncidents();
```

### hasNoActiveIncidents

Assert that the process instance has no active incidents. The assertion fails if there is any active incident.

```java
assertThat(processInstance).hasNoActiveIncidents();
```

## Element instance assertions

You can verify the element instance states and other properties using `CamundaAssert.assertThat(processInstance)`. Use
the BPMN element ID or a [ElementSelector](utilities.md#element-selector) to identify the elements.

### With BPMN element ID

Use the BPMN element ID to identify the elements:

```java
assertThat(processInstance).hasActiveElements("task_A");
```

You can customize how the elements are identified in the [configuration](#element-selector).

### With element selector

Use a [ElementSelector](utilities.md#element-selector) to identify the elements:

```java
// by BPMN element ID
assertThat(processInstance).hasActiveElements(ElementSelectors.byId("task_A"));

// by BPMN element name
assertThat(processInstance).hasActiveElements(ElementSelectors.byName("A"));
```

### hasActiveElements

Assert that the given BPMN elements of the process instance are active. The assertion fails if at least one element is completed, terminated, or not entered.

```java
assertThat(processInstance).hasActiveElements("task_A", "task_B");
```

### hasActiveElement

Assert that the BPMN element of the process instance is active the given amount of times. The assertion fails if the element is not active or not exactly the given amount of times.

```java
assertThat(processInstance).hasActiveElement("task_A", 2);
```

### hasActiveElementsExactly

Assert that only the given BPMN elements are active. The assertion fails if at least one element is not active, or other elements are active.

```java
assertThat(processInstance).hasActiveElementsExactly("task_A", "task_B");
```

### hasNoActiveElements

Assert that the given BPMN elements are not active. The assertion fails if at least one element is active.

```java
assertThat(processInstance).hasNoActiveElements("task_A", "task_B");
```

### hasNotActivatedElements

Assert that the given BPMN elements are not activated (i.e. not entered). The assertion fails if at least one element is active, completed, or terminated.

This assertion does not wait for the given activities.

```java
assertThat(processInstance).hasNotActivatedElements("task_A", "task_B");
```

### hasCompletedElements

Assert that the given BPMN elements of the process instance are completed. The assertion fails if at least one element is active, terminated, or not entered.

```java
assertThat(processInstance).hasCompletedElements("task_A", "task_B");
```

### hasCompletedElement

Assert that the BPMN element of the process instance is completed the given amount of times. The assertion fails if the element is not completed or not exactly the given amount of times.

```java
assertThat(processInstance).hasCompletedElement("task_A", 2);
```

### hasCompletedElementsInOrder

Assert that the given BPMN elements are completed in order. Elements that do not match any of the given element IDs are ignored. The assertion fails if at least one of the elements is not completed,
or the order is not correct.

```java
assertThat(processInstance).hasCompletedElementsInOrder("task_A", "task_B");
```

### hasTerminatedElements

Assert that the given BPMN elements of the process instance are terminated. The assertion fails if at least one element is active, completed, or not entered.

```java
assertThat(processInstance).hasTerminatedElements("task_A", "task_B");
```

### hasTerminatedElement

Assert that the BPMN element of the process instance is terminated the given amount of times. The assertion fails if the element is not terminated or not exactly the given amount of times.

```java
assertThat(processInstance).hasTerminatedElement("task_A", 2);
```

## Variable assertions

You can verify the process variables using `CamundaAssert.assertThat(processInstance)`. Use the variable name or a [VariableSelector](utilities.md#variable-selector) to identify the variable.

### With variable name

Use the variable name to identify the variable:

```java
assertThat(processInstance).hasVariable("approved", true);
```

### With variable selector

Use a [VariableSelector](utilities.md#variable-selector) to identify the variable:

```java
// by variable name
assertThat(processInstance).hasVariable(VariableSelectors.byName("approved"), true);

// by partial variable value
assertThat(processInstance).hasVariableSatisfies(
    VariableSelectors.byValueContains("order-123"),
    Order.class,
    order -> { });
```

### hasVariableNames

Assert that the process instance has the given variables. The assertion fails if at least one variable doesn't exist.

```java
assertThat(processInstance).hasVariableNames("var1", "var2");
```

### hasVariable

Assert that the process instance has the variable with the given value. The assertion fails if the variable doesn't exist or has a different value.

```java
assertThat(processInstance).hasVariable("var1", 100);
```

### hasVariables

Assert that the process instance has the given variables. The assertion fails if at least one variable doesn't exist or has a different value.

```java
Map<String, Object> expectedVariables = //
assertThat(processInstance).hasVariables(expectedVariables);
```

### hasVariableSatisfies

Assert that the process instance has a variable with a value that satisfies the given requirements. The assertion
transforms the value into the given type. In the consumer, you can use [AssertJ](https://github.com/assertj/assertj) to
verify the value.

The assertion fails if the variable doesn't exist, the value is of a different type, or the value doesn't satisfy the
requirements.

```java
assertThat(processInstance).hasVariableSatisfies("order", Order.class, order -> {
    Assertions.assertThat(order.status()).isEqualTo("approved");
    Assertions.assertThat(order.items())
        .hasSize(3)
        .extracting("name", "quantity")
        .containsExactlyInAnyOrder(
            tuple("Helmet", 1),
            tuple("Flag", 1),
            tuple("Oxygen tank", 3)
        );
});
```

### hasVariableSatisfiesExpression

Assert that the process instance has a variable with a value that satisfies the given FEEL expression.

The expression is evaluated with a context containing the variable under its name. The expression should access the
variable in a Boolean expression, for example, with comparisons. Learn more in the
[FEEL expressions introduction](/components/modeler/feel/language-guide/feel-expressions-introduction.md).

The assertion fails if the variable doesn't exist or the expression doesn't evaluate to `true`.

```java
assertThat(processInstance)
    .hasVariableSatisfiesExpression(
        "order",
        "order.status = \"approved\" and list contains(order.items.name, \"Oxygen tank\")");
```

### hasVariableSatisfiesJudge

Assert that a process variable satisfies a natural language expectation using a configured LLM judge. The expectation is evaluated only once. The assertion
fails if the LLM score is below the configured threshold (default: 0.5). It requires [judge configuration](configuration.md#judge-configuration).

When [document attachment](configuration.md#document-attachment) is enabled, Camunda document references found in the variable value are resolved and their content is passed to the judge.

```java
assertThat(processInstance)
    .hasVariableSatisfiesJudge("result", "Contains a valid JSON response with status OK.");
```

### hasVariableSimilarTo

Assert that a process variable is semantically similar to an expected string using a configured embedding model. The variable value and the expected value are
converted to embeddings, and the cosine similarity is compared against the configured threshold. The assertion fails if the variable doesn't exist or the
similarity score is below the configured threshold (default: 0.5). It requires [semantic similarity configuration](configuration.md#semantic-similarity-configuration).

```java
assertThat(processInstance)
    .hasVariableSimilarTo("greeting", "Hello, how can I help you today?");
```

### hasLocalVariableNames

Assert that the process instance has the local variables in the scope of the given element. Use the BPMN element ID or a
[ElementSelector](utilities.md#element-selector) to identify the element. The assertion fails if at least one variable
doesn't exist.

```java
assertThat(processInstance).hasLocalVariableNames(ElementSelectors.byId("task_A"), "var1", "var2");
```

### hasLocalVariable

Assert that the process instance has the local variable with the value in the scope of the given element. Use the BPMN
element ID or a [ElementSelector](utilities.md#element-selector) to identify the element. The assertion fails if the
variable doesn't exist or has a different value.

```java
assertThat(processInstance).hasLocalVariable(ElementSelectors.byId("task_A"), "var1", 100);
```

### hasLocalVariables

Assert that the process instance has the local variables in the scope of the given element. Use the BPMN element ID or a
[ElementSelector](utilities.md#element-selector) to identify the element. The assertion fails if at least one variable
doesn't exist or has a different value.

```java
Map<String, Object> expectedVariables = //
assertThat(processInstance).hasLocalVariables(ElementSelectors.byId("task_A"), expectedVariables);
```

### hasLocalVariableSatisfies

Assert that the process instance has a local variable in the scope of the given element with a value that satisfies the
given requirements. Use the BPMN element ID or a [ElementSelector](utilities.md#element-selector) to identify the
element. The assertion transforms the value into the given type. In the consumer, you can
use [AssertJ](https://github.com/assertj/assertj) to verify the value.

The assertion fails if the variable doesn't exist, the value is of a different type, or the value doesn't satisfy the
requirements.

```java
assertThat(processInstance).hasLocalVariableSatisfies(
    ElementSelectors.byId("send-email"),
    "to",
    EmailTo.class,
    emailTo -> {
        Assertions.assertThat(emailTo.name()).isEqualTo("Zee");
        Assertions.assertThat(emailTo.email()).isEqualTo("zee@camunda.com");
    });
```

### hasLocalVariableSatisfiesExpression

Assert that the process instance has a local variable in the scope of the given element with a value that satisfies the
given FEEL expression. Use the BPMN element ID or a [ElementSelector](utilities.md#element-selector) to identify the
element.

The expression is evaluated with a context containing the variable under its name. The expression should access the
variable in a Boolean expression, for example, with comparisons. Learn more in the
[FEEL expressions introduction](/components/modeler/feel/language-guide/feel-expressions-introduction.md).

The assertion fails if the variable doesn't exist or the expression doesn't evaluate to `true`.

```java
assertThat(processInstance)
    .hasLocalVariableSatisfiesExpression(
        ElementSelectors.byId("review-order"),
        "order",
        "order.status = \"approved\" and list contains(order.items.name, \"Oxygen tank\")");
```

### hasLocalVariableSatisfiesJudge

Assert that a local variable in the scope of a given element satisfies a natural language expectation using a configured LLM judge. Use the BPMN
element ID or an [element selector](utilities.md#element-selector) to identify the element. The expectation is evaluated only once. The assertion
fails if the LLM score is below the configured threshold (default: 0.5). It requires [judge configuration](configuration.md#judge-configuration).

When [document attachment](configuration.md#document-attachment) is enabled, Camunda document references found in the variable value are resolved and their content is passed to the judge.

```java
assertThat(processInstance)
    .hasLocalVariableSatisfiesJudge(
        ElementSelectors.byName("Greet Customer"), "output",
        "Contains a polite greeting addressed to the customer.");
```

### hasLocalVariableSimilarTo

Assert that a local variable in the scope of a given element is semantically similar to an expected string using a configured embedding model. Use the BPMN
element ID or an [element selector](utilities.md#element-selector) to identify the element. The assertion fails if the variable doesn't exist or the
similarity score is below the configured threshold (default: 0.5). It requires [semantic similarity configuration](configuration.md#semantic-similarity-configuration).

```java
assertThat(processInstance)
    .hasLocalVariableSimilarTo(
        ElementSelectors.byName("Greet Customer"), "output",
        "Hello, how can I help you today?");
```

## Process instance message assertions

You can verify the message subscriptions of a process instance using `CamundaAssert.assertThat(processInstance)`.

### isWaitingForMessage

Assert that the process instance is waiting for the given message. The assertion fails if the process instance has no
active message subscription for the given message name and optional correlation key.

```java
// 1) By message name
assertThat(processInstance).isWaitingForMessage("message-name");

// 2) By message name and correlation key
assertThat(processInstance).isWaitingForMessage("message-name", "correlation-key");
```

### isNotWaitingForMessage

Assert that the process instance is not waiting for the given message. The assertion fails if the process instance has
an active message subscription for the given message name and optional correlation key.

```java
// 1) By message name
assertThat(processInstance).isNotWaitingForMessage("message-name");

// 2) By message name and correlation key
assertThat(processInstance).isNotWaitingForMessage("message-name", "correlation-key");
```

### hasCorrelatedMessage

Assert that the given message was correlated to the process instance. The assertion fails if the process instance has no
correlated message subscription for the given message name and optional correlation key.

```java
// 1) By message name
assertThat(processInstance).hasCorrelatedMessage("message-name");

// 2) By message name and correlation key
assertThat(processInstance).hasCorrelatedMessage("message-name", "correlation-key");
```

## User task assertions

You can verify the user task states and other properties using `CamundaAssert.assertThat()` or
`CamundaAssert.assertThatUserTask()`. Use a [UserTaskSelector](utilities.md#user-task-selector) to identify the user
task.

### With user task selector

Use a [UserTaskSelector](utilities.md#user-task-selector) to identify the user task:

```java
// by BPMN element ID
assertThatUserTask(UserTaskSelectors.byElementId("user-task-id")).isCompleted();

// by user task name
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).isCompleted();

// by process instance key
assertThatUserTask(UserTaskSelectors.byProcessInstanceKey(processInstanceKey)).isCompleted();
```

### isCreated

Asserts that the user task is created. The assertion fails if the task is in any other state.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).isCreated();
```

### isCompleted

Asserts that the user task is completed. The assertion fails if the task is in any other state.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).isCompleted();
```

### isCanceled

Asserts that the user task is canceled. The assertion fails if the task is in any other state.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).isCanceled();
```

### isFailed

Asserts that the user task is failed. The assertion fails if the task is in any other state.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).isFailed();
```

### hasAssignee

Asserts that the user task has the expected assignee.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasAssignee("John Doe");
```

### hasPriority

Asserts that the user task has the expected priority.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasPriority(100);
```

### hasElementId

Asserts that the user task has the expected BPMN element ID.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasElementId("user-task-id");
```

### hasName

Asserts that the user task has the expected name.

```java
assertThatUserTask(UserTaskSelectors.byElementId("user-task-id")).hasName("User Task");
```

### hasProcessInstanceKey

Asserts that the user task has the expected process instance key.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasProcessInstanceKey(processInstanceKey);
```

### hasDueDate

Asserts that the user task has the expected due date.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasDueDate("2023-10-01T00:00:00Z");
```

### hasCompletionDate

Asserts that the user task has the expected completion date.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasCompletionDate("2023-10-01T00:00:00Z");
```

### hasFollowUpDate

Asserts that the user task has the expected follow-up date.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasFollowUpDate("2023-10-01T00:00:00Z");
```

### hasCreationDate

Asserts that the user task has the expected creation date.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasCreationDate("2023-10-01T00:00:00Z");
```

### hasCandidateGroup

Asserts that the user task has the expected candidate group.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasCandidateGroup("groupA");
```

### hasCandidateGroups

Asserts that the user task has the expected candidate groups.

```java
assertThatUserTask(UserTaskSelectors.byTaskName("User Task")).hasCandidateGroups("groupA", "groupB", "groupC");
```

## Decision assertions

You can verify the decision evaluation state and other properties using `CamundaAssert.assertThat()` or
`CamundaAssert.assertThatDecision()`. Use the evaluate decision response or
a [DecisionSelector](utilities.md#decision-selector) to identify the decision instance.

### With evaluate decision response

Use the response of the evaluate decision command to identify the decision instance:

```java
// given/when
EvaluateDecisionResponse response =
    client
        .newEvaluateDecisionCommand()
        .decisionId(decisionId)
        .variables(variables)
        .send()
        .join();

// then
assertThat(response).isEvaluated();
```

### With decision selector

Use a [DecisionSelector](utilities.md#decision-selector) to identify the decision instance:

```java
// by decision ID
assertThatDecision(DecisionSelectors.byId("decision-id")).isEvaluated();

// by decision name
assertThatDecision(DecisionSelectors.byName("Decision Name")).isEvaluated();

// by process instance key
assertThatDecision(DecisionSelectors.byProcessInstanceKey(processInstanceKey)).isEvaluated();
```

### isEvaluated

Asserts that the decision is evaluated. The assertion fails if the evaluation failed and outputs the evaluation failure message.

```java
assertThatDecision(DecisionSelectors.byId("decision-id")).isEvaluated();
```

### hasOutput

Asserts that the decision is evaluated with the expected output. The verification fails if the decision evaluation failed or the output does not match.

```java
// With primitive value
assertThatDecision(DecisionSelectors.byId("decision-id")).hasOutput("output");

// With a map of values
Map<String, Object> expectedOutput = //
assertThatDecision(DecisionSelectors.byId("decision-id")).hasOutput(expectedOutput);

// With a list of values
List<Object> expectedOutput = //
assertThatDecision(DecisionSelectors.byId("decision-id")).hasOutput(expectedOutput);
```

### hasMatchedRules

Asserts that the decision table has matched the given rule indices. The evaluation fails if the decision evaluation failed or at least one of the expected matched rules didn't match.

The assertion will pass if the expected indexes are a subset of the total matches, e.g. `hasMatchedRules(1, 2)` will pass if rules [1, 2, 3] matched.

```java
// Single rule
assertThatDecision(DecisionSelectors.byId("decision-id")).hasMatchedRules(1);

// Multiple rules
assertThatDecision(DecisionSelectors.byId("decision-id")).hasMatchedRules(1, 3);
```

### hasNotMatchedRules

Asserts that the decision table has not matched the given rule indices. The assertion will fail if the decision evaluation has failed or at least one of the rules indexes has matched.

```java
// Single rule
assertThatDecision(DecisionSelectors.byId("decision-id")).hasNotMatchedRules(2);

// Multiple rules
assertThatDecision(DecisionSelectors.byId("decision-id")).hasNotMatchedRules(2, 4);
```

### hasNoMatchedRules

Asserts that the decision table matched no rules. The assertion will fail if the decision evaluation has failed or at least one rule matched.

```java
assertThatDecision(DecisionSelectors.byId("decision-id")).hasNoMatchedRules();
```

## Value assertions

You can verify arbitrary string values, independent of a process instance, using `CamundaAssert.assertThatValue()`.

This is useful for evaluating
values produced outside of a running process. For example, a single property of a variable object, with the
same LLM judge and embedding-based similarity checks used for process variables.

### satisfiesJudge

Assert that the given value satisfies a natural language expectation using a configured LLM judge. The expectation is evaluated only once. The
assertion fails if the LLM score is below the configured threshold (default: 0.5). It requires [judge configuration](configuration.md#judge-configuration).

[Document attachment](configuration.md#document-attachment) is not supported for value assertions. To evaluate document content, use [hasVariableSatisfiesJudge](#hasvariablesatisfiesjudge) or [hasLocalVariableSatisfiesJudge](#haslocalvariablesatisfiesjudge) instead.

```java
assertThatValue("The order has been shipped and will arrive tomorrow.")
    .satisfiesJudge("Confirms that the order is on its way to the customer.");
```

Override the global judge configuration for a single assertion chain using `withJudgeConfig`.

```java
assertThatValue(response)
    .withJudgeConfig(config -> config.withThreshold(0.9))
    .satisfiesJudge("Contains a valid JSON response with status OK.");
```

### isSimilarTo

Assert that the given value is semantically similar to an expected string using a configured embedding model. Both values are converted to embeddings,
and the cosine similarity is compared against the configured threshold. The assertion fails if the similarity score is below the configured threshold
(default: 0.5). It requires [semantic similarity configuration](configuration.md#semantic-similarity-configuration).

```java
assertThatValue("Hi there, what can I do for you?")
    .isSimilarTo("Hello, how can I help you today?");
```

Override the global semantic similarity configuration for a single assertion chain using `withSemanticSimilarityConfig`.

```java
assertThatValue(response)
    .withSemanticSimilarityConfig(config -> config.withThreshold(0.9))
    .isSimilarTo("Hello, how can I help you today?");
```

## Custom assertions

You can build your own assertions similar to the assertions from CPT.

- Use the preconfigured Camunda client to retrieve the process data.
- Use [AssertJ](https://github.com/assertj/assertj)'s assertions to verify the expected properties.
- Use [Awaitility](http://www.awaitility.org/) around verifications to compensate delays until the data is available.

```java
@Test
void shouldCreateUserTask() {
    // given: the process is deployed
    // when: create a process instance

    // then
    Awaitility.await()
        .ignoreException(ClientException.class)
        .untilAsserted(
            () -> {
                final List<UserTask> userTasks = getUserTasks(processInstanceKey);
                assertThat(userTasks).hasSize(1);

                final UserTask userTask = userTasks.getFirst();
                assertThat(userTask)
                    .returns("task", UserTask::getName)
                    .returns("me", UserTask::getAssignee);
            });
}

// helper method
private List<UserTask> getUserTasks(final long processInstanceKey) {
    return client
        .newUserTaskSearchRequest()
        .filter(filter -> filter.processInstanceKey(processInstanceKey).state(UserTaskState.CREATED))
        .send()
        .join()
        .items();
}
```

---

## Configuration(Testing)

By default, CPT uses a runtime based on [Testcontainers](#testcontainers-runtime). You can customize the runtime to your
needs, or replace it with a [Remote runtime](#remote-runtime), for example, if you can't install a Docker runtime.

## Configuration files

CPT properties can be set directly in a configuration file or resolved from environment variables. The file location and resolution mechanism depend on your setup:

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

Configure CPT in your `application.yml` (or `application.properties`). Properties also support [Spring's external configuration](https://docs.spring.io/spring-boot/reference/features/external-config.html), so you can set them through environment variables, system properties, or additional profiles.

</TabItem>

<TabItem value='java-client'>

Configure CPT in a `camunda-container-runtime.properties` file. Properties support automatic environment variable resolution. If a property is not explicitly set, it is resolved from an environment variable by prepending `CAMUNDA_PROCESSTEST_`, replacing dots with underscores, removing hyphens, and converting to uppercase.

For example, `judge.chatModel.apiKey` resolves to `CAMUNDA_PROCESSTEST_JUDGE_CHATMODEL_APIKEY`.

</TabItem>

</Tabs>

## Testcontainers runtime

The default runtime of CPT is based on [Testcontainers](https://java.testcontainers.org/). It uses the Camunda Docker
image and includes the following components:

- Camunda
- Connectors

:::note Why Testcontainers?
CPT follows a common practice by using Testcontainers to provide an isolated, reproducible, and easily configurable
environment using Docker containers. This ensures consistent test results, simplifies setup across different platforms,
and allows integration with Camunda and other components without manual installation or complex dependencies.
:::

:::tip Shared runtime
If you use the same runtime configuration for all test classes, then you can use a [shared runtime](#shared-runtime) to
speed up the test execution.
:::

### Prerequisites

- A Docker-API compatible container runtime, such as Docker on Linux or Docker Desktop on Mac and Windows.
  If you're experiencing issues with your Docker runtime, have a look at
  the [Testcontainers documentation](https://java.testcontainers.org/supported_docker_environment/).

### Usage

By default, the runtime uses the same version of the Camunda Docker images as the Maven module. You can change the
Docker images and other runtime properties in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    # Change the version of the Camunda Docker image
    camunda-docker-image-version: 8.8.0
    # Change the Camunda Docker image
    camunda-docker-image-name: camunda/camunda
    # Set additional Camunda environment variables
    camunda-env-vars:
      env_1: value_1
    # Expose additional Camunda ports
    camunda-exposed-ports:
      - 9000
    # Change the Camunda logger name
    camunda-logger-name: tc.camunda
    # Enable Connectors
    connectors-enabled: true
    # Change the Connectors Docker image
    connectors-docker-image-name: camunda/connectors
    # Change version of the Connectors Docker image
    connectors-docker-image-version: 8.8.0
    # Set additional Connectors environment variables
    connectors-env-vars:
      env_1: value_1
    # Set Connectors secrets
    connectors-secrets:
      secret_1: value_1
    # Expose additional Connectors ports
    connectors-exposed-ports:
      - 9010
    # Change the Connectors logger name
    connectors-logger-name: tc.connectors
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
# Change the version of the Camunda Docker image
camundaDockerImageVersion=8.8.0
# Change the Camunda Docker image
camundaDockerImageName=camunda/camunda
# Set additional Camunda environment variables
camundaEnvVars.env_1=value_1
camundaEnvVars.env_2=value_2
# Expose additional Camunda ports
camundaExposedPorts[0]=9000
camundaExposedPorts[1]=9001
# Change the Camunda logger name
camundaLoggerName=tc.camunda
# Enable Connectors
connectorsEnabled=true
# Change version of the Connectors Docker image
connectorsDockerImageVersion=8.8.0
# Change the Connectors Docker image
connectorsDockerImageName=camunda/connectors
# Set additional Connectors environment variables
connectorsEnvVars.env_1=value_1
connectorsEnvVars.env_2=value_2
# Set Connectors secrets
connectorsSecrets.secret_1=value_1
connectorsSecrets.secret_2=value_2
# Expose additional Connectors ports
connectorsExposedPorts[0]=9010
connectorsExposedPorts[1]=9011
# Change the Connectors logger name
connectorsLoggerName=tc.connectors
```

Alternatively, you can register the JUnit extension manually and use the fluent builder:

```java
package com.example;

// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
            new CamundaProcessTestExtension()
                    // Change the version of the Camunda Docker image
                    .withCamundaDockerImageVersion("8.8.0")
                    // Change the Camunda Docker image
                    .withCamundaDockerImageName("camunda/camunda")
                    // Set additional Camunda environment variables
                    .withCamundaEnv("env_1", "value_1")
                    // Expose additional Camunda ports
                    .withCamundaExposedPort(4567)
                    // Enable Connectors
                    .withConnectorsEnabled(true)
                    // Change the Connectors Docker image
                    .withConnectorsDockerImageName("camunda/connectors")
                    // Change version of the Connectors Docker image
                    .withConnectorsDockerImageVersion("8.8.0")
                    // Set additional Connectors environment variables
                    .withConnectorsEnv("env_1", "value_1")
                    // Set Connectors secrets
                    .withConnectorsSecret("secret_1", "value_1");
}
```

</TabItem>

</Tabs>

### Shared runtime

By default, CPT creates a new runtime for each test class. You can change this behavior and use a shared Testcontainers
runtime for all test classes to speed up the test execution. You can enable the shared runtime in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    # Switch from a managed to a shared runtime
    runtime-mode: shared
```

All test classes using the shared runtime will use the same runtime configuration. You can't change the runtime
configuration for individual test classes, such as enabling connectors or setting connector secrets. However, you can
switch to a managed runtime for individual test classes and override the runtime configuration.

```java

@SpringBootTest(
        properties = {
                // Use a managed runtime for a different configuration
                "camunda.process-test.runtime-mode=managed",
                "camunda.process-test.connectors-enabled=true",
        }
)
@CamundaSpringProcessTest
public class MyProcessTest {
    //
}
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
# Switch from a managed to a shared runtime
runtimeMode=shared
```

All test classes using the shared runtime will use the same runtime configuration. You can't change the runtime
configuration for individual test classes, such as enabling connectors or setting connector secrets. However, you can
switch to a managed runtime for individual test classes and override the runtime configuration.

```java
package com.example;

// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
            new CamundaProcessTestExtension()
                    // Use a managed runtime for a different configuration
                    .withRuntimeMode(CamundaProcessTestRuntimeMode.MANAGED)
                    .withConnectorsEnabled(true);
}
```

</TabItem>

</Tabs>

### Multi-tenancy

Multi-tenancy is disabled by default. You can enable multi-tenancy in the following way:

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    # Enable multi-tenancy
    multi-tenancy-enabled: true
```

By enabling multi-tenancy, the runtime enables Basic Auth security and creates a default user with username/password
`demo` with admin rights to interact with the runtime.

A process test using multi-tenancy could look like the following example:

```java

@SpringBootTest
@CamundaSpringProcessTest
public class MyProcessTest {

    private static final String DEFAULT_USERNAME = "demo";

    private static final String TENANT_ID_1 = "tenant-1";
    private static final String TENANT_ID_2 = "tenant-2";

    @Autowired
    private CamundaClient client;
    @Autowired
    private CamundaProcessTestContext processTestContext;

    private CamundaClient clientForTenant1;

    @BeforeEach
    void setupTenants() {
        // create tenants
        client.newCreateTenantCommand().tenantId(TENANT_ID_1).name(TENANT_ID_1).send().join();
        client.newCreateTenantCommand().tenantId(TENANT_ID_2).name(TENANT_ID_2).send().join();

        // assign the default user to the tenants
        client
                .newAssignUserToTenantCommand()
                .username(DEFAULT_USERNAME)
                .tenantId(TENANT_ID_1)
                .send()
                .join();
        client
                .newAssignUserToTenantCommand()
                .username(DEFAULT_USERNAME)
                .tenantId(TENANT_ID_2)
                .send()
                .join();

        // create a client for tenant 1
        clientForTenant1 =
                processTestContext.createClient(
                        clientBuilder -> clientBuilder.defaultTenantId(TENANT_ID_1));
    }

    @Test
    void createProcessInstance() {
        // given
        clientForTenant1
                .newDeployResourceCommand()
                .addResourceFromClasspath("bpmn/order-process.bpmn")
                .send()
                .join();

        // when
        final var processInstance =
                clientForTenant1
                        .newCreateInstanceCommand()
                        .bpmnProcessId("order-process")
                        .latestVersion()
                        .variable("order_id", "order-1")
                        .send()
                        .join();

        // then
        assertThatProcessInstance(processInstance).isCreated();

        Assertions.assertThat(processInstance.getTenantId()).isEqualTo(TENANT_ID_1);
    }
}
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
# Enable multi-tenancy
multiTenancyEnabled=true
```

Alternatively, you can register the JUnit extension manually and use the fluent builder:

```java
package com.example;

// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
            new CamundaProcessTestExtension()
                    // Enable multi-tenancy
                    .withMultiTenancyEnabled(true);
}
```

By enabling multi-tenancy, the runtime enables Basic Auth security and creates a default user with username/password
`demo` with admin rights to interact with the runtime.

A process test using multi-tenancy could look like the following example:

```java

@CamundaProcessTest
public class MyProcessTest {

    private static final String DEFAULT_USERNAME = "demo";

    private static final String TENANT_ID_1 = "tenant-1";
    private static final String TENANT_ID_2 = "tenant-2";

    private CamundaClient client;
    private CamundaProcessTestContext processTestContext;

    private CamundaClient clientForTenant1;

    @BeforeEach
    void setupTenants() {
        // create tenants
        client.newCreateTenantCommand().tenantId(TENANT_ID_1).name(TENANT_ID_1).send().join();
        client.newCreateTenantCommand().tenantId(TENANT_ID_2).name(TENANT_ID_2).send().join();

        // assign the default user to the tenants
        client
                .newAssignUserToTenantCommand()
                .username(DEFAULT_USERNAME)
                .tenantId(TENANT_ID_1)
                .send()
                .join();
        client
                .newAssignUserToTenantCommand()
                .username(DEFAULT_USERNAME)
                .tenantId(TENANT_ID_2)
                .send()
                .join();

        // create a client for tenant 1
        clientForTenant1 =
                processTestContext.createClient(
                        clientBuilder -> clientBuilder.defaultTenantId(TENANT_ID_1));
    }

    @Test
    void createProcessInstance() {
        // given
        clientForTenant1
                .newDeployResourceCommand()
                .addResourceFromClasspath("bpmn/order-process.bpmn")
                .send()
                .join();

        // when
        final var processInstance =
                clientForTenant1
                        .newCreateInstanceCommand()
                        .bpmnProcessId("order-process")
                        .latestVersion()
                        .variable("order_id", "order-1")
                        .send()
                        .join();

        // then
        assertThatProcessInstance(processInstance).isCreated();

        Assertions.assertThat(processInstance.getTenantId()).isEqualTo(TENANT_ID_1);
    }
}
```

</TabItem>

</Tabs>

:::info
You should assign the default user (`demo`) to all tenants to ensure that the assertions can access all data.
:::

### Custom containers

You can add custom containers to the managed or shared Testcontainers runtime, for example, to add a database, an MCP
server, or a mock service.

The CPT runtime manages the lifecycle of the custom containers and ensures that they are started before the tests and
stopped after the tests. The custom containers are added to the same network as the Camunda and Connectors containers to
allow communication between the containers.

You can add a custom container in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

Implement a `CamundaProcessTestContainerProvider` bean that creates the custom container.

In this example, we create a WireMock container to mock external HTTP calls in the tests.

```java

@Configuration
public class TestConfig {

    @Bean
    public CamundaProcessTestContainerProvider wireMockProvider() {
        return containerContext -> new WireMockContainer();
    }

    // A WireMock container to mock external HTTP calls in the tests
    private static final class WireMockContainer extends GenericContainer<WireMockContainer> {
        public WireMockContainer() {
            // Configure the Docker image
            super("wiremock/wiremock:3.13.0");
            // Configure the network alias for communication between the containers
            withNetworkAliases("wiremock");
            // Configure the ports to expose
            withExposedPorts(8080);
            // Configure the logger
            withLogConsumer(new Slf4jLogConsumer(LoggerFactory.getLogger("tc.wiremock"), true));
            // Configure the wait strategy to ensure that the container is ready before running the tests
            waitingFor(
                    Wait.forHttp("/__admin/mappings").forPort(8080).withMethod("GET").forStatusCode(200));
            // Custom container-specific configuration
            withCopyFileToContainer(
                    // Copy the WireMock mapping file for the HTTP stubs to the container
                    MountableFile.forClasspathResource("/wiremock/mapping.json"),
                    "/home/wiremock/mappings/mapping.json");
        }
    }
}
```

In the `application.yml` configuration, we use a connector secret to bind the connector task to the WireMock container
using its network alias `wiremock` and the exposed port `8080`.

```yaml
camunda:
  process-test:
    connectors-enabled: true
    connectors-secrets:
      BASE_URL: http://wiremock:8080
```

</TabItem>

<TabItem value='java-client'>

Implement the `CamundaProcessTestContainerProvider` interface that creates the custom container.

In this example, we create a WireMock container to mock external HTTP calls in the tests.

```java
public class WireMockContainerProvider implements CamundaProcessTestContainerProvider {

    @Override
    public GenericContainer<?> createContainer(final CamundaProcessTestContainerContext containerContext) {
        return new WireMockContainer();
    }

    // A WireMock container to mock external HTTP calls in the tests
    private static final class WireMockContainer extends GenericContainer<WireMockContainer> {
        public WireMockContainer() {
            // Configure the Docker image
            super("wiremock/wiremock:3.13.0");
            // Configure the network alias for communication between the containers
            withNetworkAliases("wiremock");
            // Configure the ports to expose
            withExposedPorts(8080);
            // Configure the logger
            withLogConsumer(new Slf4jLogConsumer(LoggerFactory.getLogger("tc.wiremock"), true));
            // Configure the wait strategy to ensure that the container is ready before running the tests
            waitingFor(
                    Wait.forHttp("/__admin/mappings").forPort(8080).withMethod("GET").forStatusCode(200));
            // Custom container-specific configuration
            withCopyFileToContainer(
                    // Copy the WireMock mapping file for the HTTP stubs to the container
                    MountableFile.forClasspathResource("/wiremock/mapping.json"),
                    "/home/wiremock/mappings/mapping.json");
        }
    }
}
```

Register the container provider using the Java ServiceLoader mechanism by creating a file
`io.camunda.process.test.api.runtime.CamundaProcessTestContainerProvider` in the `src/test/resources/META-INF/services`
directory of your project and adding the fully qualified name of the container provider implementation:

```
com.example.WireMockContainerProvider
```

In the `/camunda-container-runtime.properties` configuration file, we use a connector secret to bind the connector task
to the WireMock container using its network alias `wiremock` and the exposed port `8080`.

```properties
connectorsEnabled=true
connectorsSecrets.BASE_URL=http://wiremock:8080
```

Alternatively, you can register the container provider on the JUnit extension using the fluent builder:

```java
// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
            new CamundaProcessTestExtension()
                    .withContainerProvider(new WireMockContainerProvider())
                    .withConnectorsEnabled(true)
                    .withConnectorsSecret("BASE_URL", "http://wiremock:8080");
}
```

</TabItem>

</Tabs>

## Remote runtime

Instead of using the managed [Testcontainers runtime](#testcontainers-runtime), you can configure CPT to connect to a
remote runtime, for example, to a local [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) running
on your machine.

When to use it:

- You can't install a Docker-API compatible container runtime
- Debugging of test case on your local machine

:::info
You are responsible for configuring and managing the remote runtime. Ensure the runtime is running before executing
tests. Keep in mind that CPT automatically deletes all data between test runs to maintain a clean state.
:::

### Prerequisites

- Install a Camunda 8 runtime, for example, [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md)
- Expose the management API port (`9600`) to delete the data between test runs (by default for a local Camunda 8 Run)
- Enable the management clock endpoint to allow clock manipulations

You can [configure Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run/configuration.md#configuration-options) by
defining a `application.yaml` file with:

```yaml
zeebe.clock.controlled: true
```

By default, Camunda 8 Run loads the `application.yaml` from the distribution's root directory. If you use a different
path, then you need to set the path when starting the application with the command line argument
`--config=application.yaml`:

```
./start.sh --config=application.yaml
```

### Usage

You need to set the following property to switch to a remote runtime.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    # Switch from a managed to a remote runtime
    runtime-mode: remote
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
# Switch from a managed to a remote runtime
runtimeMode=remote
```

Alternatively, you can register the JUnit extension manually and use the fluent builder:

```java
package com.example;

// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
            new CamundaProcessTestExtension()
                    // Switch from a managed to a remote runtime
                    .withRuntimeMode(CamundaProcessTestRuntimeMode.REMOTE);
}
```

</TabItem>

</Tabs>

### Change the connection

By default, CPT connects to a remote Camunda 8 Run running on your local machine. CPT checks if the remote runtime is
available and ready, before running the tests. It waits up to 1 minute for the remote runtime to become ready.

You can change the connection to the remote runtime and the connection time in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    runtime-mode: remote
    # Change the connection (default: Camunda 8 Run)
    remote:
      camunda-monitoring-api-address: http://0.0.0.0:9600
      connectors-rest-api-address: http://0.0.0.0:8086
      # The connection timeout in ISO-8601 duration format (default: PT1M)
      runtime-connection-timeout: PT1M
  client:
    rest-address: http://0.0.0.0:8080
    grpc-address: http://0.0.0.0:26500
```

:::note
The properties `camunda.process-test.remote.client.rest-address` and `camunda.process-test.remote.client.grpc-address` are deprecated. Use `camunda.client.rest-address` and `camunda.client.grpc-address` instead.
:::

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
runtimeMode=remote
# Change the connection (default: Camunda 8 Run)
remote.camundaMonitoringApiAddress=http://0.0.0.0:9600
remote.connectorsRestApiAddress=http://0.0.0.0:8086
camunda.client.gateway.grpc.address=http://0.0.0.0:26500
camunda.client.gateway.rest.address=http://0.0.0.0:8080
# The connection timeout in ISO-8601 duration format (default: PT1M)
remote.runtimeConnectionTimeout=PT1M
```

:::note
The properties `remote.client.grpcAddress` and `remote.client.restAddress` are deprecated. Use `camunda.client.gateway.grpc.address` and `camunda.client.gateway.rest.address` instead.
:::

Alternatively, register the JUnit extension manually and use the fluent builder:

```java
package com.example;

// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
            new CamundaProcessTestExtension()
                    .withRuntimeMode(CamundaProcessTestRuntimeMode.REMOTE)
                    // Change the connection (default: Camunda 8 Run)
                    .withCamundaClientBuilderFactory(() -> CamundaClient.newClientBuilder()
                            .restAddress(URI.create("http://0.0.0.0:8080"))
                            .grpcAddress(URI.create("http://0.0.0.0:26500"))
                    )
                    .withRemoteCamundaMonitoringApiAddress(URI.create("http://0.0.0.0:9600"))
                    .withRemoteConnectorsRestApiAddress(URI.create("http://0.0.0.0:8086"))
                    // Change the connection timeout (default: PT1M)
                    .withRemoteRuntimeConnectionTimeout(Duration.ofMinutes(1));
}
```

</TabItem>

</Tabs>

### Debugging of test cases

You can use a remote runtime to debug your test cases on your local machine. Set breakpoints in your test case and run
the test in debug mode from your IDE.

When the test execution stops at a breakpoint, you can inspect the process instance state using Operate and the user
task state using Tasklist. You can also use the Camunda client to interact with the runtime from the debugger console.

## Client configuration

CPT configures the Camunda client automatically based on the runtime mode. You can customize the client
configuration beyond the connection addresses, for example, to set up authentication.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

CPT applies all [Camunda client configurations](/apis-tools/camunda-spring-boot-starter/configuration.md) from your
`application.yml`. For example, to configure Basic authentication for a remote runtime:

```yaml
camunda:
  client:
    grpc-address: http://localhost:26500
    rest-address: http://localhost:8080
    auth:
      method: basic
      username: demo
      password: demo
```

For full flexibility, provide a `CamundaClientBuilderFactory` bean:

```java

@Bean
public CamundaClientBuilderFactory customClientBuilderFactory() {
    return () ->
            CamundaClient.newClientBuilder()
                    .restAddress(URI.create("http://0.0.0.0:8080"))
                    .grpcAddress(URI.create("http://0.0.0.0:26500"))
                    .credentialsProvider(
                            CredentialsProvider.newBasicAuthCredentialsProviderBuilder()
                                    .username("demo")
                                    .password("demo")
                                    .build());
}
```

</TabItem>

<TabItem value='java-client'>

In the `camunda-container-runtime.properties` file, you can set any
[`ClientProperties`](https://javadoc.io/doc/io.camunda/camunda-client-java/latest/io/camunda/client/ClientProperties.html).
For example, to configure the connection to a remote runtime:

```properties
camunda.client.gateway.rest.address=http://0.0.0.0:8080
camunda.client.gateway.grpc.address=http://0.0.0.0:26500
```

For more flexibility, use the fluent builder to set a client builder factory:

```java

@RegisterExtension
private static final CamundaProcessTestExtension EXTENSION =
        new CamundaProcessTestExtension()
                .withRuntimeMode(CamundaProcessTestRuntimeMode.REMOTE)
                .withCamundaClientBuilderFactory(
                        () ->
                                CamundaClient.newClientBuilder()
                                        .restAddress(URI.create("http://0.0.0.0:8080"))
                                        .grpcAddress(URI.create("http://0.0.0.0:26500")));
```

To override specific client properties, for example to configure a credential provider, use
`withCamundaClientBuilderOverrides`. This works together with the client builder factory and the configuration file:

```java

@RegisterExtension
private static final CamundaProcessTestExtension EXTENSION =
        new CamundaProcessTestExtension()
                .withCamundaClientBuilderOverrides(
                        camundaClientBuilder ->
                                camundaClientBuilder
                                        .credentialsProvider(
                                                CredentialsProvider.newBasicAuthCredentialsProviderBuilder()
                                                        .username("demo")
                                                        .password("demo")
                                                        .build()));
```

</TabItem>

</Tabs>

## Process Test Coverage

CPT generates an HTML and JSON coverage report of your BPMN processes and DMN decision tables. You can configure the
report generation in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    coverage:
      # Change the directory where the report is generated
      reportDirectory: target/coverage-report
      # Exclude processes from the report by their process definition ID
      excludedProcesses:
        - process_1
        - process_2
      # Exclude decisions from the report by their decision definition ID
      excludedDecisions:
        - decision_1
        - decision_2
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
# Change the directory where the report is generated
coverage.reportDirectory=target/coverage-report
# Exclude processes from the report by their process definition ID
excludedProcesses[0]=process_1
excludedProcesses[1]=process_2
# Exclude decisions from the report by their decision definition ID
excludedDecisions[0]=decision_1
excludedDecisions[1]=decision_2
```

</TabItem>

</Tabs>

## Logging

The test runtime uses [SLF4J](https://www.slf4j.org/) as the logging framework. If needed, you can enable the logging
for the following packages:

- `io.camunda.process.test` - The test runtime (recommended level `info`)
- `tc.camunda` - The Camunda Docker container (recommended level `error`)
- `tc.connectors` - The connectors Docker container (recommended level `error`)
- `org.testcontainers` - The Testcontainers framework (recommended level `warn`)

## Judge configuration

[Judge assertions](assertions.md#hasvariablesatisfiesjudge) use a configured LLM to score process variables (or plain values) against
natural language expectations. This section covers how to set up the LLM provider and tune the judge behavior.

### Prerequisites

CPT provides an optional [LangChain4j](https://docs.langchain4j.dev/) integration module that ships with preconfigured
support for major LLM providers: OpenAI, Anthropic, Amazon Bedrock, Azure OpenAI, and OpenAI-compatible APIs.
LangChain4j requires Java 17+. You can provide your own LLM integration through a
custom `ChatModelAdapter` instead (see [custom ChatModelAdapter](#custom-chatmodeladapter)).

:::tip
For a guided walkthrough of setting up and testing AI agents, see [test your AI agents](/components/agentic-orchestration/evaluate-agents/test-ai-agents.md).
:::

<Tabs groupId="client" defaultValue="spring-sdk-pre" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-pre' },
{label: 'Java client', value: 'java-client-pre' },
]}>

<TabItem value='spring-sdk-pre'>

Camunda Process Test Spring includes the LangChain4j providers as a transitive dependency. No additional
dependency is needed.

</TabItem>

<TabItem value='java-client-pre'>

Add the `camunda-process-test-langchain4j` dependency to your project:

```xml

<dependency>
    <groupId>io.camunda</groupId>
    <artifactId>camunda-process-test-langchain4j</artifactId>
    <scope>test</scope>
</dependency>
```

</TabItem>

</Tabs>

If you provide a custom `ChatModelAdapter` (see [custom ChatModelAdapter](#custom-chatmodeladapter)), this dependency
is not required.

### Property reference

All judge properties are nested under `camunda.process-test.judge` in Spring configuration. In Java properties files,
use the `judge.` prefix with camelCase keys (for example, `judge.chat-model.api-key` becomes `judge.chatModel.apiKey`).

For configuration examples, see [Step 2: configure the LLM provider and connectors](/components/agentic-orchestration/evaluate-agents/test-ai-agents.md#step-2-configure-the-llm-provider-and-connectors).

Unless noted otherwise, properties in the provider tables are required.

#### Judge settings

| Property                 | Type      | Default | Description                                                                                                                                                                                                                                                                                                                                   |
| ------------------------ | --------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `judge.threshold`        | `double`  | `0.5`   | Confidence threshold (0.0 to 1.0) for the judge to pass.                                                                                                                                                                                                                                                                                      |
| `judge.custom-prompt`    | `string`  |         | Custom evaluation prompt replacing the default criteria.                                                                                                                                                                                                                                                                                      |
| `judge.attach-documents` | `boolean` | `false` | When `true`, resolves Camunda document references in the evaluated variable and attaches their content to the judge. Disabled by default to avoid unnecessary token cost. To evaluate attached content, use a multimodal-capable model; otherwise, CPT evaluates only the raw variable JSON. See [document attachment](#document-attachment). |

The default threshold of `0.5` treats a response as acceptable when it is at least partially satisfied according to the
judge rubric. This is a practical default for AI-generated output, where wording and level of detail may vary between
runs even when the response is still useful. Increase the threshold when your assertion needs stricter semantic
agreement.

#### Chat model settings

<Tabs groupId="provider" defaultValue="openai" queryString values={[
{label: 'OpenAI', value: 'openai' },
{label: 'Anthropic', value: 'anthropic' },
{label: 'Amazon Bedrock', value: 'amazon-bedrock' },
{label: 'Azure OpenAI', value: 'azure-openai' },
{label: 'OpenAI-compatible', value: 'openai-compatible' },
{label: 'Custom/SPI', value: 'custom' },
]}>

<TabItem value='openai'>

| Property                       | Required | Type       | Description                                               |
| ------------------------------ | -------- | ---------- | --------------------------------------------------------- |
| `judge.chat-model.provider`    | Yes      | `string`   | Set to `openai`.                                          |
| `judge.chat-model.model`       | Yes      | `string`   | Model name (for example `gpt-4o`).                        |
| `judge.chat-model.api-key`     | Yes      | `string`   | API key.                                                  |
| `judge.chat-model.timeout`     | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`). |
| `judge.chat-model.temperature` | No       | `double`   | Temperature for response randomness (0.0 to 2.0).         |

**Example:**

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "openai"
        model: "gpt-4o"
        api-key: ${OPENAI_API_KEY}
```

</TabItem>

<TabItem value='anthropic'>

| Property                       | Required | Type       | Description                                               |
| ------------------------------ | -------- | ---------- | --------------------------------------------------------- |
| `judge.chat-model.provider`    | Yes      | `string`   | Set to `anthropic`.                                       |
| `judge.chat-model.model`       | Yes      | `string`   | Model name (for example `claude-sonnet-4-20250514`).      |
| `judge.chat-model.api-key`     | Yes      | `string`   | API key.                                                  |
| `judge.chat-model.timeout`     | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`). |
| `judge.chat-model.temperature` | No       | `double`   | Temperature for response randomness (0.0 to 2.0).         |

**Example:**

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "anthropic"
        model: "claude-sonnet-4-20250514"
        api-key: ${ANTHROPIC_API_KEY}
```

</TabItem>

<TabItem value='amazon-bedrock'>

Supports Bedrock long-term API keys or AWS IAM credentials. Falls back to the
[AWS default credentials provider chain](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-chain.html).

| Property                                  | Required                       | Type       | Description                                                                                    |
| ----------------------------------------- | ------------------------------ | ---------- | ---------------------------------------------------------------------------------------------- |
| `judge.chat-model.provider`               | Yes                            | `string`   | Set to `amazon-bedrock`.                                                                       |
| `judge.chat-model.model`                  | Yes                            | `string`   | Model name (for example `eu.anthropic.claude-haiku-4-5-20251001-v1:0`).                        |
| `judge.chat-model.region`                 | No                             | `string`   | AWS region (for example `eu-central-1`).                                                       |
| `judge.chat-model.api-key`                | No                             | `string`   | Bedrock long-term API key. Optional if using IAM credentials or the default credentials chain. |
| `judge.chat-model.credentials.access-key` | Conditionally, with secret key | `string`   | AWS IAM access key. Optional if using an API key or the default credentials chain.             |
| `judge.chat-model.credentials.secret-key` | Conditionally, with access key | `string`   | AWS IAM secret key. Optional if using an API key or the default credentials chain.             |
| `judge.chat-model.timeout`                | No                             | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                                      |
| `judge.chat-model.temperature`            | No                             | `double`   | Temperature for response randomness (0.0 to 2.0).                                              |

**Example:**

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "amazon-bedrock"
        model: "eu.anthropic.claude-haiku-4-5-20251001-v1:0"
        region: "eu-central-1"
        credentials:
          access-key: ${AWS_BEDROCK_ACCESS_KEY}
          secret-key: ${AWS_BEDROCK_SECRET_KEY}
```

</TabItem>

<TabItem value='azure-openai'>

Supports API key authentication. Falls back to
[`DefaultAzureCredential`](https://learn.microsoft.com/en-us/java/api/com.azure.identity.defaultazurecredential).

| Property                       | Required | Type       | Description                                                                                                                |
| ------------------------------ | -------- | ---------- | -------------------------------------------------------------------------------------------------------------------------- |
| `judge.chat-model.provider`    | Yes      | `string`   | Set to `azure-openai`.                                                                                                     |
| `judge.chat-model.model`       | Yes      | `string`   | Azure [deployment name](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/create-resource#deploy-a-model). |
| `judge.chat-model.endpoint`    | Yes      | `string`   | Azure OpenAI resource URL (for example `https://my-resource.openai.azure.com/`).                                           |
| `judge.chat-model.api-key`     | No       | `string`   | API key. Optional; if omitted, falls back to `DefaultAzureCredential`.                                                     |
| `judge.chat-model.timeout`     | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                                                                  |
| `judge.chat-model.temperature` | No       | `double`   | Temperature for response randomness (0.0 to 2.0).                                                                          |

**Example:**

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "azure-openai"
        model: "my-gpt4o-deployment"
        endpoint: "https://my-resource.openai.azure.com/"
        api-key: ${AZURE_OPENAI_API_KEY}
```

</TabItem>

<TabItem value='openai-compatible'>

For local models (such as [Ollama](https://ollama.com/)) or any third-party API that implements the
[OpenAI chat completions format](https://platform.openai.com/docs/api-reference/chat).

| Property                       | Required | Type       | Description                                                              |
| ------------------------------ | -------- | ---------- | ------------------------------------------------------------------------ |
| `judge.chat-model.provider`    | Yes      | `string`   | Set to `openai-compatible`.                                              |
| `judge.chat-model.model`       | Yes      | `string`   | Model name (for example `llama3`).                                       |
| `judge.chat-model.base-url`    | Yes      | `string`   | Base URL for the API endpoint (for example `http://localhost:11434/v1`). |
| `judge.chat-model.api-key`     | No       | `string`   | API key. Optional for local providers.                                   |
| `judge.chat-model.headers.*`   | No       | `map`      | Custom HTTP headers.                                                     |
| `judge.chat-model.timeout`     | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                |
| `judge.chat-model.temperature` | No       | `double`   | Temperature for response randomness (0.0 to 2.0).                        |

**Example (Ollama):**

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "openai-compatible"
        model: "llama3"
        base-url: "http://localhost:11434/v1"
```

</TabItem>

<TabItem value='custom'>

For providers not listed above, use a custom provider name and pass arbitrary properties. See
[Custom ChatModelAdapter](#custom-chatmodeladapter) for implementation details.

| Property                               | Required | Type       | Description                                                                                   |
| -------------------------------------- | -------- | ---------- | --------------------------------------------------------------------------------------------- |
| `judge.chat-model.provider`            | Yes      | `string`   | Custom provider name matching your SPI implementation.                                        |
| `judge.chat-model.model`               | Yes      | `string`   | Model name.                                                                                   |
| `judge.chat-model.custom-properties.*` | No       | `map`      | Arbitrary key-value pairs passed to SPI providers via `ProviderConfig.getCustomProperties()`. |
| `judge.chat-model.timeout`             | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                                     |
| `judge.chat-model.temperature`         | No       | `double`   | Temperature for response randomness (0.0 to 2.0).                                             |

**Example:**

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "my-custom-provider"
        model: "my-model"
        custom-properties:
          endpoint: "https://my-llm.example.com/v1"
```

</TabItem>

</Tabs>

### Document attachment

When `judge.attach-documents` is enabled, CPT scans the serialized variable JSON for [Camunda document](/components/document-handling/getting-started.md) references, downloads their content, and passes it to the judge alongside the text prompt as structured content blocks. This lets the judge evaluate document content, such as generated PDFs, images, or text files.

Document attachment is disabled by default. Enable it globally:

<Tabs groupId="client" defaultValue="spring-sdk-attach" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-attach' },
{label: 'Java client', value: 'java-client-attach' },
]}>

<TabItem value='spring-sdk-attach'>

```yaml
camunda:
  process-test:
    judge:
      attach-documents: true
```

</TabItem>

<TabItem value='java-client-attach'>

```properties
judge.attachDocuments=true
```

</TabItem>

</Tabs>

You can also enable it per assertion using `withJudgeConfig`:

```java
assertThat(processInstance)
    .withJudgeConfig(config -> config.withAttachDocuments(true))
    .hasVariableSatisfiesJudge("report", "Contains an executive summary with at least three key findings.");
```

#### Content type handling

How the document is passed to the judge depends on its MIME content type:

| Content type                                                                                                                                            | Passed to judge as                                                      |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| `image/*`                                                                                                                                               | Inline image block                                                      |
| `application/pdf`                                                                                                                                       | PDF file block                                                          |
| `text/*`, `application/json`, `application/xml`, `application/yaml`, `application/x-yaml`, or types with a structured suffix (`+json`, `+xml`, `+yaml`) | Inline text block (UTF-8)                                               |
| All other types                                                                                                                                         | Placeholder text only; content is not inspectable. A warning is logged. |

#### Behavior

- Built-in LangChain4j providers implement `MultimodalChatModelAdapter`. Custom `ChatModelAdapter` implementations must implement `MultimodalChatModelAdapter` to receive documents. Otherwise, document attachment does not take effect and the judge evaluates only the raw variable JSON.
- Documents with the same document ID and store ID are deduplicated and downloaded only once.
- If a document fails to download, the assertion fails with an `IllegalStateException`.

### Custom prompt

You can replace the default evaluation criteria with a custom prompt. The custom prompt replaces only the evaluation
criteria (the "You are an impartial judge..." preamble). The system still controls the expectation and value injection,
the scoring rubric, and the JSON output format.

By default, CPT uses an internal prompt that instructs the model to act as an impartial judge, compare the provided
value against the natural language expectation, apply the documented scoring rubric, and return the result in the
expected JSON structure.

<Tabs groupId="client" defaultValue="spring-sdk-custom" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-custom' },
{label: 'Java client', value: 'java-client-custom' },
]}>

<TabItem value='spring-sdk-custom'>

```yaml
camunda:
  process-test:
    judge:
      custom-prompt: "You are a domain expert evaluating financial data accuracy."
```

</TabItem>

<TabItem value='java-client-custom'>

```properties
judge.customPrompt=You are a domain expert evaluating financial data accuracy.
```

Or programmatically:

```java
JudgeConfig.of(prompt -> myChatModelAdapter.generate(prompt))
    .withCustomPrompt("You are a domain expert evaluating financial data accuracy.");
```

</TabItem>

</Tabs>

You can also override the custom prompt for a single assertion chain:

```java
assertThat(processInstance)
    .withJudgeConfig(config -> config
        .withCustomPrompt("You are a domain expert evaluating financial data accuracy."))
    .hasVariableSatisfiesJudge("result", "Contains valid totals.");
```

### Custom ChatModelAdapter

You can provide your own `ChatModelAdapter` implementation without depending on the `camunda-process-test-langchain4j`
module. A `ChatModelAdapter` is a functional interface that takes a prompt string and returns a response string.

<Tabs groupId="client" defaultValue="spring-sdk-chat" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-chat' },
{label: 'Java client', value: 'java-client-chat' },
]}>

<TabItem value='spring-sdk-chat'>

If you have a single `ChatModelAdapter` bean and no `provider` property is set, CPT auto-detects and uses it:

```java

@TestConfiguration
class JudgeTestConfig {

    @Bean
    ChatModelAdapter chatModelAdapter() {
        return prompt -> myChatModelAdapter.generate(prompt);
    }
}
```

When you have multiple beans, set `provider` to the bean name you want to use. In Spring, the bean name defaults to
the method name:

```java

@TestConfiguration
class JudgeTestConfig {

    @Bean
    ChatModelAdapter openAiAdapter() { /* ... */ }

    @Bean
    ChatModelAdapter ollamaAdapter() { /* ... */ }
}
```

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "ollamaAdapter" # matches the bean method name
```

:::note Resolution order
When using `@CamundaSpringProcessTest`, CPT resolves the judge adapter in the following order:

1. If a single `ChatModelAdapter` bean exists and no `provider` property is configured, that bean is used automatically.
2. If the `provider` property is configured and a bean with a matching name exists, that bean is selected.
3. If no matching bean is found, CPT falls back to the built-in LangChain4j implementations, provided that `camunda-process-test-langchain4j` is on the classpath.
4. If a `provider` is configured but no matching implementation can be resolved at all, CPT throws an exception.

:::

Alternatively, you can configure the judge programmatically. Set the configuration globally
using `CamundaAssert.setJudgeConfig()`:

```java
CamundaAssert.setJudgeConfig(
    JudgeConfig.of(prompt -> myChatModelAdapter.generate(prompt))
        .withThreshold(0.8));
```

</TabItem>

<TabItem value='java-client-chat'>

Implement `ChatModelAdapterProvider` and register it through `META-INF/services`:

```java
public class MyCustomProvider implements ChatModelAdapterProvider {

    @Override
    public String getProviderName() {
        return "my-provider";
    }

    @Override
    public ChatModelAdapter create(ProviderConfig config) {
        String endpoint = config.getCustomProperties().get("endpoint");
        return prompt -> callEndpoint(endpoint, prompt);
    }
}
```

Register the provider in `META-INF/services/io.camunda.process.test.api.judge.ChatModelAdapterProvider`:

```
com.example.MyCustomProvider
```

Alternatively, you can configure the judge programmatically. Set the configuration globally
using `CamundaAssert.setJudgeConfig()`:

```java
CamundaAssert.setJudgeConfig(
    JudgeConfig.of(prompt -> myChatModelAdapter.generate(prompt))
        .withThreshold(0.8));
```

Or register the JUnit extension manually with a judge configuration:

```java

@RegisterExtension
CamundaProcessTestExtension extension = new CamundaProcessTestExtension()
    .withJudgeConfig(JudgeConfig.of(prompt -> myChatModelAdapter.generate(prompt))
        .withThreshold(0.8));
```

</TabItem>

</Tabs>

#### Multimodal support

To use [document attachment](#document-attachment) with a custom adapter, implement `MultimodalChatModelAdapter` instead of `ChatModelAdapter`. `MultimodalChatModelAdapter` extends `ChatModelAdapter` and adds a second `generate` overload that receives the resolved documents.

Each `ResolvedDocument` provides the binary content via `getContent()` and metadata via `getDocumentId()`, `getFileName()`, and `getContentType()`. Pass each document to the provider as a native structured content block (image block, file block, or text block depending on the content type). Prefix each block with a text content header containing the document metadata so the judge can correlate the block back to the document reference in `<actual_value>`:

```java
public class MyMultimodalAdapter implements MultimodalChatModelAdapter {

    @Override
    public String generate(String prompt) {
        return myClient.chat(prompt);
    }

    @Override
    public String generate(String prompt, List<ResolvedDocument> documents) {
        List<Object> parts = new ArrayList<>();
        parts.add(new TextPart(prompt));

        for (ResolvedDocument doc : documents) {
            // text header identifying this document block
            parts.add(new TextPart(
                "--- documentId=\"" + doc.getDocumentId()
                + "\" fileName=\"" + doc.getFileName()
                + "\" contentType=\"" + doc.getContentType() + "\" ---"));
            // binary content as a native structured block
            parts.add(new BinaryPart(doc.getContent(), doc.getContentType()));
        }

        return myClient.chat(parts);
    }
}
```

Replace `TextPart` and `BinaryPart` with the content-block types your provider's SDK defines. If document attachment is enabled but the adapter only implements `ChatModelAdapter`, document attachment does not take effect and the judge evaluates only the raw variable JSON.

## Semantic similarity configuration

[Semantic similarity assertions](assertions.md#hasvariablesimilarto) use a configured embedding model to compare process variables (or plain values) to an expected string using vector embeddings.
The assertion converts both values to embeddings and compares them using cosine similarity.

This section covers how to set up the embedding model provider and tune the similarity behavior.

### Prerequisites

CPT provides an optional [LangChain4j](https://docs.langchain4j.dev/) integration module that ships with preconfigured support for major embedding model providers, such as OpenAI, Azure OpenAI, Amazon Bedrock, and OpenAI-compatible APIs.

:::note
LangChain4j requires Java 17+.
:::

<Tabs groupId="client" defaultValue="spring-sdk-similarity-pre" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-similarity-pre' },
{label: 'Java client', value: 'java-client-similarity-pre' },
]}>

<TabItem value='spring-sdk-similarity-pre'>

Camunda Process Test Spring includes the LangChain4j providers as a transitive dependency. No additional
dependency or configuration is needed.

</TabItem>

<TabItem value='java-client-similarity-pre'>

Add the `camunda-process-test-langchain4j` dependency to your project:

```xml
<dependency>
    <groupId>io.camunda</groupId>
    <artifactId>camunda-process-test-langchain4j</artifactId>
    <scope>test</scope>
</dependency>
```

</TabItem>

</Tabs>

:::important
You can provide your own embedding integration through a custom `EmbeddingModelAdapter`. In that case, this dependency is not required. See [custom EmbeddingModelAdapter](#custom-embeddingmodeladapter) for more details.
:::

### Property reference

All semantic similarity properties are nested under `camunda.process-test.similarity` in Spring configuration.
In Java properties files, use the `similarity.` prefix with camelCase keys. For example, `similarity.embedding-model.api-key` becomes `similarity.embeddingModel.apiKey`.

:::note
Unless noted otherwise, properties in the provider tables are required.
:::

#### Similarity settings

| Property                                   | Type      | Default | Description                                                                                                                  |
| ------------------------------------------ | --------- | ------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `similarity.threshold`                     | `double`  | `0.5`   | Cosine similarity threshold (0.0 to 1.0) for the assertion to pass.                                                          |
| `similarity.default-preprocessors-enabled` | `boolean` | `true`  | When `true`, applies the default text preprocessors (lowercase, Unicode NFC, and whitespace normalization) before embedding. |

The default threshold of 0.5 treats two strings as similar when their cosine similarity is at least 0.5. This is a practical default for AI-generated text, where wording and phrasing may vary between runs even when the meaning is the same.
Increase the threshold when your assertion needs stricter semantic agreement.

#### Embedding model settings

<Tabs groupId="provider" defaultValue="openai-embedding" queryString values={[
{label: 'OpenAI', value: 'openai-embedding' },
{label: 'Amazon Bedrock', value: 'amazon-bedrock-embedding' },
{label: 'Azure OpenAI', value: 'azure-openai-embedding' },
{label: 'OpenAI-compatible', value: 'openai-compatible-embedding' },
{label: 'Custom/SPI', value: 'custom-embedding' },
]}>

<TabItem value='openai-embedding'>

| Property                                | Required | Type       | Description                                                            |
| --------------------------------------- | -------- | ---------- | ---------------------------------------------------------------------- |
| `similarity.embedding-model.provider`   | Yes      | `string`   | Set to `openai`.                                                       |
| `similarity.embedding-model.model`      | Yes      | `string`   | Model name (for example `text-embedding-3-small`).                     |
| `similarity.embedding-model.api-key`    | Yes      | `string`   | API key.                                                               |
| `similarity.embedding-model.dimensions` | No       | `integer`  | Number of output dimensions for models that support custom dimensions. |
| `similarity.embedding-model.timeout`    | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).              |

**Example:**

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "openai"
        model: "text-embedding-3-small"
        api-key: ${OPENAI_API_KEY}
```

</TabItem>

<TabItem value='amazon-bedrock-embedding'>

It supports Bedrock long-term API keys or AWS IAM credentials. It falls back to the
[AWS default credentials provider chain](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-chain.html).

| Property                                            | Required                       | Type       | Description                                                                                    |
| --------------------------------------------------- | ------------------------------ | ---------- | ---------------------------------------------------------------------------------------------- |
| `similarity.embedding-model.provider`               | Yes                            | `string`   | Set to `amazon-bedrock`.                                                                       |
| `similarity.embedding-model.model`                  | Yes                            | `string`   | Model name (for example `amazon.titan-embed-text-v2:0`).                                       |
| `similarity.embedding-model.region`                 | No                             | `string`   | AWS region (for example `eu-central-1`).                                                       |
| `similarity.embedding-model.api-key`                | No                             | `string`   | Bedrock long-term API key. Optional if using IAM credentials or the default credentials chain. |
| `similarity.embedding-model.credentials.access-key` | Conditionally, with secret key | `string`   | AWS IAM access key. Optional if using an API key or the default credentials chain.             |
| `similarity.embedding-model.credentials.secret-key` | Conditionally, with access key | `string`   | AWS IAM secret key. Optional if using an API key or the default credentials chain.             |
| `similarity.embedding-model.dimensions`             | No                             | `integer`  | Number of output dimensions for models that support custom dimensions.                         |
| `similarity.embedding-model.normalize`              | No                             | `boolean`  | Whether to normalize the output embeddings.                                                    |
| `similarity.embedding-model.timeout`                | No                             | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                                      |

**Example:**

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "amazon-bedrock"
        model: "amazon.titan-embed-text-v2:0"
        region: "eu-central-1"
        credentials:
          access-key: ${AWS_BEDROCK_ACCESS_KEY}
          secret-key: ${AWS_BEDROCK_SECRET_KEY}
```

</TabItem>

<TabItem value='azure-openai-embedding'>

It supports API key authentication. It falls back to
[`DefaultAzureCredential`](https://learn.microsoft.com/en-us/java/api/com.azure.identity.defaultazurecredential).

| Property                                | Required | Type       | Description                                                                                                                |
| --------------------------------------- | -------- | ---------- | -------------------------------------------------------------------------------------------------------------------------- |
| `similarity.embedding-model.provider`   | Yes      | `string`   | Set to `azure-openai`.                                                                                                     |
| `similarity.embedding-model.model`      | Yes      | `string`   | Azure [deployment name](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/create-resource#deploy-a-model). |
| `similarity.embedding-model.endpoint`   | Yes      | `string`   | Azure OpenAI resource URL (for example `https://my-resource.openai.azure.com/`).                                           |
| `similarity.embedding-model.api-key`    | No       | `string`   | API key. Optional; if omitted, falls back to `DefaultAzureCredential`.                                                     |
| `similarity.embedding-model.dimensions` | No       | `integer`  | Number of output dimensions for models that support custom dimensions.                                                     |
| `similarity.embedding-model.timeout`    | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                                                                  |

**Example:**

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "azure-openai"
        model: "my-embedding-deployment"
        endpoint: "https://my-resource.openai.azure.com/"
        api-key: ${AZURE_OPENAI_API_KEY}
```

</TabItem>

<TabItem value='openai-compatible-embedding'>

For local models, such as [Ollama](https://ollama.com/), or any third-party API that implements the
[OpenAI embeddings format](https://platform.openai.com/docs/api-reference/embeddings).

| Property                                | Required | Type       | Description                                                              |
| --------------------------------------- | -------- | ---------- | ------------------------------------------------------------------------ |
| `similarity.embedding-model.provider`   | Yes      | `string`   | Set to `openai-compatible`.                                              |
| `similarity.embedding-model.model`      | Yes      | `string`   | Model name (for example `nomic-embed-text`).                             |
| `similarity.embedding-model.base-url`   | Yes      | `string`   | Base URL for the API endpoint (for example `http://localhost:11434/v1`). |
| `similarity.embedding-model.api-key`    | No       | `string`   | API key. Optional for local providers.                                   |
| `similarity.embedding-model.headers.*`  | No       | `map`      | Custom HTTP headers.                                                     |
| `similarity.embedding-model.dimensions` | No       | `integer`  | Number of output dimensions for models that support custom dimensions.   |
| `similarity.embedding-model.timeout`    | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                |

**Example (Ollama):**

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "openai-compatible"
        model: "nomic-embed-text"
        base-url: "http://localhost:11434/v1"
```

</TabItem>

<TabItem value='custom-embedding'>

For providers not listed above, use a custom provider name and pass arbitrary properties. See
[custom EmbeddingModelAdapter](#custom-embeddingmodeladapter) for implementation details.

| Property                                         | Required | Type       | Description                                                                                   |
| ------------------------------------------------ | -------- | ---------- | --------------------------------------------------------------------------------------------- |
| `similarity.embedding-model.provider`            | Yes      | `string`   | Custom provider name matching your SPI implementation.                                        |
| `similarity.embedding-model.model`               | Yes      | `string`   | Model name.                                                                                   |
| `similarity.embedding-model.custom-properties.*` | No       | `map`      | Arbitrary key-value pairs passed to SPI providers via `ProviderConfig.getCustomProperties()`. |
| `similarity.embedding-model.timeout`             | No       | `duration` | Request timeout (ISO-8601 duration, for example `PT30S`).                                     |

**Example:**

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "my-custom-provider"
        model: "my-model"
        custom-properties:
          endpoint: "https://my-embeddings.example.com/v1"
```

</TabItem>
</Tabs>

### Text preprocessors

By default, CPT applies a set of text preprocessors to both the actual and expected values before computing embeddings.
This improves stability of similarity scores by reducing noise from formatting differences. The default preprocessors are:

- **Lowercase normalization**: converts text to lowercase.
- **Unicode normalization**: applies Unicode NFC normalization.
- **Whitespace normalization**: collapses repeated whitespace and trims leading/trailing whitespace.

To disable the default preprocessors, set `similarity.default-preprocessors-enabled` to `false`:

<Tabs groupId="client" defaultValue="spring-sdk-preprocessors" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-preprocessors' },
{label: 'Java client', value: 'java-client-preprocessors' },
]}>

<TabItem value='spring-sdk-preprocessors'>

```yaml
camunda:
  process-test:
    similarity:
      default-preprocessors-enabled: false
```

</TabItem>

<TabItem value='java-client-preprocessors'>

```properties
similarity.defaultPreprocessorsEnabled=false
```

</TabItem>

</Tabs>

You can also configure preprocessors programmatically using `SemanticSimilarityConfig`:

```java
SemanticSimilarityConfig.of(myEmbeddingAdapter, 0.7)
    .withoutPreprocessors();
```

### Custom EmbeddingModelAdapter

You can provide your own `EmbeddingModelAdapter` implementation without depending on the `camunda-process-test-langchain4j`
module.

An `EmbeddingModelAdapter` is a functional interface that takes a string and returns a vector of floating-point numbers representing the text's semantic embedding.

<Tabs groupId="client" defaultValue="spring-sdk-embed" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk-embed' },
{label: 'Java client', value: 'java-client-embed' },
]}>

<TabItem value='spring-sdk-embed'>

If you have a single `EmbeddingModelAdapter` bean and no `provider` property is set, CPT auto-detects and uses it:

```java

@TestConfiguration
class SimilarityTestConfig {

    @Bean
    EmbeddingModelAdapter embeddingModelAdapter() {
        return text -> myEmbeddingClient.embed(text);
    }
}
```

When you have multiple beans, set `provider` to the bean name you want to use. In Spring, the bean name defaults to
the method name:

```java

@TestConfiguration
class SimilarityTestConfig {

    @Bean
    EmbeddingModelAdapter openAiEmbeddingAdapter() { /* ... */ }

    @Bean
    EmbeddingModelAdapter ollamaEmbeddingAdapter() { /* ... */ }
}
```

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "ollamaEmbeddingAdapter" # matches the bean method name
```

:::note Resolution order
When using `@CamundaSpringProcessTest`, CPT resolves the embedding adapter in the following order:

1. If a single `EmbeddingModelAdapter` bean exists and no `provider` property is configured, that bean is used automatically.
2. If the `provider` property is configured and a bean with a matching name exists, that bean is selected.
3. If no matching bean is found, CPT falls back to the built-in LangChain4j implementations, provided that `camunda-process-test-langchain4j` is on the classpath.
4. If a `provider` is configured but no matching implementation can be resolved at all, CPT throws an exception.

:::

Alternatively, you can configure semantic similarity programmatically. Set the configuration globally
using `CamundaAssert.setSemanticSimilarityConfig()`:

```java
CamundaAssert.setSemanticSimilarityConfig(
        SemanticSimilarityConfig.of(text -> myEmbeddingClient.embed(text), 0.8));
```

</TabItem>

<TabItem value='java-client-embed'>

Implement `EmbeddingModelAdapterProvider` and register it through `META-INF/services`:

```java
public class MyCustomEmbeddingProvider implements EmbeddingModelAdapterProvider {

    @Override
    public String getProviderName() {
        return "my-provider";
    }

    @Override
    public EmbeddingModelAdapter create(ProviderConfig config) {
        String endpoint = config.getCustomProperties().get("endpoint");
        return text -> callEndpoint(endpoint, text);
    }
}
```

Register the provider in `META-INF/services/io.camunda.process.test.api.similarity.EmbeddingModelAdapterProvider`:

```
com.example.MyCustomEmbeddingProvider
```

Alternatively, you can configure semantic similarity programmatically. Set the configuration globally
using `CamundaAssert.setSemanticSimilarityConfig()`:

```java
CamundaAssert.setSemanticSimilarityConfig(
        SemanticSimilarityConfig.of(text -> myEmbeddingClient.embed(text), 0.8));
```

Or register the JUnit extension manually with a semantic similarity configuration:

```java

@RegisterExtension
CamundaProcessTestExtension extension = new CamundaProcessTestExtension()
        .withSemanticSimilarityConfig(
                SemanticSimilarityConfig.of(text -> myEmbeddingClient.embed(text), 0.8));
```

</TabItem>

</Tabs>

---

## Connectors

You can run your process test with [Connectors](/components/connectors/introduction.md) to verify the integration with external systems or the configuration of the connector tasks in your processes.

For more unit-focused tests, mock the interaction; for example,
by [completing connector jobs](utilities.md#mock-job-workers) with an expected result.

:::note
The instructions on this page are based on the default Testcontainer runtime. If you are using a remote runtime, consult
the relevant distribution documentation, such
as [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run/configuration.md#use-built-in-and-custom-connectors).
:::

## Enable connectors

By default, the connectors are disabled. You need to change the configuration in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    # Enable connectors
    connectors-enabled: true
```

Or, directly on your test class:

```java
@SpringBootTest(properties = {"camunda.process-test.connectors-enabled=true"})
@CamundaSpringProcessTest
public class MyProcessTest {
    //
}
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
# Enable Connectors
connectorsEnabled=true
```

Or, register the JUnit extension manually and use the fluent builder:

```java
// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
        new CamundaProcessTestExtension()
            // Enable Connectors
            .withConnectorsEnabled(true);
}
```

</TabItem>

</Tabs>

## Connector secrets

If you use [Connectors secrets](/components/connectors/use-connectors/index.md#using-secrets) in your processes, you can
add the secrets to the test runtime in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    connectors-enabled: true
    connectors-secrets:
      GITHUB_TOKEN: ghp_secret
      SLACK_TOKEN: xoxb-secret
```

Or, on your test class:

```java
@SpringBootTest(
    properties = {
        "camunda.process-test.connectors-enabled=true",
        "camunda.process-test.connectors-secrets.GITHUB_TOKEN=ghp_secret",
        "camunda.process-test.connectors-secrets.SLACK_TOKEN=xoxb-secret"
    }
)
@CamundaSpringProcessTest
public class MyProcessTest {
    //
}
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
connectorsEnabled=true

connectorsSecrets.GITHUB_TOKEN=ghp_secret
connectorsSecrets.SLACK_TOKEN=xoxb-secret
```

Or, via JUnit extension:

```java
// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
        new CamundaProcessTestExtension()
            .withConnectorsEnabled(true)
            .withConnectorsSecret("GITHUB_TOKEN", "ghp_secret")
            .withConnectorsSecret("SLACK_TOKEN", "xoxb-secret");
}
```

</TabItem>

</Tabs>

## Invoke an inbound connector

You can retrieve the URL address to invoke an inbound connector in your test from the `CamundaProcessTestContext`.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

```java
@SpringBootTest
@CamundaSpringProcessTest
public class MyProcessTest {

    @Autowired private CamundaClient client;
    @Autowired private CamundaProcessTestContext processTestContext;

    @Test
    void shouldInvokeConnector() {
        // given: a process instance waiting at a connector event

        // when
        final String inboundConnectorAddress =
            processTestContext.getConnectorsAddress() + "/inbound/" + CONNECTOR_ID;
        // invoke the connector address, for example, via HTTP request

        // then: verify that the connector event is completed
    }
}
```

</TabItem>

<TabItem value='java-client'>

```java
@CamundaProcessTest
public class MyProcessTest {

    // to be injected
    private CamundaClient client;
    private CamundaProcessTestContext processTestContext;

    @Test
    void shouldInvokeConnector() {
        // given: a process instance waiting at a connector event

        // when
        final String inboundConnectorAddress =
            processTestContext.getConnectorsAddress() + "/inbound/" + CONNECTOR_ID;
        // invoke the connector address, for example, via HTTP request

        // then: verify that the connector event is completed
    }
}
```

</TabItem>

</Tabs>

:::tip
You might need to wrap the invocation of the connector in a retry loop, for example, by using [Awaitility](http://www.awaitility.org/).

There can be a delay between verifying that the connectors event is active and opening the connectors inbound subscription.
:::

## Access host ports

By default, the connectors run inside the Testcontainers environment in isolation and can't access your local machine.
However, you can
expose [host ports](https://java.testcontainers.org/features/networking/#exposing-host-ports-to-the-container) to the
containers, for example, to invoke a mock HTTP server running on your local machine from an outbound REST connector.

Expose the host ports using `TestContainers.exposeHostPorts(port)`. Inside the container, the local machine is available
under the hostname `host.testcontainers.internal`.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

```java
@WireMockTest(httpPort = 9999)
@SpringBootTest(
    properties = {
        "camunda.process-test.connectors-enabled=true",
        "camunda.process-test.connectors-secrets.BASE_URL=http://host.testcontainers.internal:9999"
    })
@CamundaSpringProcessTest
public class MyProcessTest {

    @Autowired private CamundaClient client;

    @BeforeAll
    static void setup() {
        Testcontainers.exposeHostPorts(9999);
    }

    @Test
    void shouldInvokeUrlFromConnector() {
        // given: stub the HTTP server
        stubFor(
            get(urlPathMatching("/test"))
                .willReturn(
                    aResponse()
                        .withHeader("Content-Type", "application/json")
                        .withStatus(200)
                        .withBody("{\"status\":\"okay\"}")));

        // when: a process instance invoked the outbound connector

        // then: verify the HTTP request
        CamundaAssert.assertThat(processInstance)
            .isCompleted()
            .hasVariable("status", "okay");

        verify(getRequestedFor(urlEqualTo("/test")));
    }
}
```

</TabItem>

<TabItem value='java-client'>

```java
@WireMockTest(httpPort = 9999)
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
        new CamundaProcessTestExtension()
            .withConnectorsEnabled(true)
            .withConnectorsSecret("BASE_URL", "http://host.testcontainers.internal:9999");

    private CamundaClient client;

    @BeforeAll
    static void setup() {
        Testcontainers.exposeHostPorts(9999);
    }

    @Test
    void shouldInvokeUrlFromConnector() {
        // given: stub the HTTP server
        stubFor(
            get(urlPathMatching("/test"))
                .willReturn(
                    aResponse()
                        .withHeader("Content-Type", "application/json")
                        .withStatus(200)
                        .withBody("{\"status\":\"okay\"}")));

        // when: a process instance invoked the outbound connector

        // then: verify the HTTP request
        CamundaAssert.assertThat(processInstance)
                .isCompleted()
                .hasVariable("status", "okay");

        verify(getRequestedFor(urlEqualTo("/test")));
    }
}
```

</TabItem>

</Tabs>

:::tip
You can configure the URL of an outbound connector in your BPMN process
using [Connectors secrets](/components/connectors/use-connectors/index.md#using-secrets) to replace it in the
tests, for example, setting the URL expression to `"{{secrets.BASE_URL}}" + "/test"`.
:::

## Custom connectors

By default, the runtime uses the built-in connectors bundle in the same version as the Maven module. You can change the
version or use a custom connectors bundle in the following way.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

In your `application.yml` (or `application.properties`):

```yaml
camunda:
  process-test:
    connectors-enabled: true
    connectors-docker-image-name: my-org/my-connectors
    connectors-docker-image-version: 1.0.0
```

</TabItem>

<TabItem value='java-client'>

In your `/camunda-container-runtime.properties` file:

```properties
connectorsEnabled=true

connectorsDockerImageName=my-org/my-connectors
connectorsDockerImageVersion=1.0.0
```

Or, via JUnit extension:

```java
// No annotation: @CamundaProcessTest
public class MyProcessTest {

    @RegisterExtension
    private static final CamundaProcessTestExtension EXTENSION =
        new CamundaProcessTestExtension()
            .withConnectorsEnabled(true)
            .withConnectorsDockerImageName("my-org/my-connectors")
            .withConnectorsDockerImageVersion("1.0.0");
}
```

</TabItem>

</Tabs>

---

## Camunda Process Test

<PageDescription />

## About

[Camunda Process Test](https://github.com/camunda/camunda/tree/main/testing/camunda-process-test-java) (CPT) is a Java library to test your BPMN processes and your process application.

CPT provides different runtimes to execute your process tests:

- [Testcontainers runtime](configuration.md#testcontainers-runtime) (default) - A managed runtime based on [Testcontainers](https://java.testcontainers.org/) and Docker.
- [Remote runtime](configuration.md#remote-runtime) - Your own runtime, such as, [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md)

:::info Public API
CPT is part of the Camunda 8 [public API](/reference/public-api.md) and is covered by our SemVer stability guarantees (except for alpha features). Breaking changes will not be introduced in minor or patch releases.
:::

:::note
CPT is the successor to Zeebe Process Test (ZPT). Our previous testing
library was removed in Camunda 8.10. See
the [migration guide](/apis-tools/migration-manuals/migrate-to-camunda-process-test.md) on how to migrate your process
tests.
:::

## Prerequisites

- Java:
  - For the Camunda Java client: 8+
  - For the Camunda Spring Boot Starter: 17+
- [JUnit 5](https://junit.org/junit5/)

For the default [Testcontainers runtime](configuration.md#testcontainers-runtime):

- A Docker-API compatible container runtime, such as Docker on Linux or Docker Desktop on Mac and Windows.

## Install

CPT has two variants:

- For the [Camunda Spring Boot Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md)
- For the [Camunda Java client](/apis-tools/java-client/getting-started.md)

Choose the one depending on which library you use in your process application.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

Add the following dependency to your Maven project:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-process-test-spring</artifactId>
  <version>${camunda.version}</version>
  <scope>test</scope>
</dependency>
```

### Spring Boot 3 support

If you use the [dedicated Spring Boot 3 starter](/apis-tools/camunda-spring-boot-starter/getting-started.md#dedicated-spring-boot-3-and-4-modules) (`camunda-spring-boot-3-starter`),
you must also use the dedicated Spring Boot 3 test artifact:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-process-test-spring-boot-3</artifactId>
  <version>${camunda.version}</version>
  <scope>test</scope>
</dependency>
```

</TabItem>

<TabItem value='java-client'>

Add the following dependency to your Maven project:

```xml
<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-process-test-java</artifactId>
  <version>${camunda.version}</version>
  <scope>test</scope>
</dependency>
```

</TabItem>

</Tabs>

## Write a test

Create a new Java class with the following structure:

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

```java
package com.example;

@SpringBootTest
@CamundaSpringProcessTest
public class MyProcessTest {

    @Autowired private CamundaClient client;
    @Autowired private CamundaProcessTestContext processTestContext;

    @Test
    void shouldCreateProcessInstance() {
        // given process definition is deployed

        // when
        final ProcessInstanceEvent processInstance =
            client
                .newCreateInstanceCommand()
                .bpmnProcessId("my-process")
                .latestVersion()
                .send()
                .join();

        // then
        CamundaAssert.assertThat(processInstance).isActive();
    }
}
```

- `@SpringBootTest` is the standard Spring annotation for tests.
- `@CamundaSpringProcessTest` registers the Camunda test execution listener that starts and stops the test runtime.
- `@Test` is the standard JUnit 5 annotation for a test case.
- (_optional_) Inject a preconfigured `CamundaClient` to interact with the Camunda runtime.
- (_optional_) Inject a `CamundaProcessTestContext` to interact with the test runtime.
- (_optional_) Use `CamundaAssert` to verify the process instance state.

The Spring test requires a Spring Boot process application in the same package. Usually, the process
application [deploys the process resources](/apis-tools/camunda-spring-boot-starter/getting-started.md#deploy-process-models)
using the annotation `@Deployment`.

If you have no process application yet, you can add a minimal one inside the test class as follows:

```java
@SpringBootApplication
@Deployment(resources = "classpath*:/bpmn/**/*.bpmn")
static class TestProcessApplication {}
```

</TabItem>

<TabItem value='java-client'>

```java
package com.example;

@CamundaProcessTest
public class MyProcessTest {

    // to be injected
    private CamundaClient client;
    private CamundaProcessTestContext processTestContext;

    @Test
    void shouldCreateProcessInstance() {
        // given
        client
            .newDeployResourceCommand()
            .addResourceFromClasspath("my-process.bpmn")
            .send()
            .join();

        // when
        final ProcessInstanceEvent processInstance =
            client
                .newCreateInstanceCommand()
                .bpmnProcessId("my-process")
                .latestVersion()
                .send()
                .join();

        // then
        CamundaAssert.assertThat(processInstance).isActive();
    }
}
```

- `@CamundaProcessTest` registers the Camunda JUnit extension that starts and stops the test runtime.
- `@Test` is the standard JUnit 5 annotation for a test case.
- (_optional_) Get a preconfigured `CamundaClient` injected to interact with the Camunda runtime.
- (_optional_) Get a `CamundaProcessTestContext` injected to interact with the test runtime.
- (_optional_) Use `CamundaAssert` to verify the process instance state.

</TabItem>

</Tabs>

:::tip Shared runtime
If you use the same runtime configuration for all test classes, you can use
a [shared runtime](configuration.md#shared-runtime) to speed up the test execution.
:::

### Deploy resources

You can deploy additional BPMN processes and other resources by adding the annotation `@TestDeployment` on the test
class or the method. An annotation on the test method takes precedence over an annotation on the test class. The
resources are loaded from the root classpath of the test.

```java
@Test
@TestDeployment(resources = "my-process.bpmn")
void shouldCreateProcessInstance() {
  // the given resources are deployed before running the test
}
```

## Test lifecycle

CPT performs the following actions during the JUnit 5 lifecycle when running a test class:

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]}>

<TabItem value='spring-sdk'>

- `beforeAll` (test methods)
  - Start the test runtime
- `beforeEach` (test method)
  - Inject the `CamundaClient`, the `CamundaProcessTestContext`, and the `TestScenarioRunner`
  - Publish the client created event for the Spring Boot process application to trigger the deployment and start job
    workers
  - Deploy resources defined via `@TestDeployment`
- `afterEach` (test method)
  - Collect the data for the coverage report
  - Print the created process instances if the test failed
  - Close the client connections
  - Publish the client closed event for the Spring Boot process application to stop job workers
  - Reset the Camunda runtime clock
  - Delete all data in the Camunda runtime
- `afterAll` (test methods)
  - Generate the coverage report
  - Stop the test runtime

### Limitations

CPT doesn't support Spring Boot process applications with `@PostConstruct` methods or a `CommandLineRunner`
implementation. These methods are executed when the test class is initialized, but not before each test method.

We recommend to use a minimal configuration for the test instead of the Spring Boot process application and invoke the
`@PostConstruct` or `run()` methods manually before each test method.

```java
@SpringBootTest(classes = {TestProcessApplication.class})
@CamundaSpringProcessTest
public class ProcessTest {

  @Autowired private CamundaClient client;

  @BeforeEach
  void invokeProcessApplication() throws Exception {
    final Application springBootApplication = new Application();
    springBootApplication.setCamundaClient(client);
    // call the @PostConstruct methods
    springBootApplication.afterStarted();
    // call the CommandLineRunner method
    springBootApplication.run();
  }

}
```

Minimal test configuration:

```java
// must be in a different package than the Spring Boot application
package org.example.test;

@SpringBootApplication(
  // list all required packages for the process test, such as job workers
  scanBasePackages = {"org.example.services", "org.example.workers"}
)
@Deployment(resources = "classpath*:/bpmn/**/*.bpmn")
public class TestProcessApplication {}
```

</TabItem>

<TabItem value='java-client'>

- `beforeAll` (test methods)
  - Start the test runtime
- `beforeEach` (test method)
  - Inject the `CamundaClient`, the `CamundaProcessTestContext`, and the `TestScenarioRunner`
  - Deploy resources defined via `@TestDeployment`
- `afterEach` (test method)
  - Collect the data for the coverage report
  - Print the created process instances if the test failed
  - Close the client connections
  - Reset the Camunda runtime clock
  - Delete all data in the Camunda runtime
- `afterAll` (test methods)
  - Generate the coverage report
  - Stop the test runtime

</TabItem>

</Tabs>

## Next steps

Learn more about the following topics:

- `CamundaAssert` and [assertions](assertions.md)
- `CamundaProcessTestContext` and [utilities](utilities.md)
- How to [configure the runtime](configuration.md)
- How to [test AI agent processes](/components/agentic-orchestration/evaluate-agents/test-ai-agents.md)
- Best practices for [writing process tests](/components/best-practices/development/testing-process-definitions.md)

Refer to the [API documentation](https://javadoc.io/doc/io.camunda/camunda-process-test-java/latest/io/camunda/process/test/api/package-summary.html) for details.

## Examples

Take a look at the example project on [GitHub](https://github.com/camunda/camunda/tree/main/testing/camunda-process-test-example). This demonstrates the usage of the library for a demo Spring Boot process application.

## Process Test Coverage

After a test run, CPT prints the coverage of your BPMN processes and DMN decision tables to the log and generates a
detailed HTML and JSON report. You can use the report to identify untested paths in your processes and decision tables, and increase your test coverage.

A link to the HTML report is printed in the log:

```
Coverage: io.camunda.InvoiceApprovalTest
========================
Process coverage:
- Process_InvoiceApproval: 96%

Decision coverage:
- auto-approve-invoice: 20%

 Coverage report: file:///my/home/projects/my-process-application/target/coverage-report/report.html
```

![An example process test coverage HTML report](assets/process-coverage-report.png)

---

## JSON test cases

You can write your process tests in JSON format instead of coding the test logic in Java. The JSON file describes test cases with instructions that align with CPT's assertions and utilities.

CPT's JSON test cases use the same schema as [test scenario files in Play](/components/hub/workspace/modeler/validation/test-scenario-files.md), so you can edit the same files in Play and execute them with CPT.

## Write a JSON test case

The JSON format is defined in the [JSON schema](https://camunda.com/json-schema/cpt-test-cases/8.9/schema.json). It defines the following structure:

- `testCases`: An array of test cases to be executed.
  - `name`: The name of the test case.
  - `description`: A description of the test case.
  - `instructions`: An array of [instructions](#reference-instructions) to execute the test case.
    - Each instruction has a `type` that defines the action to be performed (for example, `CREATE_PROCESS_INSTANCE`).
    - Additional properties depend on the instruction type (for example, process definition ID and variables).

How to start:

1. Create a new JSON file in your test resources folder (for example, `src/test/resources/test-cases/invoice-approval.json`)
2. Refer to the JSON schema `https://camunda.com/json-schema/cpt-test-cases/8.9/schema.json` in the `$schema` property.
   Use the same schema version as the CPT version you are using to ensure compatibility.
3. Add your test cases and use the [available instructions](#reference-instructions) to define the behavior of your process test.

The basic structure of the JSON file looks like this:

```JSON
{
  "$schema": "https://camunda.com/json-schema/cpt-test-cases/8.9/schema.json",
  "testCases": [
    {
      "name": "My first test case",
      "description": "A human-readable description of the test case.",
      "instructions": [
      ]
    }
  ]
}
```

You can find a full example of a JSON test case file in the [Examples](#examples) section below.

:::tip
Use AI to support the generation of your JSON files. Refer to the documentation, provide a description of your test case, and your BPMN processes to get a first draft of your test cases.

Or, use an IDE with JSON schema support to get auto-completion and validation while writing your test cases, for example [IntelliJ IDEA](https://www.jetbrains.com/help/idea/json.html#ws_json_schema_add_custom).
:::

## Run a JSON test case

You can run your JSON test case files as parameterized JUnit tests. Add the `@TestCaseSource` annotation to your test method to read the files and provide test cases as arguments. Then, execute the test cases using the `TestCaseRunner` provided by CPT.

The runner executes the test case instructions by leveraging CPT's assertions and utilities. If an assertion instruction fails, the runner throws an assertion error, causing the test to fail. If all instructions pass, the test case is considered successful.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

```java
@SpringBootTest
@CamundaSpringProcessTest
public class MyProcessTest {

    @Autowired private TestCaseRunner testCaseRunner;

    @ParameterizedTest
    @TestCaseSource
    void shouldPass(final TestCase testCase, final String fileName) {
        // given: the process definitions are deployed

        // when/then: run and verify the test case
        testCaseRunner.run(testCase);
    }
}
```

</TabItem>
<TabItem value='java-client'>

```java
@CamundaProcessTest
public class MyProcessTest {

    private TestCaseRunner testCaseRunner;

    @ParameterizedTest
    @TestCaseSource
    void shouldPass(final TestCase testCase, final String fileName) {
        // given: the process definitions are deployed

        // when/then: run and verify the test case
        testCaseRunner.run(testCase);
    }
}
```

</TabItem>
</Tabs>

You can set the following fields in the `@TestCaseSource` annotation to configure which files to load:

- `directory`: The classpath directory to scan for JSON test case files. Defaults to `/test-cases`.
- `fileNames`: An array of specific file names to load from the directory. If not set, all files in the directory are loaded.
- `fileExtension`: The file extension to filter files in the directory. Defaults to `json`. The filter is ignored if `fileNames` is set.

### Connect your process application

The `TestCaseRunner` integrates seamlessly with CPT's [test lifecycle](getting-started.md#test-lifecycle). It connects to your process application and starts job workers, if enabled.

You can add additional steps before and after running the test case, for example, to deploy additional resources or to mock external services of your process application.

<Tabs groupId="client" defaultValue="spring-sdk" queryString values={
[
{label: 'Camunda Spring Boot Starter', value: 'spring-sdk' },
{label: 'Java client', value: 'java-client' }
]
}>

<TabItem value='spring-sdk'>

```java
@SpringBootTest
@CamundaSpringProcessTest
public class MyProcessTest {

    @Autowired private CamundaClient client;
    @Autowired private CamundaProcessTestContext processTestContext;
    @Autowired private TestCaseRunner testCaseRunner;

    @MockitoBean private AccountingService accountingService;

    @ParameterizedTest
    @TestCaseSource
    void shouldPass(final TestCase testCase, final String fileName) {
        // given: the process definitions are deployed via @Deployment on the process application
        // optionally: set up mocks, job workers, etc.

        // when/then: run and verify the test case
        testCaseRunner.run(testCase);

        // optionally: verify mock invocations, external resources, etc.
        Mockito.verify(accountingService).addInvoiceToAccount("0815", "INV-1001");
    }
}
```

</TabItem>

<TabItem value='java-client'>

```java
@CamundaProcessTest
@ExtendWith(MockitoExtension.class)
public class MyProcessTest {

    private CamundaClient client;
    private CamundaProcessTestContext processTestContext;
    private TestCaseRunner testCaseRunner;

    // Inject the mock in the process application
    @Mock private AccountingService accountingService;

    @ParameterizedTest
    @TestCaseSource
    @TestDeployment(resources = "invoice-approval.bpmn")
    void shouldPass(final TestCase testCase, final String fileName) {
        // given: the process definitions are deployed via @TestDeployment
        // optionally: set up mocks, job workers, etc.

        // when/then: run and verify the test case
        testCaseRunner.run(testCase);

        // optionally: verify mock invocations, external resources, etc.
        Mockito.verify(accountingService).addInvoiceToAccount("0815", "INV-1001");
    }
}
```

</TabItem>

</Tabs>

## Examples

You can find some example process tests using JSON test cases on [GitHub](https://github.com/camunda/camunda/tree/main/testing/camunda-process-test-example), like the following one:

```json reference referenceLinkText="Source" title="Invoice Approval JSON test case"
https://github.com/camunda/camunda/blob/stable/8.9/testing/camunda-process-test-example/src/test/resources/test-cases/invoice-approval.json
```

## Reference: Instructions

Instructions define the actions and assertions to be performed in a test case. Each instruction has a `type` property that identifies the instruction, along with additional properties specific to that instruction type.

### ASSERT_DECISION

An instruction to assert the evaluation of a decision. See the [assertions documentation](assertions.md#decision-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_DECISION"
    string
    Yes
    
  
  
    decisionSelector
    The selector to identify the decision.
    DecisionSelector
    Yes
    
  
  
    output
    Expected output of the decision. Can be any JSON type.
    any
    No
    
  
  
    matchedRules
    Expected matched rule indexes
    array of integer
    No
    
  
  
    notMatchedRules
    Expected not matched rule indexes
    array of integer
    No
    
  
  
    noMatchedRules
    Assert that no rules were matched
    boolean
    No
    false
  

Example:

```json
{
  "type": "ASSERT_DECISION",
  "decisionSelector": {
    "decisionDefinitionId": "ChooseRocket"
  },
  "output": {
    "rocket": "Ariane 6"
  },
  "matchedRules": [3]
}
```

### ASSERT_ELEMENT_INSTANCE

An instruction to assert the state of an element instance. See the [assertions documentation](assertions.md#element-instance-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_ELEMENT_INSTANCE"
    string
    Yes
    
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
    
  
  
    elementSelector
    The selector to identify the element.
    ElementSelector
    Yes
    
  
  
    state
    The expected state of the element instance.
    enum: IS_ACTIVE, IS_COMPLETED, IS_TERMINATED
    Yes
    
  
  
    amount
    The expected amount of element instances in the given state.
    integer (minimum: 1)
    No
    1
  

Example:

```json
{
  "type": "ASSERT_ELEMENT_INSTANCE",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "elementSelector": {
    "elementId": "LaunchRocket"
  },
  "state": "IS_COMPLETED"
}
```

### ASSERT_ELEMENT_INSTANCES

An instruction to assert the state of multiple element instances. See the [assertions documentation](assertions.md#element-instance-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_ELEMENT_INSTANCES"
    string
    Yes
    
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
    
  
  
    elementSelectors
    The selectors to identify the elements.
    array of ElementSelector
    Yes
    
  
  
    state
    The expected state of the element instances.
    enum: IS_ACTIVE, IS_COMPLETED, IS_TERMINATED, IS_NOT_ACTIVE, IS_NOT_ACTIVATED, IS_ACTIVE_EXACTLY, IS_COMPLETED_IN_ORDER
    Yes
    
  

Example:

```json
{
  "type": "ASSERT_ELEMENT_INSTANCES",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "elementSelectors": [
    { "elementId": "PrepareMission" },
    { "elementId": "LaunchRocket" },
    { "elementId": "LandOnMoon" }
  ],
  "state": "IS_COMPLETED_IN_ORDER"
}
```

### ASSERT_PROCESS_INSTANCE

An instruction to assert the state of a process instance. See the [assertions documentation](assertions.md#process-instance-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_PROCESS_INSTANCE"
    string
    Yes
    
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
    
  
  
    state
    The expected state of the process instance.
    enum: IS_ACTIVE, IS_COMPLETED, IS_CREATED, IS_TERMINATED
    No
    
  
  
    hasActiveIncidents
    Whether the process instance has active incidents.
    boolean
    No
    
  

Example:

```json
{
  "type": "ASSERT_PROCESS_INSTANCE",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "state": "IS_COMPLETED"
}
```

### ASSERT_PROCESS_INSTANCE_MESSAGE_SUBSCRIPTION

An instruction to assert the state of a process instance message subscription. See the [assertions documentation](assertions.md#process-instance-message-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_PROCESS_INSTANCE_MESSAGE_SUBSCRIPTION"
    string
    Yes
    
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
    
  
  
    messageSelector
    The selector to identify the message.
    MessageSelector
    Yes
    
  
  
    state
    The expected state of the message subscription.
    enum: IS_WAITING, IS_NOT_WAITING, IS_CORRELATED
    Yes
    
  

Example:

```json
{
  "type": "ASSERT_PROCESS_INSTANCE_MESSAGE_SUBSCRIPTION",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "messageSelector": {
    "messageName": "AstronautReady"
  },
  "state": "IS_CORRELATED"
}
```

### ASSERT_USER_TASK

An instruction to assert the state of a user task. See the [assertions documentation](assertions.md#user-task-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_USER_TASK"
    string
    Yes
    
  
  
    userTaskSelector
    The selector to identify the user task.
    UserTaskSelector
    Yes
    
  
  
    state
    The expected state of the user task.
    enum: IS_CREATED, IS_COMPLETED, IS_CANCELED, IS_FAILED
    No
    
  
  
    assignee
    The expected assignee of the user task.
    string
    No
    
  
  
    candidateGroups
    The expected candidate groups of the user task.
    array of string
    No
    
  
  
    priority
    The expected priority of the user task.
    integer
    No
    
  
  
    elementId
    The expected element ID of the user task.
    string
    No
    
  
  
    name
    The expected name of the user task.
    string
    No
    
  
  
    dueDate
    The expected due date of the user task in ISO-8601 format.
    string
    No
    
  
  
    followUpDate
    The expected follow-up date of the user task in ISO-8601 format.
    string
    No
    
  

Example:

```json
{
  "type": "ASSERT_USER_TASK",
  "userTaskSelector": {
    "elementId": "ReviewMissionPlan"
  },
  "state": "IS_CREATED",
  "assignee": "zee-astronaut",
  "priority": 100
}
```

### ASSERT_VARIABLE

An instruction to assert a single variable of a process instance. See the [assertions documentation](assertions.md#variable-assertions) for more details.

  
    Property
    Description
    Type
    Required
  
  
    type
    Instruction type, must be "ASSERT_VARIABLE"
    string
    Yes
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
  
  
    elementSelector
    The selector to identify the element for local variables.
    ElementSelector
    No
  
  
    variableName
    The name of the variable to evaluate.
    string
    Yes
  
  
    satisfiesExpression
    A FEEL expression assertion that must evaluate to <code>true</code> for the given variable.
    string
    No
  
  
    satisfiesJudge
    An LLM judge assertion that evaluates the variable against a semantic expectation.
    JudgeAssertion
    No
  
  
    similarTo
    A semantic similarity assertion that checks the variable value against an expected value using text embeddings.
    SemanticSimilarityAssertion
    No
  

Example:

```json
{
  "type": "ASSERT_VARIABLE",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "variableName": "mission",
  "satisfiesExpression": "mission.status = \"completed\" and list contains(mission.astronauts, \"Zee\")"
}
```

#### Judge Assertion

An LLM-as-judge assertion that evaluates a variable against a semantic expectation.

  
    Property
    Description
    Type
    Required
  
  
    expectation
    The semantic expectation for the variable value.
    string
    Yes
  
  
    threshold
    The score threshold (0.0–1.0) at or above which the assertion passes. Defaults to the threshold configured in the CPT runtime (0.5 if not configured).
    number (0.0–1.0)
    No
  
  
    customPrompt
    A custom prompt for the judge evaluation. Overrides the configured custom prompt.
    string
    No
  
  
    attachDocuments
    When true, resolves Camunda document references in the variable value and attaches their content to the judge. Overrides the configured <code>judge.attach-documents</code> setting. To evaluate attached content, use a multimodal-capable model; otherwise, CPT evaluates only the raw variable JSON.
    boolean
    No
  

Example:

```json
{
  "type": "ASSERT_VARIABLE",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "variableName": "missionSummary",
  "satisfiesJudge": {
    "expectation": "The summary confirms a successful moon landing.",
    "threshold": 0.8
  }
}
```

#### Semantic Similarity Assertion

A semantic similarity assertion that checks a variable value against an expected value using text embeddings.

  
    Property
    Description
    Type
    Required
  
  
    expectedValue
    The expected value the variable should be semantically similar to.
    string
    Yes
  
  
    threshold
    The minimum similarity score (0.0–1.0) for the assertion to pass. Defaults to the threshold configured in the CPT runtime (0.5 if not configured).
    number (0.0–1.0)
    No
  

Example:

```json
{
  "type": "ASSERT_VARIABLE",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "elementSelector": {
    "elementId": "ReviewMissionPlan"
  },
  "variableName": "reviewComment",
  "similarTo": {
    "expectedValue": "The mission plan meets the required standards.",
    "threshold": 0.85
  }
}
```

### ASSERT_VARIABLES

An instruction to assert the variables of a process instance. See the [assertions documentation](assertions.md#variable-assertions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "ASSERT_VARIABLES"
    string
    Yes
    
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
    
  
  
    elementSelector
    The selector to identify the element for local variables.
    ElementSelector
    No
    
  
  
    variableNames
    The expected variable names.
    array of string
    No
    
  
  
    variables
    The expected variables with their values.
    object
    No
    
  

Example:

```json
{
  "type": "ASSERT_VARIABLES",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "variables": {
    "missionStatus": "completed",
    "astronautName": "Zee"
  }
}
```

### BROADCAST_SIGNAL

An instruction to broadcast a signal.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "BROADCAST_SIGNAL"
    string
    Yes
    
  
  
    signalName
    The name of the signal to broadcast.
    string
    Yes
    
  
  
    variables
    The variables to broadcast with the signal.
    object
    No
    
  

Example:

```json
{
  "type": "BROADCAST_SIGNAL",
  "signalName": "EmergencyEvacuation",
  "variables": {
    "reason": "meteor-shower",
    "destination": "space-station"
  }
}
```

### COMPLETE_JOB

An instruction to complete a job. See the [utilities documentation](utilities.md#complete-jobs) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "COMPLETE_JOB"
    string
    Yes
    
  
  
    jobSelector
    The selector to identify the job to complete.
    JobSelector
    Yes
    
  
  
    variables
    The variables to complete the job with.
    object
    No
    
  
  
    useExampleData
    Whether to complete the job with example data from the BPMN element. This property has precedence over variables.
    boolean
    No
    false
  

Example:

```json
{
  "type": "COMPLETE_JOB",
  "jobSelector": {
    "jobType": "analyze-moon-samples"
  },
  "variables": {
    "analysisResult": "high-mineral-content"
  }
}
```

### COMPLETE_JOB_AD_HOC_SUB_PROCESS

An instruction to complete a job of an ad-hoc sub-process. See the [utilities documentation](utilities.md#ad-hoc-sub-process-jobs) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "COMPLETE_JOB_AD_HOC_SUB_PROCESS"
    string
    Yes
    
  
  
    jobSelector
    The selector to identify the job to complete.
    JobSelector
    Yes
    
  
  
    variables
    The variables to complete the job with.
    object
    No
    
  
  
    activateElements
    The elements to activate in the ad-hoc sub-process.
    array of ActivateElementInstruction
    No
    
  
  
    cancelRemainingInstances
    Whether to cancel remaining instances of the ad-hoc sub-process.
    boolean
    No
    false
  
  
    completionConditionFulfilled
    Whether the completion condition of the ad-hoc sub-process is fulfilled.
    boolean
    No
    false
  

#### Activate Element Instruction

An instruction to activate an element in an ad-hoc sub-process.

  
    Property
    Description
    Type
    Required
  
  
    elementId
    The ID of the element to activate.
    string
    Yes
  
  
    variables
    The variables to set when activating the element.
    object
    No
  

Example:

```json
{
  "type": "COMPLETE_JOB_AD_HOC_SUB_PROCESS",
  "jobSelector": {
    "elementId": "conduct-experiment"
  },
  "variables": {
    "experimentResult": "success"
  },
  "activateElements": [
    {
      "elementId": "CollectMoonSamples",
      "variables": {
        "sampleType": "regolith"
      }
    }
  ]
}
```

### COMPLETE_JOB_USER_TASK_LISTENER

An instruction to complete a job of a user task listener. See the [utilities documentation](utilities.md#user-task-listener-jobs) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "COMPLETE_JOB_USER_TASK_LISTENER"
    string
    Yes
    
  
  
    jobSelector
    The selector to identify the job to complete.
    JobSelector
    Yes
    
  
  
    denied
    Whether the worker denies the work.
    boolean
    No
    false
  
  
    deniedReason
    The reason for denying the job.
    string
    No
    
  
  
    corrections
    The corrections to apply to the user task. Only applicable if denied is false.
    UserTaskCorrections
    No
    
  

#### User Task Corrections

The corrections to apply to a user task.

  
    Property
    Description
    Type
    Required
  
  
    assignee
    The assignee of the task.
    string
    No
  
  
    dueDate
    The due date of the task.
    string
    No
  
  
    followUpDate
    The follow up date of the task.
    string
    No
  
  
    candidateUsers
    The candidate users of the task.
    array of string
    No
  
  
    candidateGroups
    The candidate groups of the task.
    array of string
    No
  
  
    priority
    The priority of the task.
    integer
    No
  

Example:

```json
{
  "type": "COMPLETE_JOB_USER_TASK_LISTENER",
  "jobSelector": {
    "jobType": "validate-astronaut-assignment"
  },
  "corrections": {
    "assignee": "zee-senior-astronaut",
    "priority": 50
  }
}
```

### COMPLETE_USER_TASK

An instruction to complete a user task. See the [utilities documentation](utilities.md#complete-user-tasks) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "COMPLETE_USER_TASK"
    string
    Yes
    
  
  
    userTaskSelector
    The selector to identify the user task to complete.
    UserTaskSelector
    Yes
    
  
  
    variables
    The variables to set when completing the user task. Ignored if useExampleData is true.
    object
    No
    
  
  
    useExampleData
    Whether to complete the user task with example data from the BPMN element. If true, the variables property is ignored.
    boolean
    No
    false
  

Example:

```json
{
  "type": "COMPLETE_USER_TASK",
  "userTaskSelector": {
    "elementId": "ReviewMissionPlan"
  },
  "variables": {
    "approved": true,
    "comments": "Mission plan looks good for moon exploration"
  }
}
```

### CONDITIONAL_BEHAVIOR

An instruction to register a conditional behavior that reacts to process state changes. See the [utilities documentation](utilities.md#conditional-behavior) for more details.

The conditions form a conjunction; the behavior fires only when every assertion succeeds. Actions are consumed in order: the first match fires the first action, the second match fires the second, and the last action repeats indefinitely.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "CONDITIONAL_BEHAVIOR"
    string
    Yes
    
  
  
    name
    A descriptive name for diagnostics and log messages.
    string
    No
    
  
  
    conditions
    The ASSERT_* instructions to watch. The behavior fires only when every condition succeeds (conjunction).
    array of instructions
    Yes
    
  
  
    actions
    The action instructions to execute when all conditions are met. Consumed in order; the last action repeats indefinitely.
    array of instructions
    Yes
    
  

Example:

```json
{
  "type": "CONDITIONAL_BEHAVIOR",
  "name": "auto-complete-review-task",
  "conditions": [
    {
      "type": "ASSERT_USER_TASK",
      "userTaskSelector": {
        "taskName": "Review Task"
      },
      "state": "IS_CREATED"
    }
  ],
  "actions": [
    {
      "type": "COMPLETE_USER_TASK",
      "userTaskSelector": {
        "taskName": "Review Task"
      },
      "variables": {
        "approved": true
      }
    }
  ]
}
```

### CORRELATE_MESSAGE

An instruction to correlate a message.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "CORRELATE_MESSAGE"
    string
    Yes
    
  
  
    name
    The name of the message.
    string
    Yes
    
  
  
    correlationKey
    The correlation key of the message.
    string
    No
    
  
  
    variables
    The variables to correlate with the message.
    object
    No
    
  

Example:

```json
{
  "type": "CORRELATE_MESSAGE",
  "name": "AstronautReady",
  "correlationKey": "mission-001",
  "variables": {
    "astronautName": "Zee",
    "status": "ready-for-launch"
  }
}
```

### CREATE_PROCESS_INSTANCE

An instruction to create a new process instance.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "CREATE_PROCESS_INSTANCE"
    string
    Yes
    
  
  
    processDefinitionSelector
    The selector to identify the process definition to create the process instance for.
    ProcessDefinitionSelector
    Yes
    
  
  
    variables
    The variables to create the process instance with.
    object
    No
    
  
  
    startInstructions
    The instructions to execute when starting the process instance.
    array of StartInstruction
    No
    
  
  
    runtimeInstructions
    The instructions to affect the runtime behavior of the process instance.
    array of RuntimeInstruction
    No
    
  

#### Start Instruction

An instruction to execute when starting a process instance.

  
    Property
    Description
    Type
    Required
  
  
    elementId
    The ID of the element to start the process instance at.
    string
    Yes
  

#### Runtime Instruction

An instruction to affect the runtime behavior of a process instance.

  
    Property
    Description
    Type
    Required
  
  
    type
    The type of the runtime instruction. Currently supports "TERMINATE_PROCESS_INSTANCE".
    string
    Yes
  
  
    afterElementId
    The ID of the element after which to terminate the process instance. Required when type is "TERMINATE_PROCESS_INSTANCE".
    string
    Yes
  

Example:

```json
{
  "type": "CREATE_PROCESS_INSTANCE",
  "processDefinitionSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "variables": {
    "missionName": "Artemis-Zee",
    "destination": "Moon",
    "astronautCount": 4
  }
}
```

### EVALUATE_CONDITIONAL_START_EVENT

An instruction to evaluate conditional start events.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "EVALUATE_CONDITIONAL_START_EVENT"
    string
    Yes
    
  
  
    variables
    The variables to evaluate the conditional start events with.
    object
    Yes
    
  

Example:

```json
{
  "type": "EVALUATE_CONDITIONAL_START_EVENT",
  "variables": {
    "weatherCondition": "clear",
    "fuelLevel": 100
  }
}
```

### EVALUATE_DECISION

An instruction to evaluate a DMN decision.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "EVALUATE_DECISION"
    string
    Yes
    
  
  
    decisionDefinitionSelector
    The selector to identify the decision definition to evaluate.
    DecisionDefinitionSelector
    Yes
    
  
  
    variables
    The variables to evaluate the decision with.
    object
    No
    
  

Example:

```json
{
  "type": "EVALUATE_DECISION",
  "decisionDefinitionSelector": {
    "decisionDefinitionId": "ChooseRocket"
  },
  "variables": {
    "payload": 5000,
    "destination": "Moon"
  }
}
```

### INCREASE_TIME

An instruction to increase the time. See the [utilities documentation](utilities.md#increase-time) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "INCREASE_TIME"
    string
    Yes
    
  
  
    duration
    The duration to increase the time by, in ISO 8601 duration format (for example, "PT1H", "P2D").
    string
    Yes
    
  

Example:

```json
{
  "type": "INCREASE_TIME",
  "duration": "P3D"
}
```

### MOCK_CHILD_PROCESS

An instruction to mock a child process. See the [utilities documentation](utilities.md#mock-child-processes) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "MOCK_CHILD_PROCESS"
    string
    Yes
    
  
  
    processDefinitionId
    The ID of the child process to mock.
    string
    Yes
    
  
  
    variables
    The variables to set for the mocked child process.
    object
    No
    
  
  
    versionTag
    The version tag for the deployed stub process. Required when the call activity uses <code>bindingType="versionTag"</code>.
    string
    No
    
  

Example:

```json
{
  "type": "MOCK_CHILD_PROCESS",
  "processDefinitionId": "AstronautTrainingProcess",
  "variables": {
    "trainingCompleted": true,
    "grade": "excellent"
  }
}
```

### MOCK_DMN_DECISION

An instruction to mock a DMN decision. See the [utilities documentation](utilities.md#mock-dmn-decisions) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "MOCK_DMN_DECISION"
    string
    Yes
    
  
  
    decisionDefinitionId
    The decision definition ID to mock.
    string
    Yes
    
  
  
    variables
    The variables to set as the decision output. Deprecated, use <code>decisionOutput</code>.
    object
    No
    
  
  
    decisionOutput
    The decision output to mock. Can be any JSON type.
    any
    No
    
  

Example:

```json
{
  "type": "MOCK_DMN_DECISION",
  "decisionDefinitionId": "ChooseRocket",
  "decisionOutput": "Falcon Heavy"
}
```

### MOCK_JOB_WORKER_COMPLETE_JOB

An instruction to mock a job worker who completes jobs. See the [utilities documentation](utilities.md#complete-job) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "MOCK_JOB_WORKER_COMPLETE_JOB"
    string
    Yes
    
  
  
    jobType
    The job type to mock. This should match the zeebeJobType in the BPMN model.
    string
    Yes
    
  
  
    variables
    The variables to complete the job with.
    object
    No
    
  
  
    useExampleData
    Whether to use example data from the BPMN element. If true, the variables property is ignored.
    boolean
    No
    false
  

Example:

```json
{
  "type": "MOCK_JOB_WORKER_COMPLETE_JOB",
  "jobType": "calculate-trajectory",
  "variables": {
    "trajectory": "optimal",
    "fuelConsumption": 450
  }
}
```

### MOCK_JOB_WORKER_THROW_BPMN_ERROR

An instruction to mock a job worker who throws BPMN errors. See the [utilities documentation](utilities.md#throw-bpmn-error) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "MOCK_JOB_WORKER_THROW_BPMN_ERROR"
    string
    Yes
    
  
  
    jobType
    The job type to mock. This should match the zeebeJobType in the BPMN model.
    string
    Yes
    
  
  
    errorCode
    The error code to throw. This should match the error code in an error catch event.
    string
    Yes
    
  
  
    errorMessage
    The error message to include when throwing the error.
    string
    No
    
  
  
    variables
    The variables to include when throwing the error.
    object
    No
    
  

Example:

```json
{
  "type": "MOCK_JOB_WORKER_THROW_BPMN_ERROR",
  "jobType": "launch-rocket",
  "errorCode": "WEATHER_UNSUITABLE",
  "errorMessage": "High winds detected"
}
```

### PUBLISH_MESSAGE

An instruction to publish a message.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "PUBLISH_MESSAGE"
    string
    Yes
    
  
  
    name
    The name of the message.
    string
    Yes
    
  
  
    correlationKey
    The correlation key of the message.
    string
    No
    
  
  
    variables
    The variables to publish with the message.
    object
    No
    
  
  
    timeToLive
    The time-to-live of the message in milliseconds.
    integer
    No
    
  
  
    messageId
    The message ID for uniqueness.
    string
    No
    
  

Example:

```json
{
  "type": "PUBLISH_MESSAGE",
  "name": "LaunchApproved",
  "correlationKey": "mission-001",
  "variables": {
    "approvedBy": "mission-control",
    "launchWindow": "2026-03-15T10:00:00Z"
  }
}
```

### RESOLVE_INCIDENT

An instruction to resolve an incident. See the [utilities documentation](utilities.md#resolve-incidents) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "RESOLVE_INCIDENT"
    string
    Yes
    
  
  
    incidentSelector
    The selector to identify the incident to resolve.
    IncidentSelector
    Yes
    
  

Example:

```json
{
  "type": "RESOLVE_INCIDENT",
  "incidentSelector": {
    "elementId": "LaunchRocket"
  }
}
```

### SET_TIME

An instruction to set the time. See the [utilities documentation](utilities.md#set-time) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "SET_TIME"
    string
    Yes
    
  
  
    time
    The time to set, in ISO 8601 instant format (for example, "2026-01-19T13:00:00Z").
    string
    Yes
    
  

Example:

```json
{
  "type": "SET_TIME",
  "time": "2026-03-15T10:00:00Z"
}
```

### THROW_BPMN_ERROR_FROM_JOB

An instruction to throw a BPMN error from a job. See the [utilities documentation](utilities.md#throw-bpmn-errors-from-jobs) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "THROW_BPMN_ERROR_FROM_JOB"
    string
    Yes
    
  
  
    jobSelector
    The selector to identify the job to throw the error from.
    JobSelector
    Yes
    
  
  
    errorCode
    The error code to throw.
    string
    Yes
    
  
  
    errorMessage
    The error message to throw.
    string
    No
    
  
  
    variables
    The variables to set when throwing the error.
    object
    No
    
  

Example:

```json
{
  "type": "THROW_BPMN_ERROR_FROM_JOB",
  "jobSelector": {
    "jobType": "deploy-satellite"
  },
  "errorCode": "DEPLOYMENT_FAILED",
  "errorMessage": "Insufficient orbital velocity"
}
```

### UPDATE_VARIABLES

An instruction to create or update process instance variables. See the [utilities documentation](utilities.md#update-variables) for more details.

  
    Property
    Description
    Type
    Required
    Default
  
  
    type
    Instruction type, must be "UPDATE_VARIABLES"
    string
    Yes
    
  
  
    processInstanceSelector
    The selector to identify the process instance.
    ProcessInstanceSelector
    Yes
    
  
  
    variables
    The variables to create or update.
    object
    Yes
    
  
  
    elementSelector
    The selector to identify the element for local variables.
    ElementSelector
    No
    
  
  
    createLocalVariables
    Whether to create variables locally in the scope of the element (requires <code>elementSelector</code>). When <code>true</code>, variables are created in the element's local scope and are not propagated to parent scopes.
    boolean
    No
    false
  

Example:

```json
{
  "type": "UPDATE_VARIABLES",
  "processInstanceSelector": {
    "processDefinitionId": "MoonExplorationProcess"
  },
  "variables": {
    "currentPhase": "landing",
    "fuelRemaining": 75
  }
}
```

## Reference: Selectors

Selectors are used to identify specific resources in your process tests. Each selector must contain at least one of the specified properties.

### Decision Definition Selector

A selector to identify a decision definition.

  
    Property
    Description
    Type
    Required
  
  
    decisionDefinitionId
    ID of the decision definition
    string
    Yes
  

Example:

```json
{
  "decisionDefinitionId": "ChooseRocket"
}
```

### Decision Selector

A selector to identify a decision. The selector must contain at least one of the following properties:

  
    Property
    Description
    Type
    Required
  
  
    decisionDefinitionId
    ID of the decision definition
    string
    No
  
  
    decisionDefinitionName
    Name of the decision definition
    string
    No
  

Example:

```json
{
  "decisionDefinitionId": "ChooseRocket"
}
```

### Element Selector

A selector to identify a BPMN element. The selector must contain at least one of the following properties:

  
    Property
    Description
    Type
    Required
  
  
    elementId
    ID of the BPMN element
    string
    No
  
  
    elementName
    Name of the BPMN element
    string
    No
  

Example:

```json
{
  "elementId": "LaunchRocket"
}
```

### Incident Selector

A selector to identify an incident. The selector must contain at least one of the following properties:

  
    Property
    Description
    Type
    Required
  
  
    elementId
    ID of the BPMN element where the incident occurred
    string
    No
  
  
    processDefinitionId
    Process definition ID of the incident
    string
    No
  

Example:

```json
{
  "elementId": "LaunchRocket"
}
```

### Job Selector

A selector to identify a job. The selector must contain at least one of the following properties:

  
    Property
    Description
    Type
    Required
  
  
    jobType
    Type of the job
    string
    No
  
  
    elementId
    ID of the BPMN element
    string
    No
  
  
    processDefinitionId
    Process definition ID of the job
    string
    No
  

Example:

```json
{
  "jobType": "analyze-moon-samples"
}
```

### Message Selector

A selector to identify a message.

  
    Property
    Description
    Type
    Required
  
  
    messageName
    Name of the message
    string
    Yes
  
  
    correlationKey
    Correlation key of the message
    string
    No
  

Example:

```json
{
  "messageName": "AstronautReady"
}
```

### Process Definition Selector

A selector to identify a process definition.

  
    Property
    Description
    Type
    Required
  
  
    processDefinitionId
    ID of the process definition
    string
    Yes
  

Example:

```json
{
  "processDefinitionId": "MoonExplorationProcess"
}
```

### Process Instance Selector

A selector to identify a process instance.

  
    Property
    Description
    Type
    Required
  
  
    processDefinitionId
    Process definition ID of the process instance
    string
    Yes
  

```json
{
  "processDefinitionId": "MoonExplorationProcess"
}
```

### User Task Selector

A selector to identify a user task. The selector must contain at least one of the following properties:

  
    Property
    Description
    Type
    Required
  
  
    elementId
    ID of the BPMN element
    string
    No
  
  
    taskName
    Name of the user task
    string
    No
  
  
    processDefinitionId
    Process definition ID of the user task
    string
    No
  

Example:

```json
{
  "elementId": "ReviewMissionPlan"
}
```

---

## Utilities

There are different utilities that can help you to write your process test.

## Manipulate the clock

The Camunda runtime uses an internal clock to execute process instances and to calculate when a BPMN timer event is due. In a test, you can use `CamundaProcessTestContext` to manipulate the clock.

When to use it:

- Trigger an active BPMN timer event
- Test scenarios that require a specific date or time, for example, a leap year

:::tip
If you trigger a BPMN timer event, you should assert that the BPMN timer event is active before manipulating the clock.
Otherwise, you may manipulate the clock too early and the BPMN timer event is not triggered.
:::

### Increase time

You can increase the time by a given duration. As a result, the clock is moved forward (i.e., in the future).

```java
@Test
void shouldTriggerTimerEvent() {
    // given: a process instance waiting at a BPMN timer event

    // when
    assertThat(processInstance).hasActiveElements("wait_2_days");

    processTestContext.increaseTime(Duration.ofDays(2));

    // then
    assertThat(processInstance).hasCompletedElements("wait_2_days");
}
```

### Set time

You can set the clock to a given date and time.

```java
@Test
void shouldCreateProcessInstanceInTheMorning() {
    // given
    processTestContext.setTime(Instant.parse("2025-10-01T08:00:00Z"));

    // when: create a process instance
    // then: verify the behavior at the given time
}
```

## Mock job workers

You can mock a job worker to simulate its behavior without invoking the actual worker. The mock handles all jobs of the given job type.

When to use it:

- Test the process in isolation from the actual job workers
- Simulate different outcomes of a job worker (success, BPMN error)
- Mock disabled job workers or Connectors

:::tip
If you start the process application in your test case, you
should [disable the job workers](../camunda-spring-boot-starter/configuration.md#disable-a-job-worker) to avoid interferences with
the mocks, for example, by setting the following configuration:

```java
@SpringBootTest(properties = {"camunda.client.worker.defaults.enabled=false"})
@CamundaSpringProcessTest
class MyProcessTest { .. }
```

:::

### Complete job

The mock completes jobs with/without variables.

```java
@Test
void shouldCompleteJob() {
    // given: mock job worker for the job type "send-email"
    // 1) Complete jobs without variables
    processTestContext.mockJobWorker("send-email").thenComplete();

    // 2) Complete jobs with variables
    final Map<String, Object> variables = Map.of(
        "emailSent", true,
        "timestamp", "2024-01-01T10:00:00Z"
    );
    processTestContext.mockJobWorker("send-email").thenComplete(variables);

    // when: create a process instance
    // then: verify that the process instance completed all tasks
}
```

### Complete with example data

The mock completes jobs with [example data](/components/modeler/data-handling.md#defining-example-data) that is defined
at the related BPMN element. If the BPMN element has no example data, the mock completes the job without variables.

```java
@Test
void shouldCompleteJobWithExampleData() {
    // given: mock job worker for the job type "fetch-weather-data"
    processTestContext.mockJobWorker("fetch-weather-data").thenCompleteWithExampleData();

    // when: create a process instance
    // then: verify that the process instance completed all tasks
}
```

:::tip

Add example data during modeling to provide context and make writing FEEL expressions easier. By using the same example
data for mocks, you keep the data in the BPMN process itself and avoid repeating them in the process tests. This can
simplify your tests and reducing the maintenance effort.

:::

### Throw BPMN error

The mock throws BPMN errors for jobs with the given error code and optional error message and variables.

```java
@Test
void shouldThrowBpmnError() {
    // given: mock job worker for the job type "validate-order"
    // 1) Throw BPMN errors with error code "INVALID_ORDER"
    processTestContext.mockJobWorker("validate-order").thenThrowBpmnError("INVALID_ORDER");

    // 2) Throw BPMN errors with error code "INVALID_ORDER" and variables
    final Map<String, Object> variables = Map.of(
        "reason", "The order exceeds the item limit."
    );
    processTestContext
        .mockJobWorker("validate-order")
        .thenThrowBpmnError("INVALID_ORDER", variables);

    // 3) Throw BPMN errors with error code, error message, and variables
    processTestContext
        .mockJobWorker("validate-order")
        .thenThrowBpmnError("INVALID_ORDER", "Order validation failed", variables);

    // when: create a process instance
    // then: verify that the process instance handled the BPMN error
}
```

### Custom handler

You can implement a custom handler to mock more complex behaviors.

```java
@Test
void shouldUseCustomHandler() {
    // given: mock job worker for the job type "calculate-discount"
    processTestContext
        .mockJobWorker("calculate-discount")
        .withHandler(
            (jobClient, job) -> {
                final Map<String, Object> variables = job.getVariablesAsMap();
                final double orderAmount = (double) variables.get("orderAmount");
                final double discount = orderAmount > 100 ? 0.1 : 0.0;

                jobClient.newCompleteCommand(job).variable("discount", discount).send().join();
            });

    // when: create a process instance
    // then: verify that the process instance has the expected variables
}
```

### Inspect mock invocations

You can inspect the invocations of a mock job worker to verify how many jobs were handled and to get the details of each
job.

```java
@Test
void shouldInspectMockInvocations() {
    // given: mock job worker for the job type "send-email"
    final JobWorkerMock mockJobWorker =
            processTestContext.mockJobWorker("send-email").thenComplete();

    // when: create a process instance that triggers the job worker

    // then: verify the number of invocations
    assertThat(mockJobWorker.getInvocations()).isEqualTo(1);
    // and: inspect the details of each invocation
    assertThat(mockJobWorker.getActivatedJobs())
        .hasSize(1)
        .flatExtracting(job -> job.getVariablesAsMap().entrySet())
        .contains(entry("receiver", "Zee"), entry("subject", "Greetings"));
}
```

## Mock child processes

You can mock a child process for a call activity to simulate its output without executing the actual child process.
The mock deploys a dummy process with the given process ID that returns the given variables.
You can optionally add a version tag. This is required when the call activity uses `bindingType="versionTag"` to resolve the child process by a specific version.

When to use it:

- Test the parent process in isolation from the actual child process
- Simulate different outcomes of a child process
- Mock a non-existing child process

```java
@Test
void shouldMockChildProcess() {
    // given: mock child process with the process ID "lunar-lander"
    // 1) Complete the child process without variables
    processTestContext.mockChildProcess().withProcessId("lunar-lander").thenComplete();

    // 2) Complete the child process with variables
    final Map<String, Object> variables = Map.of("landingStatus", "nominal");
    processTestContext.mockChildProcess().withProcessId("lunar-lander").thenComplete(variables);

    // 3) Complete the child process with a version tag
    // Use when the call activity has bindingType="versionTag"
    processTestContext.mockChildProcess()
        .withProcessId("lunar-lander")
        .withVersionTag("1.7.1")
        .thenComplete(variables);

    // when: create a process instance
    // then: verify that the process instance completed the call activity
}
```

### Child process with dynamic variables

You can mock a child process with dynamic behavior whose output variables are derived from the parent process instance.
The handler receives the parent variables and returns the child process variables.

```java
@Test
void shouldMockChildProcess() {
    // given: mock dynamic child process with the process ID "AstronautTrainingProcess"
    processTestContext
        .mockChildProcess()
        .withProcessId("AstronautTrainingProcess")
        .thenComplete(parentVariables -> {
            final String astronautName = (String) parentVariables.get("astronautName");
            final String grade = "Zee".equals(astronautName) ? "excellent" : "good";

            return Map.of(
                "trainingCompleted", true,
                "grade", grade);
        });

    // when: create a process instance
    // then: verify that the process instance completed the call activity
}
```

## Mock DMN decisions

You can mock a DMN decision for a business rule task to simulate its output without evaluating the actual DMN decision.
The mock deploys a dummy DMN decision with the given decision ID that returns the given variables.

When to use it:

- Test the process with the business rule task in isolation from the actual DMN decision
- Simulate different outcomes of a DMN decision
- Mock a non-existing DMN decision

```java
@Test
void shouldMockDmnDecision() {
    // given: mock DMN decision with the decision ID "credit-check-decision"
    final Map<String, Object> variables = Map.of(
        "approved", true,
        "riskLevel", "low",
        "creditLimit", 5000
    );
    processTestContext.mockDmnDecision("credit-check-decision", variables);

    // when: create a process instance
    // then: verify that the process instance completed the business rule task
}
```

## Conditional behavior

The `when(condition).then(action)` API on `CamundaProcessTestContext` registers background behaviors that react to process state changes without blocking the test thread. This is useful for non-deterministic flows where the execution order is unknown. You can register multiple behaviors before starting the process, and they will react independently as the process progresses. Behaviors are cleared automatically after each test.

```java
@Test
void shouldCompleteTaskAutomatically() {
    // given: define a conditional behavior
    processTestContext
        .when(() -> assertThat(processInstance).hasActiveElements("approve_order"))
        .as("approve order")
        .then(() -> processTestContext.completeUserTask("approve_order",
            Map.of("approved", true)));

    // when: create a process instance
    // then: verify that the process instance is completed
}
```

:::important
The action should resolve the process state that the condition checks for. After an action executes, the engine waits for the condition to become false again before re-evaluating. For example, if the condition asserts that a user task is active, the action should complete that user task. This advances the process flow so that the condition no longer holds. Otherwise, the same condition may not be detected again reliably.
:::

If the same conditional behavior applies to multiple tests, you can define it in a `@BeforeEach` method:

```java
@BeforeEach
void setupBehaviors() {
    processTestContext
        .when(() -> assertThat(processInstance).hasActiveElements("send_notification"))
        .as("complete send notification")
        .then(() -> processTestContext.completeJob("send-notification"));
}

@Test
void shouldCompleteOrder() {
    // given: the conditional behavior is defined in @BeforeEach

    // when: create a process instance
    // then: verify that the process instance completed the task
}
```

### Chain multiple actions

Actions are consumed in order on each condition match. The last action repeats indefinitely once all preceding actions are exhausted.

```java
@Test
void shouldHandleRepeatedTask() {
    // given: define a conditional behavior with chained actions
    processTestContext
        .when(() -> assertThat(processInstance).hasActiveElements("review_document"))
        .as("review document")
        .then(() -> processTestContext.completeUserTask("review_document",
            Map.of("approved", false, "comment", "Needs revision")))
        .then(() -> processTestContext.completeUserTask("review_document",
            Map.of("approved", true, "comment", "Looks good")));

    // when: create a process instance
    // then: verify that the process instance is completed
}
```

### Name a behavior

You can assign a descriptive name to a conditional behavior using `.as()`. The name is used in log messages and diagnostics.

```java
@Test
void shouldNameBehavior() {
    // given: define a named conditional behavior
    processTestContext
        .when(() -> assertThat(processInstance).hasActiveElements("send_notification"))
        .as("send-notification is active")
        .then(() -> processTestContext.completeJob("send-notification"));

    // when: create a process instance
    // then: verify that the process instance completed the task
}
```

## Complete jobs

You can complete an active job to simulate the behavior of a job worker without invoking the actual worker.
The command waits for the first job with the given job type and completes it. If no job exists, the command fails.

Identify the job by its job type or using a [JobSelector](#job-selector). You can pass variables or complete the job
with the [example data](/components/modeler/data-handling.md#defining-example-data) from the related BPMN element.

When to use it:

- Test the process with full control over the job completion
- Complete a repeated task with different outcomes

```java
@Test
void shouldCompleteJob() {
    // given: a process instance is waiting at a task

    // when: complete the job with type "send-notification"
    // 1) Without variables
    processTestContext.completeJob("send-notification");

    // 2) With variables
    final Map<String, Object> variables = Map.of(
        "notification-sent", true,
        "recipients", List.of("user1@example.com", "user2@example.com")
    );
    processTestContext.completeJob("send-notification", variables);

    // 3) With example data from the BPMN element
    processTestContext.completeJobWithExampleData("send-notification");

    // 4) With job selector by element ID "send_notification_task"
    processTestContext.completeJob(JobSelectors.byElementId("send_notification_task"));

    // 5) With a mapper from input variables to output variables
    processTestContext.completeJob(
        "send-notification",
        inputVariables -> {
            final String recipient = (String) inputVariables.get("recipient");
            return Map.of("notificationSent", true, "sentTo", recipient);
        });

    // then: verify that the process instance completed the task
}
```

### Ad-hoc sub-process jobs

You can simulate the behavior of
an [ad-hoc sub-process job worker](/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses.md#job-worker-implementation),
for example, an AI agent, and control the execution of the ad-hoc sub-process. The job completion allows you to
activate an element in the ad-hoc sub-process or to fulfill the completion condition.

```java
@Test
void shouldCompleteJobOfAdHocSubProcess() {
    // given: the ad-hoc sub-process is active

    // when: complete the job of the ad-hoc sub-process
    // 1) With activating an element with variables
    processTestContext.completeJobOfAdHocSubProcess(
        JobSelectors.byElementId("ad-hoc-sub-process"),
        result -> result.activateElement("search-knowledge-base").variable("query", "launch rockets"));

    // 2) With job variables (for the ad-hoc sub-process)
    processTestContext.completeJobOfAdHocSubProcess(
        JobSelectors.byElementId("ad-hoc-sub-process"),
        Map.of("agent", agentContext),
        result -> result.activateElement("search-knowledge-base").variable("query", "launch rockets"));

    // 3) With fulfilling the completion condition
    processTestContext.completeJobOfAdHocSubProcess(
        JobSelectors.byElementId("ad-hoc-sub-process"),
        result -> result.completionConditionFulfilled(true));

    // then: verify that the ad-hoc sub-process completed the task
}
```

### User task listener jobs

You can simulate the behavior of
a [user task listener job worker](/components/concepts/user-task-listeners.md#implement-a-user-task-listener). The job
completion allows to correct the user task data or to deny the user task lifecycle transition.

```java
@Test
void shouldCompleteJobOfUserTaskListener() {
    // given: the process instance is waiting at a user task

    // when: complete the job of the user task listener
    // 1) With correcting user task data
    processTestContext.completeJobOfUserTaskListener(
        JobSelectors.byElementId("approve_request_task"),
        result -> result.correctAssignee("me").correctPriority(100));

    // 2) With denying the user task lifecycle transition
    processTestContext.completeJobOfUserTaskListener(
        JobSelectors.byElementId("approve_request_task"),
        result -> result.deny(true).deniedReason("Policy violation"));

    // then: verify that the user task is completed
}
```

## Throw BPMN errors from jobs

You can throw a BPMN error from an active job to simulate the behavior of a job worker without invoking the actual worker.
The command waits for the first job with the given job type and throws the BPMN error. If no job exists, the command fails.

Identify the job by its job type or using a [JobSelector](#job-selector). Optionally, you can pass variables and an
error message with the BPMN error.

When to use it:

- Test the error paths in the process
- Simulate different behaviors of a repeated task (success, BPMN error)

```java
@Test
void shouldThrowBpmnErrorFromJob() {
    // given: a process instance is waiting at a task

    // when: throw a BPMN error for the job with type "validate-data"
    // 1) With error code "VALIDATION_FAILED" and no variables
    processTestContext.throwBpmnErrorFromJob("validate-data", "VALIDATION_FAILED");

    // 2) With error code "VALIDATION_FAILED" and variables
    final Map<String, Object> variables = Map.of(
        "error-message", "Invalid customer data",
        "error-code", "ERR_VALIDATION_001"
    );
    processTestContext.throwBpmnErrorFromJob("validate-data", "VALIDATION_FAILED", variables);

    // 3) With error code, error message, and variables
    processTestContext.throwBpmnErrorFromJob(
        "validate-data",
        "VALIDATION_FAILED",
        "Data validation failed due to missing required fields",
        variables);

    // 4) With job selector by element ID "validate_data_task"
    processTestContext.throwBpmnErrorFromJob(
        JobSelectors.byElementId("validate_data_task"),
        "VALIDATION_FAILED");

    // then: verify that the process instance handled the error
}
```

## Complete user tasks

You can complete a user task to simulate the user behavior in Tasklist. The command waits for the first user task and
completes it. If no user task exists, the command fails.

Identify the user task by its BPMN element ID or using a [UserTaskSelector](#user-task-selector). You can pass variables
or complete the user task with the [example data](/components/modeler/data-handling.md#defining-example-data) from the
related BPMN element.

When to use it:

- Test a process with user tasks

```java
@Test
void shouldCompleteUserTask() {
    // given: a process instance is waiting at a user task

    // when: complete the user task
    // 1) With element ID "task_approveRequest"
    final Map<String, Object> variables = Map.of(
        "approved", true,
        "comment", "Request approved by manager",
        "approvedAmount", 5000.00
    );
    processTestContext.completeUserTask("task_approveRequest", variables);

    // 2) With selector by task name "Approve Request"
    processTestContext.completeUserTask(
        UserTaskSelectors.byTaskName("Approve Request"),
        variables);

    // 3) With example data from the BPMN element
    processTestContext.completeUserTaskWithExampleData(
        UserTaskSelectors.byElementId("task_approveRequest"));

    // 4) With a mapper from input variables to output variables
    processTestContext.completeUserTask(
        "task_approveRequest",
        inputVariables -> Map.of("approved", inputVariables.containsKey("preApproved")));

    // then: verify that the process instance is completed
}
```

## Update variables

You can update or create variables of a process instance or in the local scope of a BPMN element, for example, to trigger a BPMN conditional event.

To target local variables of a specific BPMN element, use an [ElementSelector](#element-selector).

### Update process instance variables

Use `updateVariables()` to update or create variables on a process instance.

```java
@Test
void shouldTriggerConditionalEvent() {
    // given: a process instance is waiting at the conditional event

    // when: update the variables to trigger the conditional event
    final Map<String, Object> variables = Map.of(
        "priority", 80,
        "riskLevel", "high"
    );
    processTestContext.updateVariables(
        ProcessInstanceSelectors.byKey(processInstanceKey),
        variables);

    // then: verify that the conditional event is completed
}
```

### Update local variables

Use `updateLocalVariables()` to propagate variables starting from a given element's scope. The variables are updated on the element or the nearest parent scope where they already exist. If a variable doesn't exist in any scope, it's created on the process instance scope.

```java
processTestContext.updateLocalVariables(
    ProcessInstanceSelectors.byKey(processInstanceKey),
    ElementSelectors.byId("sub-process"),
    variables);
```

### Create local variables

Use `createLocalVariables()` to create variables in the local scope of a given element. The variables are created only in the element's scope and are not propagated to parent scopes.

```java
processTestContext.createLocalVariables(
    ProcessInstanceSelectors.byKey(processInstanceKey),
    ElementSelectors.byId("sub-process"),
    variables);
```

## Resolve incidents

You can resolve an active incident. Use the [IncidentSelector](#incident-selector) to identify the incident based on
different criteria, for example, by the BPMN element ID where the incident occurred.

If the incident is caused by a job, the command increases the job retries by one before resolving the incident. If the
incident is caused by a missing variable, you should [update the variables](#update-variables) before resolving the
incident.

```java
@Test
void shouldResolveIncident() {
    // given: a process instance has an active incident

    // when: resolve the incident at the element with ID "validate-data"
    processTestContext.resolveIncident(IncidentSelectors.byElementId("validate-data"));

    // then: verify that the element is completed
}
```

## Selectors

CPT provides selectors to identify entities such as jobs, user tasks, process instances, and more based on different
criteria. You can use selectors in both utilities and assertions to target the entities you want to interact
with or verify. The selector targets the first matching entity.

CPT provides predefined selectors for common use cases. You can combine multiple selectors using `.and()` to create more
specific selection criteria.

```java
// Combine job selectors by job type and process instance key
processTestContext.completeJob(
    JobSelectors.byJobType("send-notification")
        .and(JobSelectors.byProcessInstanceKey(processInstanceKey))
);
```

Alternatively, you can implement your own custom selector when you need specialized selection logic.

```java
// Implement a custom selector to select a user task by its assignee
private static UserTaskSelector byAssignee(String assignee) {
    return new UserTaskSelectorByAssignee(assignee);
}

private static final class UserTaskSelectorByAssignee implements UserTaskSelector {

    private final String assignee;

    public UserTaskSelectorByAssignee(String assignee) {
        this.assignee = assignee;
    }

    @Override
    public boolean test(final UserTask userTask) {
        return assignee.equals(userTask.getAssignee());
    }

    @Override
    public String describe() {
        return "assignee: " + assignee;
    }

    @Override
    public void applyFilter(final UserTaskFilter filter) {
        filter.assignee(assignee);
    }
}
```

### Decision selector

You can use a decision selector to identify a DMN decision evaluation based on different criteria, such as decision ID
or decision name.

Predefined decision selectors are available in the `io.camunda.process.test.api.assertions.DecisionSelectors` class.

```java
// Assert the evaluation of a DMN decision with the ID "credit-score"
assertThatDecision(DecisionSelectors.byId("credit-score")).hasOutput(750);
```

### Element selector

You can use an element selector to identify a BPMN element based on different criteria, such as element ID or element
name.

Predefined element selectors are available in the `io.camunda.process.test.api.assertions.ElementSelectors` class.

```java
// Assert the BPMN element with the ID "approve_request_task"
assertThat(processInstance).hasActiveElements(ElementSelectors.byId("approve_request_task"));

// Assert the BPMN element with the name "Approve Request"
assertThat(processInstance).hasActiveElements(ElementSelectors.byName("Approve Request"));
```

### Incident selector

You can use an incident selector to identify an incident based on different criteria, such as BPMN element ID or process
instance key.

Predefined incident selectors are available in the `io.camunda.process.test.api.assertions.IncidentSelectors` class.

```java
// Resolve an incident by the BPMN element ID "approve_request_task"
processTestContext.resolveIncident(IncidentSelectors.byElementId("approve_request_task"));
```

### Job selector

You can use a job selector to identify a job based on different criteria, such as job type, BPMN element ID, or process
instance key.

Predefined job selectors are available in the `io.camunda.process.test.api.assertions.JobSelectors` class.

```java
// Complete a job by its BPMN element ID
processTestContext.completeJob(JobSelectors.byElementId("send_notification_task"));

// Throw a BPMN error from a job by its job type
processTestContext.throwBpmnErrorFromJob(JobSelectors.byJobType("validate-data"), "VALIDATION_FAILED");
```

### Process instance selector

You can use a process instance selector to identify a process instance based on different criteria, such as process
instance key or BPMN process ID.

Predefined process instance selectors are available in the
`io.camunda.process.test.api.assertions.ProcessInstanceSelectors` class.

```java
// Assert a process instance by its process instance key
assertThatProcessInstance(ProcessInstanceSelectors.byKey(processInstanceKey)).isCreated();
```

### User task selector

You can use a user task selector to identify a user task based on different criteria, such as element ID, task name, or
process instance key.

Predefined user task selectors are available in the `io.camunda.process.test.api.assertions.UserTaskSelectors` class.

```java
// Complete a user task by its task name
processTestContext.completeUserTask(UserTaskSelectors.byTaskName("Approve Request"), variables);
```

### Variable selector

You can use a variable selector to identify a variable based on different criteria, such as variable name or variable value.

Predefined variable selectors are available in the `io.camunda.process.test.api.assertions.VariableSelectors` class.

```java
// Assert a variable by its name
assertThatProcessInstance(processInstance).hasVariable(VariableSelectors.byName("approved"), true);
```

---

## Migrate from Zeebe Process Test

:::warning
Zeebe Process Test was removed in Camunda 8.10. Use [Camunda Process Test](/apis-tools/testing/getting-started.md) instead.
:::

For the release-level summary of this removal, see the [8.10 release announcement](/reference/announcements-release-notes/8100/8100-announcements.md#removal-of-legacy-apis-tasklist-v1-dependent-features-and-zeebe-process-test).

Use [Camunda Process Test](/apis-tools/testing/getting-started.md) for current process testing, and review the [migration guide](/apis-tools/migration-manuals/migrate-to-camunda-process-test.md) to replace old ZPT dependencies, annotations, and assertions.

## Examples

For example tests, refer to [GitHub](https://github.com/camunda-cloud/zeebe-process-test).

---

## Contributing


Thanks for your interest in contributing to the Camunda 8 Orchestration Cluster TypeScript SDK.

## Development Setup

Requirements:

- Node >= 20 (>=18 works with global File polyfill; we target >=20 in CI)
- npm 9+ recommended

Install deps:

```
npm ci
```

Run full build + tests:

```
npm run build
```

Integration tests spin up containers (Zeebe, Operate, etc.). Use:

```
npm run test:integration
```

## Deterministic Build & Timestamp Policy

The repository enforces a drift guard: regenerated artifacts must be byte‑for‑byte identical across builds unless a real source/input change occurred. To make this reliable we **removed all embedded generation timestamps** (e.g. `generatedAt`, banner date strings) from committed artifacts.

Current policy:

- Do **not** reintroduce wall‑clock timestamps, date banners, or build times into any committed generated file (TypeScript, JSON, Markdown) unless they are logically required for runtime behavior.
- If you need provenance, prefer stable content hashes (already present: `specHash`, branding key hashes) or add a new hash field rather than a timestamp.
- The publish workflow sets `CAMUNDA_SDK_SKIP_FETCH_SPEC=1` to avoid pulling a moving upstream spec mid‑release.

Rationale:

1. Eliminates false positive drift failures due solely to time.
2. Simplifies local verification: two consecutive `npm run build` runs must yield zero git diffs.
3. Improves review signal: any diff now reflects a substantive schema/template/script change.

Contributor guidance:

| Scenario                                 | What to do                                                                       |
| ---------------------------------------- | -------------------------------------------------------------------------------- |
| Need to record when something was built  | Use runtime logging or external release notes, not a committed artifact field.   |
| Want to tag provenance in generated code | Add or extend a stable hash (e.g. combine spec hash + template hash).            |
| Adding a new generation script           | Ensure output ordering is deterministic (sort keys, arrays) and omit timestamps. |

If you inadvertently add a timestamp, the second local build will show a diff—remove the field instead of guarding it behind the deterministic flag.

## Commit Message Guidelines

We use Conventional Commits enforced by commitlint.

Format:

```
<type>(optional scope): <subject>

<body>

BREAKING CHANGE: <explanation>
```

Allowed `type` values (common set):

- feat
- fix
- chore
- docs
- style
- refactor
- test
- ci
- build
- perf

Rules:

- Subject length: 5–100 characters (commitlint enforces `subject-min-length` & `subject-max-length`).
- Use imperative mood ("add support", not "added support").
- Lowercase subject (except proper nouns). No PascalCase subjects (rule enforced).
- Keep subject concise; body can include details, rationale, links.
- Prefix breaking changes with `BREAKING CHANGE:` either in body or footer.

Examples:

```
feat(worker): add job worker concurrency gating
fix(retry): prevent double backoff application
chore(ci): stabilize deterministic publish (skip spec fetch)
docs: document deterministic build flag
refactor(auth): simplify token refresh jitter logic
```

### Breaking change commits

Breaking change markers (`BREAKING CHANGE:` in the body/footer) trigger a major version bump and a CHANGELOG entry. **Never** use these markers for intra-branch corrections on a feature branch — they pollute the release history and cause unnecessary major version increments.

PR CI includes a breaking change guard that fails when it detects these markers. If the breaking change is intentional, add the `breaking-change-approved` label to the PR. Otherwise, rewrite the commit history to remove the markers before merging.

## Branching & Releases

Releases are performed by GitHub Actions using semantic-release:

- `main` publishes alpha prereleases.
- `stable/<major>.<minor>` publishes stable patch releases for that minor line.

Use feature branches and PRs; merge commits should follow conventional syntax to produce changelog entries.

To understand what will be released, prefer inspecting the CI logs/artifacts for the release workflow (it runs semantic-release in dry-run mode as part of the pipeline).

## Testing Strategy

- Unit tests: `npm test` (fast, deterministic). Avoid relying on wall-clock timers.
- Integration tests: `npm run test:integration` (requires container stack up; CI spins it automatically in generate job).
- Add test scaffolds for new REST operations via existing generation pipeline; run `npm run scaffold:methods` if needed.

## Validation & Schemas

If adding new runtime validation paths or job worker actions, ensure they integrate cleanly with:

- `CAMUNDA_SDK_VALIDATION` grammar (req/res strict/warn/none)
- Job worker unique symbol receipts (`JobActionReceipt`).

## Performance Considerations

Large generation outputs are committed; avoid unnecessary formatting churn. When modifying templates:

- Keep imports stable.
- Reuse deterministic timestamp injection.
- Avoid introducing non-deterministic ordering (Object.keys without sort, randomization, etc.).

## Adding Dependencies

Prefer lightweight, maintained libraries. Changes affecting bundle size must include justification in PR description.

## Security

Do not log secrets. Redaction logic already masks sensitive env values in hydrated config logs. If adding new secret env vars, update redaction list.

## Code Style

Prettier + ESLint run in build pipeline. Run:

```
npm run format && npm run lint
```

before pushing sizable changes.

## Questions

Open a GitHub issue or start a PR draft with your questions in the description.

Happy hacking!

---

## Function: classifyDomainError()


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
function classifyDomainError(err): DomainErrorTag;
```

## Parameters

### err

[`DomainError`](../type-aliases/DomainError.md)

## Returns

[`DomainErrorTag`](../type-aliases/DomainErrorTag.md)

---

## Function: eventuallyTE()


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
function eventuallyTE<E, A>(thunk, predicate, opts): TaskEither<E, A>;
```

## Type Parameters

### E

`E`

### A

`A`

## Parameters

### thunk

() => `Promise`\<`A`\>

### predicate

(`a`) => `boolean` \| `Promise`\<`boolean`\>

### opts

#### intervalMs?

`number`

#### waitUpToMs

`number`

## Returns

[`TaskEither`](../type-aliases/TaskEither.md)\<`E`, `A`\>

---

## Function: foldDomainError()


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
function foldDomainError(handlers): (err) => A;
```

## Type Parameters

### A

`A`

## Parameters

### handlers

#### generic

(`e`) => `A`

#### http

(`e`) => `A`

#### timeout

(`e`) => `A`

#### validation

(`e`) => `A`

## Returns

(`err`) => `A`

---

## Function: retryTE()


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
function retryTE<E, A>(task, opts): TaskEither<E, A>;
```

## Type Parameters

### E

`E`

### A

`A`

## Parameters

### task

[`TaskEither`](../type-aliases/TaskEither.md)\<`E`, `A`\>

### opts

#### baseDelayMs?

`number`

#### max

`number`

#### shouldRetry?

(`e`, `attempt`) => `boolean` \| `Promise`\<`boolean`\>

## Returns

[`TaskEither`](../type-aliases/TaskEither.md)\<`E`, `A`\>

---

## Function: withTimeoutTE()


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
function withTimeoutTE<E, A>(task, ms, onTimeout?): TaskEither<E, A>;
```

## Type Parameters

### E

`E`

### A

`A`

## Parameters

### task

[`TaskEither`](../type-aliases/TaskEither.md)\<`E`, `A`\>

### ms

`number`

### onTimeout?

() => `E`

## Returns

[`TaskEither`](../type-aliases/TaskEither.md)\<`E`, `A`\>

---

## fp


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

## Type Aliases

- [DomainError](type-aliases/DomainError.md)
- [DomainErrorTag](type-aliases/DomainErrorTag.md)
- [FnKeys](type-aliases/FnKeys.md)
- [Fpify](type-aliases/Fpify.md)
- [HttpError](type-aliases/HttpError.md)
- [Left](type-aliases/Left.md)
- [Right](type-aliases/Right.md)
- [TaskEither](type-aliases/TaskEither.md)

## Functions

- [classifyDomainError](functions/classifyDomainError.md)
- [eventuallyTE](functions/eventuallyTE.md)
- [foldDomainError](functions/foldDomainError.md)
- [retryTE](functions/retryTE.md)
- [withTimeoutTE](functions/withTimeoutTE.md)

## References

### CamundaFpClient

Re-exports [CamundaFpClient](../index/type-aliases/CamundaFpClient.md)

---

### createCamundaFpClient

Re-exports [createCamundaFpClient](../index/functions/createCamundaFpClient.md)

---

### Either

Re-exports [Either](../index/type-aliases/Either.md)

---

### isLeft

Re-exports [isLeft](../index/functions/isLeft.md)

---

### isRight

Re-exports [isRight](../index/functions/isRight.md)

---

## Type Alias: DomainError


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type DomainError =
  CamundaValidationError | EventualConsistencyTimeoutError | HttpError | Error;
```

---

## Type Alias: DomainErrorTag


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type DomainErrorTag = "validation" | "timeout" | "http" | "generic";
```

---

## Type Alias: FnKeys<C>

# Type Alias: FnKeys\<C\>

:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type FnKeys<C> = {
  [K in keyof C]: C[K] extends (a: any) => any ? K : never;
}[keyof C];
```

## Type Parameters

### C

`C`

---

## Type Alias: Fpify<C>

# Type Alias: Fpify\<C\>

:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type Fpify<C> = {
  [K in FnKeys<C>]: C[K] extends (a: infer A) => infer R
    ? (a: A) => TaskEither<DomainError, Awaited<R>>
    : never;
} & object & { [K in Exclude<keyof C, FnKeys<C>>]: C[K] };
```

## Type Declaration

### inner

```ts
inner: C;
```

## Type Parameters

### C

`C`

---

## Type Alias: HttpError


:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type HttpError = object & Record<string, any>;
```

## Type Declaration

### body?

```ts
optional body?: any;
```

### message?

```ts
optional message?: string;
```

### name?

```ts
optional name?: string;
```

### status?

```ts
optional status?: number;
```

---

## Type Alias: Left<E>

# Type Alias: Left\<E\>

:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type Left<E> = object;
```

## Type Parameters

### E

`E`

## Properties

### \_tag

```ts
_tag: "Left";
```

---

### left

```ts
left: E;
```

---

## Type Alias: Right<A>

# Type Alias: Right\

:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type Right = object;
```

## Type Parameters

### A

`A`

## Properties

### \_tag

```ts
_tag: "Right";
```

---

### right

```ts
right: A;
```

---

## Type Alias: TaskEither<E, A>

# Type Alias: TaskEither\<E, A\>

:::caution Technical Preview
The Functional Programming API is a **technical preview**. Its surface may change in future releases without following semver.
:::

```ts
type TaskEither<E, A> = () => Promise<Either<E, A>>;
```

## Type Parameters

### E

`E`

### A

`A`

## Returns

`Promise`\<[`Either`](../../index/type-aliases/Either.md)\<`E`, `A`\>\>

---

## Class: CamundaClient


## Constructors

### Constructor

```ts
new CamundaClient(opts?): CamundaClient;
```

#### Parameters

##### opts?

[`CamundaOptions`](../interfaces/CamundaOptions.md) = `{}`

#### Returns

`CamundaClient`

## Accessors

### config

#### Get Signature

```ts
get config(): Readonly<CamundaConfig>;
```

##### Returns

`Readonly`\<[`CamundaConfig`](../interfaces/CamundaConfig.md)\>

## Methods

### \_getSupportLogger()

```ts
_getSupportLogger(): SupportLogger;
```

Internal accessor for support logger (no public API commitment yet).

#### Returns

[`SupportLogger`](../interfaces/SupportLogger.md)

---

### \_invokeWithRetry()

```ts
_invokeWithRetry<T>(op, opts): Promise<T>;
```

Internal invocation helper to apply global backpressure gating + retry + normalization

#### Type Parameters

##### T

`T`

#### Parameters

##### op

() => `Promise`\<`T`\>

##### opts

###### classify?

(`e`) => `object`

###### exempt?

`boolean`

###### opId

`string`

###### retryOverride?

\| `false`
\| `Partial`\<[`HttpRetryPolicy`](../interfaces/HttpRetryPolicy.md)\>

#### Returns

`Promise`\<`T`\>

---

### activateAdHocSubProcessActivities()

```ts
activateAdHocSubProcessActivities(input, options?): CancelablePromise<void>;
```

Activate activities within an ad-hoc sub-process

Activates selected activities within an ad-hoc sub-process identified by element ID.
The provided element IDs must exist within the ad-hoc sub-process instance identified by the
provided adHocSubProcessInstanceKey.

-

#### Parameters

##### input

[`activateAdHocSubProcessActivitiesInput`](../type-aliases/activateAdHocSubProcessActivitiesInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Activate ad-hoc sub-process activities**

```ts
async function activateAdHocSubProcessActivitiesExample(
  adHocSubProcessInstanceKey: ElementInstanceKey,
  elementId: ElementId
) {
  const camunda = createCamundaClient();

  await camunda.activateAdHocSubProcessActivities({
    adHocSubProcessInstanceKey,
    elements: [{ elementId }],
  });
}
```

#### Operation Id

activateAdHocSubProcessActivities

#### Tags

Ad-hoc sub-process

---

### activateJobs()

```ts
activateJobs(input, options?): CancelablePromise<{
  jobs: EnrichedActivatedJob[];
}>;
```

Activate jobs

Iterate through all known partitions and activate jobs up to the requested maximum.

-

#### Parameters

##### input

[`JobActivationRequest`](../type-aliases/JobActivationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`jobs`: [`EnrichedActivatedJob`](../interfaces/EnrichedActivatedJob.md)[];
\}\>

#### Example

**Activate and process jobs**

```ts
async function activateJobsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.activateJobs({
    type: "payment-processing",
    timeout: 30000,
    maxJobsToActivate: 5,
  });

  for (const job of result.jobs) {
    console.log(`Job ${job.jobKey}: ${job.type}`);

    // Each enriched job has helper methods
    await job.complete({ paymentId: "PAY-123" });
  }
}
```

#### Operation Id

activateJobs

#### Tags

Job

---

### assignClientToGroup()

```ts
assignClientToGroup(input, options?): CancelablePromise<void>;
```

Assign a client to a group

Assigns a client to a group, making it a member of the group.
Members of the group inherit the group authorizations, roles, and tenant assignments.

-

#### Parameters

##### input

[`assignClientToGroupInput`](../type-aliases/assignClientToGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a client to a group**

```ts
async function assignClientToGroupExample(
  groupId: GroupId,
  clientId: ClientId
) {
  const camunda = createCamundaClient();

  await camunda.assignClientToGroup({
    groupId,
    clientId,
  });
}
```

#### Operation Id

assignClientToGroup

#### Tags

Group

---

### assignClientToTenant()

```ts
assignClientToTenant(input, options?): CancelablePromise<void>;
```

Assign a client to a tenant

Assign the client to the specified tenant.
The client can then access tenant data and perform authorized actions.

-

#### Parameters

##### input

[`assignClientToTenantInput`](../type-aliases/assignClientToTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a client to a tenant**

```ts
async function assignClientToTenantExample(
  tenantId: TenantId,
  clientId: ClientId
) {
  const camunda = createCamundaClient();

  await camunda.assignClientToTenant({
    tenantId,
    clientId,
  });
}
```

#### Operation Id

assignClientToTenant

#### Tags

Tenant

---

### assignGroupToTenant()

```ts
assignGroupToTenant(input, options?): CancelablePromise<void>;
```

Assign a group to a tenant

Assigns a group to a specified tenant.
Group members (users, clients) can then access tenant data and perform authorized actions.

-

#### Parameters

##### input

[`assignGroupToTenantInput`](../type-aliases/assignGroupToTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a group to a tenant**

```ts
async function assignGroupToTenantExample(
  tenantId: TenantId,
  groupId: GroupId
) {
  const camunda = createCamundaClient();

  await camunda.assignGroupToTenant({
    tenantId,
    groupId,
  });
}
```

#### Operation Id

assignGroupToTenant

#### Tags

Tenant

---

### assignMappingRuleToGroup()

```ts
assignMappingRuleToGroup(input, options?): CancelablePromise<void>;
```

Assign a mapping rule to a group

Assigns a mapping rule to a group. *

#### Parameters

##### input

[`assignMappingRuleToGroupInput`](../type-aliases/assignMappingRuleToGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a mapping rule to a group**

```ts
async function assignMappingRuleToGroupExample(
  groupId: GroupId,
  mappingRuleId: MappingRuleId
) {
  const camunda = createCamundaClient();

  await camunda.assignMappingRuleToGroup({
    groupId,
    mappingRuleId,
  });
}
```

#### Operation Id

assignMappingRuleToGroup

#### Tags

Group

---

### assignMappingRuleToTenant()

```ts
assignMappingRuleToTenant(input, options?): CancelablePromise<void>;
```

Assign a mapping rule to a tenant

Assign a single mapping rule to a specified tenant. *

#### Parameters

##### input

[`assignMappingRuleToTenantInput`](../type-aliases/assignMappingRuleToTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a mapping rule to a tenant**

```ts
async function assignMappingRuleToTenantExample(
  tenantId: TenantId,
  mappingRuleId: MappingRuleId
) {
  const camunda = createCamundaClient();

  await camunda.assignMappingRuleToTenant({
    tenantId,
    mappingRuleId,
  });
}
```

#### Operation Id

assignMappingRuleToTenant

#### Tags

Tenant

---

### assignRoleToClient()

```ts
assignRoleToClient(input, options?): CancelablePromise<void>;
```

Assign a role to a client

Assigns the specified role to the client. The client will inherit the authorizations associated with this role. *

#### Parameters

##### input

[`assignRoleToClientInput`](../type-aliases/assignRoleToClientInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a role to a client**

```ts
async function assignRoleToClientExample(roleId: RoleId, clientId: ClientId) {
  const camunda = createCamundaClient();

  await camunda.assignRoleToClient({
    roleId,
    clientId,
  });
}
```

#### Operation Id

assignRoleToClient

#### Tags

Role

---

### assignRoleToGroup()

```ts
assignRoleToGroup(input, options?): CancelablePromise<void>;
```

Assign a role to a group

Assigns the specified role to the group. Every member of the group (user or client) will inherit the authorizations associated with this role. *

#### Parameters

##### input

[`assignRoleToGroupInput`](../type-aliases/assignRoleToGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a role to a group**

```ts
async function assignRoleToGroupExample(roleId: RoleId, groupId: GroupId) {
  const camunda = createCamundaClient();

  await camunda.assignRoleToGroup({
    roleId,
    groupId,
  });
}
```

#### Operation Id

assignRoleToGroup

#### Tags

Role

---

### assignRoleToMappingRule()

```ts
assignRoleToMappingRule(input, options?): CancelablePromise<void>;
```

Assign a role to a mapping rule

Assigns a role to a mapping rule. *

#### Parameters

##### input

[`assignRoleToMappingRuleInput`](../type-aliases/assignRoleToMappingRuleInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a role to a mapping rule**

```ts
async function assignRoleToMappingRuleExample(
  roleId: RoleId,
  mappingRuleId: MappingRuleId
) {
  const camunda = createCamundaClient();

  await camunda.assignRoleToMappingRule({
    roleId,
    mappingRuleId,
  });
}
```

#### Operation Id

assignRoleToMappingRule

#### Tags

Role

---

### assignRoleToTenant()

```ts
assignRoleToTenant(input, options?): CancelablePromise<void>;
```

Assign a role to a tenant

Assigns a role to a specified tenant.
Users, Clients or Groups, that have the role assigned, will get access to the tenant's data and can perform actions according to their authorizations.

-

#### Parameters

##### input

[`assignRoleToTenantInput`](../type-aliases/assignRoleToTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a role to a tenant**

```ts
async function assignRoleToTenantExample(tenantId: TenantId, roleId: RoleId) {
  const camunda = createCamundaClient();

  await camunda.assignRoleToTenant({
    tenantId,
    roleId,
  });
}
```

#### Operation Id

assignRoleToTenant

#### Tags

Tenant

---

### assignRoleToUser()

```ts
assignRoleToUser(input, options?): CancelablePromise<void>;
```

Assign a role to a user

Assigns the specified role to the user. The user will inherit the authorizations associated with this role. *

#### Parameters

##### input

[`assignRoleToUserInput`](../type-aliases/assignRoleToUserInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a role to a user**

```ts
async function assignRoleToUserExample(roleId: RoleId, username: Username) {
  const camunda = createCamundaClient();

  await camunda.assignRoleToUser({
    roleId,
    username,
  });
}
```

#### Operation Id

assignRoleToUser

#### Tags

Role

---

### assignUserTask()

```ts
assignUserTask(input, options?): CancelablePromise<void>;
```

Assign user task

Assigns a user task with the given key to the given assignee. Assignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

-

#### Parameters

##### input

[`assignUserTaskInput`](../type-aliases/assignUserTaskInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a user task**

```ts
async function assignUserTaskExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  await camunda.assignUserTask({
    userTaskKey,
    assignee: "alice",
    allowOverride: true,
  });
}
```

#### Operation Id

assignUserTask

#### Tags

User task

---

### assignUserToGroup()

```ts
assignUserToGroup(input, options?): CancelablePromise<void>;
```

Assign a user to a group

Assigns a user to a group, making the user a member of the group.
Group members inherit the group authorizations, roles, and tenant assignments.

-

#### Parameters

##### input

[`assignUserToGroupInput`](../type-aliases/assignUserToGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a user to a group**

```ts
async function assignUserToGroupExample(groupId: GroupId, username: Username) {
  const camunda = createCamundaClient();

  await camunda.assignUserToGroup({
    groupId,
    username,
  });
}
```

#### Operation Id

assignUserToGroup

#### Tags

Group

---

### assignUserToTenant()

```ts
assignUserToTenant(input, options?): CancelablePromise<void>;
```

Assign a user to a tenant

Assign a single user to a specified tenant. The user can then access tenant data and perform authorized actions. *

#### Parameters

##### input

[`assignUserToTenantInput`](../type-aliases/assignUserToTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Assign a user to a tenant**

```ts
async function assignUserToTenantExample(
  tenantId: TenantId,
  username: Username
) {
  const camunda = createCamundaClient();

  await camunda.assignUserToTenant({
    tenantId,
    username,
  });
}
```

#### Operation Id

assignUserToTenant

#### Tags

Tenant

---

### broadcastSignal()

```ts
broadcastSignal(input, options?): CancelablePromise<SignalBroadcastResult>;
```

Broadcast signal

Broadcasts a signal. *

#### Parameters

##### input

[`SignalBroadcastRequest`](../type-aliases/SignalBroadcastRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`SignalBroadcastResult`](../type-aliases/SignalBroadcastResult.md)\>

#### Example

**Broadcast a signal**

```ts
async function broadcastSignalExample() {
  const camunda = createCamundaClient();

  const result = await camunda.broadcastSignal({
    signalName: "system-shutdown",
    variables: {
      reason: "Scheduled maintenance",
    },
  });

  console.log(`Signal broadcast key: ${result.signalKey}`);
}
```

#### Operation Id

broadcastSignal

#### Tags

Signal

---

### cancelBatchOperation()

```ts
cancelBatchOperation(input, options?): CancelablePromise<void>;
```

Cancel Batch operation

Cancels a running batch operation.
This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

###### batchOperationKey

[`BatchOperationKey`](../type-aliases/BatchOperationKey.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Cancel a batch operation**

```ts
async function cancelBatchOperationExample(
  batchOperationKey: BatchOperationKey
) {
  const camunda = createCamundaClient();

  await camunda.cancelBatchOperation({ batchOperationKey });
}
```

#### Operation Id

cancelBatchOperation

#### Tags

Batch operation

---

### cancelProcessInstance()

```ts
cancelProcessInstance(input, options?): CancelablePromise<void>;
```

Cancel process instance

Cancels a running process instance. As a cancellation includes more than just the removal of the process instance resource, the cancellation resource must be posted. Cancellation can wait on listener-related processing; when that processing does not complete in time, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

-

#### Parameters

##### input

`object` & `object`

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Cancel a process instance**

```ts
async function cancelProcessInstanceExample(
  processDefinitionId: ProcessDefinitionId
) {
  const camunda = createCamundaClient();

  // Create a process instance and get its key from the response
  const created = await camunda.createProcessInstance({
    processDefinitionId,
  });

  // Cancel the process instance using the key from the creation response
  await camunda.cancelProcessInstance({
    processInstanceKey: created.processInstanceKey,
  });
}
```

#### Operation Id

cancelProcessInstance

#### Tags

Process instance

---

### cancelProcessInstancesBatchOperation()

```ts
cancelProcessInstancesBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Cancel process instances (batch)

Cancels multiple running process instances.
Since only ACTIVE root instances can be cancelled, any given filters for state and
parentProcessInstanceKey are ignored and overridden during this batch operation.
This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`ProcessInstanceCancellationBatchOperationRequest`](../type-aliases/ProcessInstanceCancellationBatchOperationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Cancel process instances in batch**

```ts
async function cancelProcessInstancesBatchOperationExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.cancelProcessInstancesBatchOperation({
    filter: {
      processDefinitionKey,
    },
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

cancelProcessInstancesBatchOperation

#### Tags

Process instance

---

### clearAuthCache()

```ts
clearAuthCache(opts?): void;
```

#### Parameters

##### opts?

###### disk?

`boolean`

###### memory?

`boolean`

#### Returns

`void`

---

### completeJob()

```ts
completeJob(input, options?): CancelablePromise<void>;
```

Complete job

Complete a job with the given payload, which allows completing the associated service task.

-

#### Parameters

##### input

[`completeJobInput`](../type-aliases/completeJobInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Complete a job**

```ts
async function completeJobExample(jobKey: JobKey) {
  const camunda = createCamundaClient();

  await camunda.completeJob({
    jobKey,
    variables: {
      paymentId: "PAY-123",
      status: "completed",
    },
  });
}
```

#### Operation Id

completeJob

#### Tags

Job

---

### completeUserTask()

```ts
completeUserTask(input, options?): CancelablePromise<void>;
```

Complete user task

Completes a user task with the given key. Completion waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

-

#### Parameters

##### input

[`completeUserTaskInput`](../type-aliases/completeUserTaskInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Complete a user task**

```ts
async function completeUserTaskExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  await camunda.completeUserTask({
    userTaskKey,
    variables: {
      approved: true,
      comment: "Looks good",
    },
  });
}
```

#### Operation Id

completeUserTask

#### Tags

User task

---

### configure()

```ts
configure(next): void;
```

#### Parameters

##### next

[`CamundaOptions`](../interfaces/CamundaOptions.md)

#### Returns

`void`

---

### correlateMessage()

```ts
correlateMessage(input, options?): CancelablePromise<MessageCorrelationResult>;
```

Correlate message

Publishes a message and correlates it to a subscription.
If correlation is successful it will return the first process instance key the message correlated with.
The message is not buffered.
Use the publish message endpoint to send messages that can be buffered.

-

#### Parameters

##### input

[`MessageCorrelationRequest`](../type-aliases/MessageCorrelationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MessageCorrelationResult`](../type-aliases/MessageCorrelationResult.md)\>

#### Example

**Correlate a message**

```ts
async function correlateMessageExample() {
  const camunda = createCamundaClient();

  const result = await camunda.correlateMessage({
    name: "order-payment-received",
    correlationKey: "ORD-12345",
    variables: {
      paymentId: "PAY-123",
      amount: 99.95,
    },
  });

  console.log(`Message correlated to: ${result.processInstanceKey}`);
}
```

#### Operation Id

correlateMessage

#### Tags

Message

---

### createAdminUser()

```ts
createAdminUser(input, options?): CancelablePromise<UserCreateResult>;
```

Create admin user

Creates a new user and assigns the admin role to it. This endpoint is only usable when users are managed in the Orchestration Cluster and while no user is assigned to the admin role. *

#### Parameters

##### input

[`UserRequest`](../type-aliases/UserRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserCreateResult`](../type-aliases/UserCreateResult.md)\>

#### Example

**Create an admin user**

```ts
async function createAdminUserExample(username: Username) {
  const camunda = createCamundaClient();

  const result = await camunda.createAdminUser({
    username,
    name: "Admin User",
    email: "admin@example.com",
    password: "admin-password-123",
  });

  console.log(`Created admin user: ${result.username}`);
}
```

#### Operation Id

createAdminUser

#### Tags

Setup

---

### createAgentInstance()

```ts
createAgentInstance(input, options?): CancelablePromise<AgentInstanceCreationResult>;
```

Create agent instance

Creates a new agent instance. The returned key identifies the instance and must
be used in subsequent update and query calls.

-

#### Parameters

##### input

[`AgentInstanceCreationRequest`](../type-aliases/AgentInstanceCreationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AgentInstanceCreationResult`](../type-aliases/AgentInstanceCreationResult.md)\>

#### Example

**Create an agent instance**

```ts
async function createAgentInstanceExample(
  elementInstanceKey: ElementInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.createAgentInstance({
    elementInstanceKey,
    definition: {
      model: "gpt-4o",
      provider: "openai",
      systemPrompt: "You are a helpful assistant.",
    },
  });

  console.log(`Created agent instance: ${result.agentInstanceKey}`);
}
```

#### Operation Id

createAgentInstance

#### Tags

Agent instance

---

### createAgentInstanceHistoryItem()

```ts
createAgentInstanceHistoryItem(input, options?): CancelablePromise<AgentInstanceHistoryItemCreationResult>;
```

Create agent instance history item

Appends a single history item to an agent instance's conversation history.
The created item has commitStatus PENDING until the job identified by jobLease
completes successfully, at which point it transitions to COMMITTED. If the job
fails or is superseded by a retry, the item is marked DISCARDED.

-

#### Parameters

##### input

[`createAgentInstanceHistoryItemInput`](../type-aliases/createAgentInstanceHistoryItemInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AgentInstanceHistoryItemCreationResult`](../type-aliases/AgentInstanceHistoryItemCreationResult.md)\>

#### Example

**Append an agent instance history item**

```ts
async function createAgentInstanceHistoryItemExample(
  agentInstanceKey: AgentInstanceKey,
  elementInstanceKey: ElementInstanceKey,
  jobKey: JobKey,
  jobLease: string
) {
  const camunda = createCamundaClient();

  const result = await camunda.createAgentInstanceHistoryItem({
    agentInstanceKey,
    elementInstanceKey,
    jobKey,
    jobLease,
    role: "ASSISTANT",
    content: [{ contentType: "TEXT", text: "How can I help you today?" }],
    producedAt: new Date().toISOString(),
  });

  console.log(`Created history item: ${result.historyItemKey}`);
}
```

#### Operation Id

createAgentInstanceHistoryItem

#### Tags

Agent instance

---

### createAuthorization()

```ts
createAuthorization(input, options?): CancelablePromise<AuthorizationCreateResult>;
```

Create authorization

Create the authorization. *

#### Parameters

##### input

\| [`AuthorizationIdBasedRequest`](../type-aliases/AuthorizationIdBasedRequest.md)
\| [`AuthorizationPropertyBasedRequest`](../type-aliases/AuthorizationPropertyBasedRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AuthorizationCreateResult`](../type-aliases/AuthorizationCreateResult.md)\>

#### Example

**Create an authorization**

```ts
async function createAuthorizationExample() {
  const camunda = createCamundaClient();

  const result = await camunda.createAuthorization({
    ownerId: "user-123",
    ownerType: "USER",
    resourceId: "order-process",
    resourceType: "PROCESS_DEFINITION",
    permissionTypes: ["CREATE_PROCESS_INSTANCE", "READ_PROCESS_INSTANCE"],
  });

  console.log(`Authorization key: ${result.authorizationKey}`);
}
```

#### Operation Id

createAuthorization

#### Tags

Authorization

---

### createDeployment()

```ts
createDeployment(input, options?): CancelablePromise<ExtendedDeploymentResult>;
```

Deploy resources

Deploys one or more resources, including BPMN processes, DMN decision models, forms, RPA resources, and generic files.
A deployment can contain any file type. Files that are not interpreted as BPMN, DMN, form, or RPA resources are stored as deployable generic resources in the engine.
This is an atomic call, i.e. either all resources are deployed or none of them are.

-

#### Parameters

##### input

[`createDeploymentInput`](../type-aliases/createDeploymentInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ExtendedDeploymentResult`](../interfaces/ExtendedDeploymentResult.md)\>

Enriched deployment result with typed arrays (processes, decisions, decisionRequirements, forms, resources).

#### Example

**Deploy resources from files**

```ts
async function deployResourcesFromFilesExample() {
  const camunda = createCamundaClient();

  // Node.js only: deploy directly from file paths
  const result = await camunda.deployResourcesFromFiles([
    "./process.bpmn",
    "./decision.dmn",
  ]);

  console.log(`Deployment key: ${result.deploymentKey}`);
}
```

#### Operation Id

createDeployment

#### Tags

Resource

---

### createDocument()

```ts
createDocument(input, options?): CancelablePromise<DocumentReference>;
```

Upload document

Upload a document to the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

-

#### Parameters

##### input

[`createDocumentInput`](../type-aliases/createDocumentInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DocumentReference`](../type-aliases/DocumentReference.md)\>

#### Example

**Upload a document**

```ts
async function createDocumentExample() {
  const camunda = createCamundaClient();

  const file = new Blob(["Hello, world!"], { type: "text/plain" });

  const result = await camunda.createDocument({
    file,
    metadata: { fileName: "hello.txt" },
  });

  console.log(`Document ID: ${result.documentId}`);
}
```

#### Operation Id

createDocument

#### Tags

Document

---

### createDocumentLink()

```ts
createDocumentLink(input, options?): CancelablePromise<DocumentLink>;
```

Create document link

Create a link to a document in the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP

-

#### Parameters

##### input

[`createDocumentLinkInput`](../type-aliases/createDocumentLinkInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DocumentLink`](../type-aliases/DocumentLink.md)\>

#### Example

**Create a document link**

```ts
async function createDocumentLinkExample(documentId: DocumentId) {
  const camunda = createCamundaClient();

  const link = await camunda.createDocumentLink({
    documentId,
    timeToLive: 3600000,
  });

  console.log(`Document link: ${link.url}`);
}
```

#### Operation Id

createDocumentLink

#### Tags

Document

---

### createDocuments()

```ts
createDocuments(input, options?): CancelablePromise<DocumentCreationBatchResponse>;
```

Upload multiple documents

Upload multiple documents to the Camunda 8 cluster.

The caller must provide a file name for each document, which will be used in case of a multi-status response
to identify which documents failed to upload. The file name can be provided in the `Content-Disposition` header
of the file part or in the `fileName` field of the metadata. You can add a parallel array of metadata objects. These
are matched with the files based on index, and must have the same length as the files array.
To pass homogenous metadata for all files, spread the metadata over the metadata array.
A filename value provided explicitly via the metadata array in the request overrides the `Content-Disposition` header
of the file part.

In case of a multi-status response, the response body will contain a list of `DocumentBatchProblemDetail` objects,
each of which contains the file name of the document that failed to upload and the reason for the failure.
The client can choose to retry the whole batch or individual documents based on the response.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

-

#### Parameters

##### input

[`createDocumentsInput`](../type-aliases/createDocumentsInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DocumentCreationBatchResponse`](../type-aliases/DocumentCreationBatchResponse.md)\>

#### Example

**Upload multiple documents**

```ts
async function createDocumentsExample() {
  const camunda = createCamundaClient();

  const file1 = new Blob(["File one"], { type: "text/plain" });
  const file2 = new Blob(["File two"], { type: "text/plain" });

  const result = await camunda.createDocuments({
    files: [file1, file2],
    metadataList: [{ fileName: "one.txt" }, { fileName: "two.txt" }],
  });

  for (const doc of result.createdDocuments ?? []) {
    console.log(`Created: ${doc.documentId}`);
  }
}
```

#### Operation Id

createDocuments

#### Tags

Document

---

### createElementInstanceVariables()

```ts
createElementInstanceVariables(input, options?): CancelablePromise<void>;
```

Update element instance variables

Updates all the variables of a particular scope (for example, process instance, element instance) with the given variable data.
Specify the element instance in the `elementInstanceKey` parameter.
Variable updates can be delayed by listener-related processing; if processing exceeds the
request timeout, this endpoint can return 504. Other gateway timeout causes are also
possible. Retry with backoff and inspect listener worker availability and logs when this
repeats.

-

#### Parameters

##### input

[`createElementInstanceVariablesInput`](../type-aliases/createElementInstanceVariablesInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Create element instance variables**

```ts
async function createElementInstanceVariablesExample(
  elementInstanceKey: ElementInstanceKey
) {
  const camunda = createCamundaClient();

  await camunda.createElementInstanceVariables({
    elementInstanceKey,
    variables: { orderId: "ORD-12345", status: "processing" },
  });
}
```

#### Operation Id

createElementInstanceVariables

#### Tags

Element instance

---

### createGlobalClusterVariable()

```ts
createGlobalClusterVariable(input, options?): CancelablePromise<ClusterVariableResult>;
```

Create a global-scoped cluster variable

Create a global-scoped cluster variable. *

#### Parameters

##### input

[`CreateClusterVariableRequest`](../type-aliases/CreateClusterVariableRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableResult`](../type-aliases/ClusterVariableResult.md)\>

#### Example

**Create a global cluster variable**

```ts
async function createGlobalClusterVariableExample(name: ClusterVariableName) {
  const camunda = createCamundaClient();

  const result = await camunda.createGlobalClusterVariable({
    name,
    value: { darkMode: true },
  });

  console.log(`Created: ${result.name}`);
}
```

#### Operation Id

createGlobalClusterVariable

#### Tags

Cluster Variable

---

### createGlobalTaskListener()

```ts
createGlobalTaskListener(input, options?): CancelablePromise<GlobalTaskListenerResult>;
```

Create global user task listener

Create a new global user task listener. *

#### Parameters

##### input

[`CreateGlobalTaskListenerRequest`](../type-aliases/CreateGlobalTaskListenerRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GlobalTaskListenerResult`](../type-aliases/GlobalTaskListenerResult.md)\>

#### Example

**Create a global task listener**

```ts
async function createGlobalTaskListenerExample(id: GlobalListenerId) {
  const camunda = createCamundaClient();

  const result = await camunda.createGlobalTaskListener({
    id,
    eventTypes: ["completing"],
    type: "audit-log-listener",
  });

  console.log(`Created listener: ${result.id}`);
}
```

#### Operation Id

createGlobalTaskListener

#### Tags

Global listener

---

### createGroup()

```ts
createGroup(input, options?): CancelablePromise<GroupCreateResult>;
```

Create group

Create a new group.

The supplied `groupId` is validated against `^[a-zA-Z0-9_~@.+-]+$`
(max 256 characters) by `IdentifierValidator.validateId` in the
runtime. This strict validation applies wherever the Groups API
is available: in OIDC deployments that set
`camunda.security.authentication.oidc.groupsClaim` the Groups
API (including this endpoint) is disabled entirely, so group
CRUD never sees externally-minted IdP IDs. The BYOG relaxation
only loosens validation when a group is referenced _as a member_
of a role or tenant (`assignRoleToGroup`,
`assignGroupToTenant`); group CRUD itself always uses the strict
default-id regex. The constraint is not advertised on the
`GroupId` schema so that the same schema can be reused at
member-reference sites without falsely rejecting
externally-minted IdP group IDs there.

-

#### Parameters

##### input

[`GroupCreateRequest`](../type-aliases/GroupCreateRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupCreateResult`](../type-aliases/GroupCreateResult.md)\>

#### Example

**Create a group**

```ts
async function createGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  const result = await camunda.createGroup({
    groupId,
    name: "Engineering Team",
  });

  console.log(`Created group: ${result.groupId}`);
}
```

#### Operation Id

createGroup

#### Tags

Group

---

### createJobWorker()

```ts
createJobWorker<In, Out, Headers>(cfg): JobWorker;
```

Create a job worker that activates and processes jobs of the given type.

Worker configuration fields inherit global defaults resolved via the
unified configuration (environment variables or equivalent `CAMUNDA_WORKER_*`
keys provided via `CamundaOptions.config`) when not explicitly set on the
config object.

#### Type Parameters

##### In

`In` _extends_ `ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\> = `any`

##### Out

`Out` _extends_ `ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\> = `any`

##### Headers

`Headers` _extends_ `ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\> = `any`

#### Parameters

##### cfg

[`JobWorkerConfig`](../interfaces/JobWorkerConfig.md)\<`In`, `Out`, `Headers`\>

Worker configuration

#### Returns

[`JobWorker`](../interfaces/JobWorker.md)

#### Examples

**Create a job worker**

```ts
async function createJobWorkerExample() {
  const camunda = createCamundaClient();

  const _worker = camunda.createJobWorker({
    jobType: "payment-processing",
    jobTimeoutMs: 30000,
    maxParallelJobs: 5,
    jobHandler: async (job): Promise<JobActionReceipt> => {
      console.log(`Processing job ${job.jobKey}`);
      return job.complete({ processed: true });
    },
  });

  // Workers run continuously until closed
  // worker.close();
}
```

**Job worker with error handling**

```ts
async function jobWorkerWithErrorHandlingExample() {
  const camunda = createCamundaClient();

  const worker = camunda.createJobWorker({
    jobType: "email-sending",
    jobTimeoutMs: 60000,
    maxParallelJobs: 10,
    pollIntervalMs: 300,
    jobHandler: async (job): Promise<JobActionReceipt> => {
      try {
        console.log(`Sending email for job ${job.jobKey}`);
        return job.complete({ sent: true });
      } catch (err) {
        return job.fail({
          errorMessage: String(err),
          retries: (job.retries ?? 1) - 1,
        });
      }
    },
  });

  void worker;
}
```

---

### createMappingRule()

```ts
createMappingRule(input, options?): CancelablePromise<MappingRuleCreateUpdateResult>;
```

Create mapping rule

Create a new mapping rule

-

#### Parameters

##### input

[`MappingRuleCreateRequest`](../type-aliases/MappingRuleCreateRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MappingRuleCreateUpdateResult`](../type-aliases/MappingRuleCreateUpdateResult.md)\>

#### Example

**Create a mapping rule**

```ts
async function createMappingRuleExample(mappingRuleId: MappingRuleId) {
  const camunda = createCamundaClient();

  const result = await camunda.createMappingRule({
    mappingRuleId,
    name: "LDAP Group Mapping",
    claimName: "groups",
    claimValue: "engineering",
  });

  console.log(`Created mapping rule: ${result.mappingRuleId}`);
}
```

#### Operation Id

createMappingRule

#### Tags

Mapping rule

---

### createProcessInstance()

```ts
createProcessInstance(input, options?): CancelablePromise<CreateProcessInstanceResult>;
```

Create process instance

Creates and starts an instance of the specified process.
The process definition to use to create the instance can be specified either using its unique key
(as returned by Deploy resources), or using the BPMN process id and a version.

Waits for the completion of the process instance before returning a result
when awaitCompletion is enabled.

-

#### Parameters

##### input

\| [`ProcessInstanceCreationInstructionByKey`](../type-aliases/ProcessInstanceCreationInstructionByKey.md)
\| [`ProcessInstanceCreationInstructionById`](../type-aliases/ProcessInstanceCreationInstructionById.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`CreateProcessInstanceResult`](../type-aliases/CreateProcessInstanceResult.md)\>

#### Examples

**By ID**

```ts
async function createProcessInstanceByIdExample(
  processDefinitionId: ProcessDefinitionId
) {
  const camunda = createCamundaClient();

  const result = await camunda.createProcessInstance({
    processDefinitionId,
    variables: {
      orderId: "ORD-12345",
      amount: 99.95,
    },
  });

  console.log(`Started process instance: ${result.processInstanceKey}`);
}
```

**By key**

```ts
async function createProcessInstanceByKeyExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  // Key from a previous API response (e.g. deployment)
  const result = await camunda.createProcessInstance({
    processDefinitionKey,
    variables: {
      orderId: "ORD-12345",
      amount: 99.95,
    },
  });

  console.log(`Started process instance: ${result.processInstanceKey}`);
}
```

#### Operation Id

createProcessInstance

#### Tags

Process instance

---

### createRole()

```ts
createRole(input, options?): CancelablePromise<RoleCreateResult>;
```

Create role

Create a new role. *

#### Parameters

##### input

[`RoleCreateRequest`](../type-aliases/RoleCreateRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleCreateResult`](../type-aliases/RoleCreateResult.md)\>

#### Example

**Create a role**

```ts
async function createRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  const result = await camunda.createRole({
    roleId,
    name: "Process Admin",
  });

  console.log(`Created role: ${result.roleId}`);
}
```

#### Operation Id

createRole

#### Tags

Role

---

### createTenant()

```ts
createTenant(input, options?): CancelablePromise<TenantCreateResult>;
```

Create tenant

Creates a new tenant. *

#### Parameters

##### input

[`TenantCreateRequest`](../type-aliases/TenantCreateRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantCreateResult`](../type-aliases/TenantCreateResult.md)\>

#### Example

**Create a tenant**

```ts
async function createTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.createTenant({
    tenantId,
    name: "Customer Service",
  });

  console.log(`Created tenant: ${result.tenantId}`);
}
```

#### Operation Id

createTenant

#### Tags

Tenant

---

### createTenantClusterVariable()

```ts
createTenantClusterVariable(input, options?): CancelablePromise<ClusterVariableResult>;
```

Create a tenant-scoped cluster variable

Create a new cluster variable for the given tenant. *

#### Parameters

##### input

[`createTenantClusterVariableInput`](../type-aliases/createTenantClusterVariableInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableResult`](../type-aliases/ClusterVariableResult.md)\>

#### Example

**Create a tenant cluster variable**

```ts
async function createTenantClusterVariableExample(
  tenantId: TenantId,
  name: ClusterVariableName
) {
  const camunda = createCamundaClient();

  const result = await camunda.createTenantClusterVariable({
    tenantId,
    name,
    value: { region: "us-east-1" },
  });

  console.log(`Created: ${result.name}`);
}
```

#### Operation Id

createTenantClusterVariable

#### Tags

Cluster Variable

---

### createThreadedJobWorker()

```ts
createThreadedJobWorker<In, Out, Headers>(cfg): ThreadedJobWorker;
```

Create a threaded job worker that runs handler logic in a pool of worker threads.
The handler must be a separate module file that exports a default function with
signature `(job, client) => Promise<JobActionReceipt>`.

This keeps the main event loop free for polling and I/O, dramatically improving
throughput for CPU-bound job handlers.

Worker configuration fields inherit global defaults resolved via the
unified configuration (environment variables or equivalent `CAMUNDA_WORKER_*`
keys provided via `CamundaOptions.config`) when not explicitly set on the
config object.

#### Type Parameters

##### In

`In` _extends_ `ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\> = `any`

##### Out

`Out` _extends_ `ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\> = `any`

##### Headers

`Headers` _extends_ `ZodType`\<`unknown`, `unknown`, `$ZodTypeInternals`\<`unknown`, `unknown`\>\> = `any`

#### Parameters

##### cfg

[`ThreadedJobWorkerConfig`](../interfaces/ThreadedJobWorkerConfig.md)\<`In`, `Out`, `Headers`\>

Threaded worker configuration

#### Returns

[`ThreadedJobWorker`](../interfaces/ThreadedJobWorker.md)

#### Example

**Create a threaded job worker**

```ts
const worker = client.createThreadedJobWorker({
  jobType: "cpu-heavy-task",
  handlerModule: "./my-handler.js",
  maxParallelJobs: 32,
  jobTimeoutMs: 30000,
});
```

---

### createUser()

```ts
createUser(input, options?): CancelablePromise<UserCreateResult>;
```

Create user

Create a new user. *

#### Parameters

##### input

[`UserRequest`](../type-aliases/UserRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserCreateResult`](../type-aliases/UserCreateResult.md)\>

#### Example

**Create a user**

```ts
async function createUserExample(username: Username) {
  const camunda = createCamundaClient();

  const result = await camunda.createUser({
    username,
    name: "Alice Smith",
    email: "alice@example.com",
    password: "secure-password-123",
  });

  console.log(`Created user: ${result.username}`);
}
```

#### Operation Id

createUser

#### Tags

User

---

### deleteAuthorization()

```ts
deleteAuthorization(input, options?): CancelablePromise<void>;
```

Delete authorization

Deletes the authorization with the given key. *

#### Parameters

##### input

[`deleteAuthorizationInput`](../type-aliases/deleteAuthorizationInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete an authorization**

```ts
async function deleteAuthorizationExample(authorizationKey: AuthorizationKey) {
  const camunda = createCamundaClient();

  await camunda.deleteAuthorization({ authorizationKey });
}
```

#### Operation Id

deleteAuthorization

#### Tags

Authorization

---

### deleteDecisionInstance()

```ts
deleteDecisionInstance(input, options?): CancelablePromise<void>;
```

Delete decision instance

Delete all associated decision evaluations based on provided key. *

#### Parameters

##### input

`object` & `object`

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a decision instance**

```ts
async function deleteDecisionInstanceExample(
  decisionEvaluationKey: DecisionEvaluationKey
) {
  const camunda = createCamundaClient();

  await camunda.deleteDecisionInstance({ decisionEvaluationKey });
}
```

#### Operation Id

deleteDecisionInstance

#### Tags

Decision instance

---

### deleteDecisionInstancesBatchOperation()

```ts
deleteDecisionInstancesBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Delete decision instances (batch)

Delete multiple decision instances. This will delete the historic data from secondary storage.
This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`DecisionInstanceDeletionBatchOperationRequest`](../type-aliases/DecisionInstanceDeletionBatchOperationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Delete decision instances in batch**

```ts
async function deleteDecisionInstancesBatchOperationExample() {
  const camunda = createCamundaClient();

  const result = await camunda.deleteDecisionInstancesBatchOperation({
    filter: {},
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

deleteDecisionInstancesBatchOperation

#### Tags

Decision instance

---

### deleteDocument()

```ts
deleteDocument(input, options?): CancelablePromise<void>;
```

Delete document

Delete a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

-

#### Parameters

##### input

[`deleteDocumentInput`](../type-aliases/deleteDocumentInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a document**

```ts
async function deleteDocumentExample(documentId: DocumentId) {
  const camunda = createCamundaClient();

  await camunda.deleteDocument({ documentId });
}
```

#### Operation Id

deleteDocument

#### Tags

Document

---

### deleteGlobalClusterVariable()

```ts
deleteGlobalClusterVariable(input, options?): CancelablePromise<void>;
```

Delete a global-scoped cluster variable

Delete a global-scoped cluster variable. *

#### Parameters

##### input

[`deleteGlobalClusterVariableInput`](../type-aliases/deleteGlobalClusterVariableInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a global cluster variable**

```ts
async function deleteGlobalClusterVariableExample(name: ClusterVariableName) {
  const camunda = createCamundaClient();

  await camunda.deleteGlobalClusterVariable({ name });
}
```

#### Operation Id

deleteGlobalClusterVariable

#### Tags

Cluster Variable

---

### deleteGlobalTaskListener()

```ts
deleteGlobalTaskListener(input, options?): CancelablePromise<void>;
```

Delete global user task listener

Deletes a global user task listener. *

#### Parameters

##### input

[`deleteGlobalTaskListenerInput`](../type-aliases/deleteGlobalTaskListenerInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a global task listener**

```ts
async function deleteGlobalTaskListenerExample(id: GlobalListenerId) {
  const camunda = createCamundaClient();

  await camunda.deleteGlobalTaskListener({
    id,
  });
}
```

#### Operation Id

deleteGlobalTaskListener

#### Tags

Global listener

---

### deleteGroup()

```ts
deleteGroup(input, options?): CancelablePromise<void>;
```

Delete group

Deletes the group with the given ID. *

#### Parameters

##### input

[`deleteGroupInput`](../type-aliases/deleteGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a group**

```ts
async function deleteGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  await camunda.deleteGroup({ groupId });
}
```

#### Operation Id

deleteGroup

#### Tags

Group

---

### deleteMappingRule()

```ts
deleteMappingRule(input, options?): CancelablePromise<void>;
```

Delete a mapping rule

Deletes the mapping rule with the given ID.

-

#### Parameters

##### input

[`deleteMappingRuleInput`](../type-aliases/deleteMappingRuleInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a mapping rule**

```ts
async function deleteMappingRuleExample(mappingRuleId: MappingRuleId) {
  const camunda = createCamundaClient();

  await camunda.deleteMappingRule({ mappingRuleId });
}
```

#### Operation Id

deleteMappingRule

#### Tags

Mapping rule

---

### deleteProcessInstance()

```ts
deleteProcessInstance(input, options?): CancelablePromise<void>;
```

Delete process instance

Deletes a process instance. Only instances that are completed or terminated can be deleted. *

#### Parameters

##### input

`object` & `object`

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a process instance**

```ts
async function deleteProcessInstanceExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  await camunda.deleteProcessInstance({ processInstanceKey });
}
```

#### Operation Id

deleteProcessInstance

#### Tags

Process instance

---

### deleteProcessInstancesBatchOperation()

```ts
deleteProcessInstancesBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Delete process instances (batch)

Delete multiple process instances. This will delete the historic data from secondary storage.
Only process instances in a final state (COMPLETED or TERMINATED) can be deleted.
This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`ProcessInstanceDeletionBatchOperationRequest`](../type-aliases/ProcessInstanceDeletionBatchOperationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Delete process instances in batch**

```ts
async function deleteProcessInstancesBatchOperationExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.deleteProcessInstancesBatchOperation({
    filter: {
      processDefinitionKey,
    },
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

deleteProcessInstancesBatchOperation

#### Tags

Process instance

---

### deleteResource()

```ts
deleteResource(input, options?): CancelablePromise<DeleteResourceResponse>;
```

Delete resource

Deletes a deployed resource. This can be a process definition, decision requirements
definition, or form definition deployed using the deploy resources endpoint. Specify the
resource you want to delete in the `resourceKey` parameter.

Once a resource has been deleted it cannot be recovered. If the resource needs to be
available again, a new deployment of the resource is required.

By default, only the resource itself is deleted from the runtime state. To also delete the
historic data associated with a resource, set the `deleteHistory` flag in the request body
to `true`. The historic data is deleted asynchronously via a batch operation. The details of
the created batch operation are included in the response. Note that history deletion is only
supported for process resources; for other resource types this flag is ignored and no history
will be deleted. *

#### Parameters

##### input

`object` & `object`

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DeleteResourceResponse`](../type-aliases/DeleteResourceResponse.md)\>

#### Example

**Delete a resource**

```ts
async function deleteResourceExample(resourceKey: ProcessDefinitionKey) {
  const camunda = createCamundaClient();

  // Use a process definition key as a resource key for deletion
  await camunda.deleteResource({
    resourceKey,
  });
}
```

#### Operation Id

deleteResource

#### Tags

Resource

---

### deleteRole()

```ts
deleteRole(input, options?): CancelablePromise<void>;
```

Delete role

Deletes the role with the given ID. *

#### Parameters

##### input

[`deleteRoleInput`](../type-aliases/deleteRoleInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a role**

```ts
async function deleteRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  await camunda.deleteRole({ roleId });
}
```

#### Operation Id

deleteRole

#### Tags

Role

---

### deleteTenant()

```ts
deleteTenant(input, options?): CancelablePromise<void>;
```

Delete tenant

Deletes an existing tenant. *

#### Parameters

##### input

[`deleteTenantInput`](../type-aliases/deleteTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a tenant**

```ts
async function deleteTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  await camunda.deleteTenant({ tenantId });
}
```

#### Operation Id

deleteTenant

#### Tags

Tenant

---

### deleteTenantClusterVariable()

```ts
deleteTenantClusterVariable(input, options?): CancelablePromise<void>;
```

Delete a tenant-scoped cluster variable

Delete a tenant-scoped cluster variable. *

#### Parameters

##### input

[`deleteTenantClusterVariableInput`](../type-aliases/deleteTenantClusterVariableInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a tenant cluster variable**

```ts
async function deleteTenantClusterVariableExample(
  tenantId: TenantId,
  name: ClusterVariableName
) {
  const camunda = createCamundaClient();

  await camunda.deleteTenantClusterVariable({
    tenantId,
    name,
  });
}
```

#### Operation Id

deleteTenantClusterVariable

#### Tags

Cluster Variable

---

### deleteUser()

```ts
deleteUser(input, options?): CancelablePromise<void>;
```

Delete user

Deletes a user. *

#### Parameters

##### input

[`deleteUserInput`](../type-aliases/deleteUserInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Delete a user**

```ts
async function deleteUserExample(username: Username) {
  const camunda = createCamundaClient();

  await camunda.deleteUser({ username });
}
```

#### Operation Id

deleteUser

#### Tags

User

---

### deployResourcesFromFiles()

```ts
deployResourcesFromFiles(resourceFilenames, options?): CancelablePromise<ExtendedDeploymentResult>;
```

Node-only convenience: deploy resources from local filesystem paths.

#### Parameters

##### resourceFilenames

`string`[]

Absolute or relative file paths to BPMN/DMN/form/resource files.

##### options?

Optional: tenantId.

###### tenantId?

`string`

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ExtendedDeploymentResult`](../interfaces/ExtendedDeploymentResult.md)\>

ExtendedDeploymentResult

---

### emitSupportLogPreamble()

```ts
emitSupportLogPreamble(): void;
```

Emit the standard support log preamble & redacted configuration to the current support logger.
Safe to call multiple times; subsequent calls are ignored (idempotent).
Useful when a custom supportLogger was injected and you still want the canonical header & config dump.

#### Returns

`void`

---

### evaluateConditionals()

```ts
evaluateConditionals(input, options?): CancelablePromise<EvaluateConditionalResult>;
```

Evaluate root level conditional start events

Evaluates root-level conditional start events for process definitions.
If the evaluation is successful, it will return the keys of all created process instances, along with their associated process definition key.
Multiple root-level conditional start events of the same process definition can trigger if their conditions evaluate to true.

-

#### Parameters

##### input

[`ConditionalEvaluationInstruction`](../type-aliases/ConditionalEvaluationInstruction.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`EvaluateConditionalResult`](../type-aliases/EvaluateConditionalResult.md)\>

#### Example

**Evaluate conditionals**

```ts
async function evaluateConditionalsExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.evaluateConditionals({
    variables: { orderReady: true },
    tenantId,
  });

  console.log(`Evaluated conditionals: ${JSON.stringify(result)}`);
}
```

#### Operation Id

evaluateConditionals

#### Tags

Conditional

---

### evaluateDecision()

```ts
evaluateDecision(input, options?): CancelablePromise<EvaluateDecisionResult>;
```

Evaluate decision

Evaluates a decision.
You specify the decision to evaluate either by using its unique key (as returned by
DeployResource), or using the decision ID. When using the decision ID, the latest deployed
version of the decision is used.

-

#### Parameters

##### input

\| [`DecisionEvaluationById`](../type-aliases/DecisionEvaluationById.md)
\| [`DecisionEvaluationByKey`](../type-aliases/DecisionEvaluationByKey.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`EvaluateDecisionResult`](../type-aliases/EvaluateDecisionResult.md)\>

#### Examples

**By ID**

```ts
async function evaluateDecisionByIdExample(
  decisionDefinitionId: DecisionDefinitionId
) {
  const camunda = createCamundaClient();

  const result = await camunda.evaluateDecision({
    decisionDefinitionId,
    variables: {
      amount: 1000,
      invoiceCategory: "Misc",
    },
  });

  console.log(`Decision: ${result.decisionDefinitionId}`);
  console.log(`Output: ${result.output}`);
}
```

**By key**

```ts
async function evaluateDecisionByKeyExample(
  decisionDefinitionKey: DecisionDefinitionKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.evaluateDecision({
    decisionDefinitionKey,
    variables: {
      amount: 1000,
      invoiceCategory: "Misc",
    },
  });

  console.log(`Decision output: ${result.output}`);
}
```

#### Operation Id

evaluateDecision

#### Tags

Decision definition

---

### evaluateExpression()

```ts
evaluateExpression(input, options?): CancelablePromise<ExpressionEvaluationResult>;
```

Evaluate an expression

Evaluates a FEEL expression and returns the result. Supports references to tenant scoped
cluster variables when a tenant ID is provided. Optionally, provide a `scopeKey` to make the
variables of a specific process instance or element instance visible while evaluating the
expression.

-

#### Parameters

##### input

[`ExpressionEvaluationRequest`](../type-aliases/ExpressionEvaluationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ExpressionEvaluationResult`](../type-aliases/ExpressionEvaluationResult.md)\>

#### Example

**Evaluate an expression**

```ts
async function evaluateExpressionExample() {
  const camunda = createCamundaClient();

  const result = await camunda.evaluateExpression({
    expression: "= x + y",
    variables: { x: 10, y: 20 },
  });

  console.log(`Result: ${result.result}`);
}
```

#### Operation Id

evaluateExpression

#### Tags

Expression

---

### failJob()

```ts
failJob(input, options?): CancelablePromise<void>;
```

Fail job

Mark the job as failed.

-

#### Parameters

##### input

[`failJobInput`](../type-aliases/failJobInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Fail a job with retry**

```ts
async function failJobExample(jobKey: JobKey) {
  const camunda = createCamundaClient();

  await camunda.failJob({
    jobKey,
    retries: 2,
    errorMessage: "Payment gateway timeout",
    retryBackOff: 5000,
  });
}
```

#### Operation Id

failJob

#### Tags

Job

---

### forceAuthRefresh()

```ts
forceAuthRefresh(): Promise<string | undefined>;
```

#### Returns

`Promise`\<`string` \| `undefined`\>

---

### getAgentInstance()

```ts
getAgentInstance(
   input,
   consistencyManagement,
options?): CancelablePromise<AgentInstanceResult>;
```

Get agent instance

Returns agent instance as JSON. *

#### Parameters

##### input

[`getAgentInstanceInput`](../type-aliases/getAgentInstanceInput.md)

##### consistencyManagement

[`getAgentInstanceConsistency`](../type-aliases/getAgentInstanceConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AgentInstanceResult`](../type-aliases/AgentInstanceResult.md)\>

#### Example

**Get an agent instance**

```ts
async function getAgentInstanceExample(agentInstanceKey: AgentInstanceKey) {
  const camunda = createCamundaClient();

  const instance = await camunda.getAgentInstance(
    { agentInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Status: ${instance.status}`);
  console.log(`Element: ${instance.elementId}`);
}
```

#### Operation Id

getAgentInstance

#### Tags

Agent instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getAuditLog()

```ts
getAuditLog(
   input,
   consistencyManagement,
options?): CancelablePromise<AuditLogResult>;
```

Get audit log

Get an audit log entry by auditLogKey. *

#### Parameters

##### input

[`getAuditLogInput`](../type-aliases/getAuditLogInput.md)

##### consistencyManagement

[`getAuditLogConsistency`](../type-aliases/getAuditLogConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AuditLogResult`](../type-aliases/AuditLogResult.md)\>

#### Example

**Get an audit log entry**

```ts
async function getAuditLogExample(auditLogKey: AuditLogKey) {
  const camunda = createCamundaClient();

  const log = await camunda.getAuditLog(
    { auditLogKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Audit log: ${log.operationType}`);
}
```

#### Operation Id

getAuditLog

#### Tags

Audit Log

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getAuthentication()

```ts
getAuthentication(options?): CancelablePromise<CamundaUserResult>;
```

Get current user

Retrieves the current authenticated user. *

#### Parameters

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`CamundaUserResult`](../type-aliases/CamundaUserResult.md)\>

#### Example

**Get authentication info**

```ts
async function getAuthenticationExample() {
  const camunda = createCamundaClient();

  const user = await camunda.getAuthentication();

  console.log(`Authenticated as: ${user.username}`);
}
```

#### Operation Id

getAuthentication

#### Tags

Authentication

---

### getAuthHeaders()

```ts
getAuthHeaders(): Promise<Record<string, string>>;
```

#### Returns

`Promise`\<`Record`\<`string`, `string`\>\>

---

### getAuthorization()

```ts
getAuthorization(
   input,
   consistencyManagement,
options?): CancelablePromise<AuthorizationResult>;
```

Get authorization

Get authorization by the given key. *

#### Parameters

##### input

[`getAuthorizationInput`](../type-aliases/getAuthorizationInput.md)

##### consistencyManagement

[`getAuthorizationConsistency`](../type-aliases/getAuthorizationConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AuthorizationResult`](../type-aliases/AuthorizationResult.md)\>

#### Example

**Get an authorization**

```ts
async function getAuthorizationExample(authorizationKey: AuthorizationKey) {
  const camunda = createCamundaClient();

  const authorization = await camunda.getAuthorization(
    { authorizationKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Owner: ${authorization.ownerId} (${authorization.ownerType})`);
}
```

#### Operation Id

getAuthorization

#### Tags

Authorization

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getBackpressureState()

```ts
getBackpressureState():
  | {
  backoffMs: number;
  consecutive: number;
  permitsCurrent: number;
  permitsMax: number | null;
  severity: BackpressureSeverity;
  waiters: number;
}
  | {
  consecutive: number;
  permitsCurrent: number;
  permitsMax: null;
  severity: string;
  waiters: number;
};
```

Public accessor for current backpressure adaptive limiter state (stable)

#### Returns

\| \{
`backoffMs`: `number`;
`consecutive`: `number`;
`permitsCurrent`: `number`;
`permitsMax`: `number` \| `null`;
`severity`: [`BackpressureSeverity`](../type-aliases/BackpressureSeverity.md);
`waiters`: `number`;
\}
\| \{
`consecutive`: `number`;
`permitsCurrent`: `number`;
`permitsMax`: `null`;
`severity`: `string`;
`waiters`: `number`;
\}

---

### getBatchOperation()

```ts
getBatchOperation(
   input,
   consistencyManagement,
options?): CancelablePromise<BatchOperationResponse>;
```

Get batch operation

Get batch operation by key. *

#### Parameters

##### input

[`getBatchOperationInput`](../type-aliases/getBatchOperationInput.md)

##### consistencyManagement

[`getBatchOperationConsistency`](../type-aliases/getBatchOperationConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationResponse`](../type-aliases/BatchOperationResponse.md)\>

#### Example

**Get a batch operation**

```ts
async function getBatchOperationExample(batchOperationKey: BatchOperationKey) {
  const camunda = createCamundaClient();

  const batch = await camunda.getBatchOperation(
    { batchOperationKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Batch: ${batch.batchOperationType} (${batch.state})`);
}
```

#### Operation Id

getBatchOperation

#### Tags

Batch operation

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getConfig()

```ts
getConfig(): Readonly<CamundaConfig>;
```

Read-only snapshot of current hydrated configuration (do not mutate directly).
Use configure(...) to apply changes.

#### Returns

`Readonly`\<[`CamundaConfig`](../interfaces/CamundaConfig.md)\>

---

### getDecisionDefinition()

```ts
getDecisionDefinition(
   input,
   consistencyManagement,
options?): CancelablePromise<DecisionDefinitionResult>;
```

Get decision definition

Returns a decision definition by key. *

#### Parameters

##### input

[`getDecisionDefinitionInput`](../type-aliases/getDecisionDefinitionInput.md)

##### consistencyManagement

[`getDecisionDefinitionConsistency`](../type-aliases/getDecisionDefinitionConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DecisionDefinitionResult`](../type-aliases/DecisionDefinitionResult.md)\>

#### Example

**Get a decision definition**

```ts
async function getDecisionDefinitionExample(
  decisionDefinitionKey: DecisionDefinitionKey
) {
  const camunda = createCamundaClient();

  const definition = await camunda.getDecisionDefinition(
    { decisionDefinitionKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Decision: ${definition.decisionDefinitionId}`);
  console.log(`Version: ${definition.version}`);
}
```

#### Operation Id

getDecisionDefinition

#### Tags

Decision definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getDecisionDefinitionXml()

```ts
getDecisionDefinitionXml(
   input,
   consistencyManagement,
options?): CancelablePromise<string>;
```

Get decision definition XML

Returns decision definition as XML. *

#### Parameters

##### input

[`getDecisionDefinitionXmlInput`](../type-aliases/getDecisionDefinitionXmlInput.md)

##### consistencyManagement

[`getDecisionDefinitionXmlConsistency`](../type-aliases/getDecisionDefinitionXmlConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`string`\>

#### Example

**Get decision definition XML**

```ts
async function getDecisionDefinitionXmlExample(
  decisionDefinitionKey: DecisionDefinitionKey
) {
  const camunda = createCamundaClient();

  const xml = await camunda.getDecisionDefinitionXml(
    { decisionDefinitionKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`XML length: ${JSON.stringify(xml).length}`);
}
```

#### Operation Id

getDecisionDefinitionXML

#### Tags

Decision definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getDecisionInstance()

```ts
getDecisionInstance(
   input,
   consistencyManagement,
options?): CancelablePromise<DecisionInstanceGetQueryResult>;
```

Get decision instance

Returns a decision instance. *

#### Parameters

##### input

[`getDecisionInstanceInput`](../type-aliases/getDecisionInstanceInput.md)

##### consistencyManagement

[`getDecisionInstanceConsistency`](../type-aliases/getDecisionInstanceConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DecisionInstanceGetQueryResult`](../type-aliases/DecisionInstanceGetQueryResult.md)\>

#### Example

**Get a decision instance**

```ts
async function getDecisionInstanceExample(
  decisionEvaluationInstanceKey: DecisionEvaluationInstanceKey
) {
  const camunda = createCamundaClient();

  const instance = await camunda.getDecisionInstance(
    { decisionEvaluationInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Decision: ${instance.decisionDefinitionId}`);
}
```

#### Operation Id

getDecisionInstance

#### Tags

Decision instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getDecisionRequirements()

```ts
getDecisionRequirements(
   input,
   consistencyManagement,
options?): CancelablePromise<DecisionRequirementsResult>;
```

Get decision requirements

Returns Decision Requirements as JSON. *

#### Parameters

##### input

[`getDecisionRequirementsInput`](../type-aliases/getDecisionRequirementsInput.md)

##### consistencyManagement

[`getDecisionRequirementsConsistency`](../type-aliases/getDecisionRequirementsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DecisionRequirementsResult`](../type-aliases/DecisionRequirementsResult.md)\>

#### Example

**Get decision requirements**

```ts
async function getDecisionRequirementsExample(
  decisionRequirementsKey: DecisionRequirementsKey
) {
  const camunda = createCamundaClient();

  const requirements = await camunda.getDecisionRequirements(
    { decisionRequirementsKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Requirements: ${requirements.decisionRequirementsId}`);
}
```

#### Operation Id

getDecisionRequirements

#### Tags

Decision requirements

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getDecisionRequirementsXml()

```ts
getDecisionRequirementsXml(
   input,
   consistencyManagement,
options?): CancelablePromise<string>;
```

Get decision requirements XML

Returns decision requirements as XML. *

#### Parameters

##### input

[`getDecisionRequirementsXmlInput`](../type-aliases/getDecisionRequirementsXmlInput.md)

##### consistencyManagement

[`getDecisionRequirementsXmlConsistency`](../type-aliases/getDecisionRequirementsXmlConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`string`\>

#### Example

**Get decision requirements XML**

```ts
async function getDecisionRequirementsXmlExample(
  decisionRequirementsKey: DecisionRequirementsKey
) {
  const camunda = createCamundaClient();

  const xml = await camunda.getDecisionRequirementsXml(
    { decisionRequirementsKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`XML length: ${JSON.stringify(xml).length}`);
}
```

#### Operation Id

getDecisionRequirementsXML

#### Tags

Decision requirements

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getDocument()

```ts
getDocument(input, options?): CancelablePromise<Blob>;
```

Download document

Download a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

-

#### Parameters

##### input

[`getDocumentInput`](../type-aliases/getDocumentInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`Blob`\>

#### Example

**Download a document**

```ts
async function getDocumentExample(documentId: DocumentId) {
  const camunda = createCamundaClient();

  await camunda.getDocument({ documentId });

  console.log(`Downloaded document: ${documentId}`);
}
```

#### Operation Id

getDocument

#### Tags

Document

---

### getElementInstance()

```ts
getElementInstance(
   input,
   consistencyManagement,
options?): CancelablePromise<ElementInstanceResult>;
```

Get element instance

Returns element instance as JSON. *

#### Parameters

##### input

[`getElementInstanceInput`](../type-aliases/getElementInstanceInput.md)

##### consistencyManagement

[`getElementInstanceConsistency`](../type-aliases/getElementInstanceConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ElementInstanceResult`](../type-aliases/ElementInstanceResult.md)\>

#### Example

**Get an element instance**

```ts
async function getElementInstanceExample(
  elementInstanceKey: ElementInstanceKey
) {
  const camunda = createCamundaClient();

  const element = await camunda.getElementInstance(
    { elementInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Element: ${element.elementId} (${element.type})`);
}
```

#### Operation Id

getElementInstance

#### Tags

Element instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getErrorMode()

```ts
getErrorMode(): "throw" | "result";
```

Internal accessor (read-only) for eventual consistency error mode.

#### Returns

`"throw"` \| `"result"`

---

### getFormByKey()

```ts
getFormByKey(
   input,
   consistencyManagement,
options?): CancelablePromise<FormResult>;
```

Get form by key

Get a form by its unique form key.

-

#### Parameters

##### input

[`getFormByKeyInput`](../type-aliases/getFormByKeyInput.md)

##### consistencyManagement

[`getFormByKeyConsistency`](../type-aliases/getFormByKeyConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`FormResult`](../type-aliases/FormResult.md)\>

#### Example

**Get a form by key**

```ts
async function getFormByKeyExample(formKey: FormKey) {
  const camunda = createCamundaClient();

  const form = await camunda.getFormByKey(
    {
      formKey,
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Form: ${form.formId}, version: ${form.version}`);
}
```

#### Operation Id

getFormByKey

#### Tags

Form

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getGlobalClusterVariable()

```ts
getGlobalClusterVariable(
   input,
   consistencyManagement,
options?): CancelablePromise<ClusterVariableResult>;
```

Get a global-scoped cluster variable

Get a global-scoped cluster variable. *

#### Parameters

##### input

[`getGlobalClusterVariableInput`](../type-aliases/getGlobalClusterVariableInput.md)

##### consistencyManagement

[`getGlobalClusterVariableConsistency`](../type-aliases/getGlobalClusterVariableConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableResult`](../type-aliases/ClusterVariableResult.md)\>

#### Example

**Get a global cluster variable**

```ts
async function getGlobalClusterVariableExample(name: ClusterVariableName) {
  const camunda = createCamundaClient();

  const variable = await camunda.getGlobalClusterVariable(
    { name },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`${variable.name} = ${variable.value}`);
}
```

#### Operation Id

getGlobalClusterVariable

#### Tags

Cluster Variable

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getGlobalJobStatistics()

```ts
getGlobalJobStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<GlobalJobStatisticsQueryResult>;
```

Global job statistics

Returns global aggregated counts for jobs. Filter by the creation time window (required) and optionally by jobType.

-

#### Parameters

##### input

[`getGlobalJobStatisticsInput`](../type-aliases/getGlobalJobStatisticsInput.md)

##### consistencyManagement

[`getGlobalJobStatisticsConsistency`](../type-aliases/getGlobalJobStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GlobalJobStatisticsQueryResult`](../type-aliases/GlobalJobStatisticsQueryResult.md)\>

#### Example

**Get global job statistics**

```ts
async function getGlobalJobStatisticsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getGlobalJobStatistics(
    {
      from: "2025-01-01T00:00:00Z",
      to: "2025-12-31T23:59:59Z",
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Statistics retrieved: ${JSON.stringify(result)}`);
}
```

#### Operation Id

getGlobalJobStatistics

#### Tags

Job

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getGlobalTaskListener()

```ts
getGlobalTaskListener(
   input,
   consistencyManagement,
options?): CancelablePromise<GlobalTaskListenerResult>;
```

Get global user task listener

Get a global user task listener by its id. *

#### Parameters

##### input

[`getGlobalTaskListenerInput`](../type-aliases/getGlobalTaskListenerInput.md)

##### consistencyManagement

[`getGlobalTaskListenerConsistency`](../type-aliases/getGlobalTaskListenerConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GlobalTaskListenerResult`](../type-aliases/GlobalTaskListenerResult.md)\>

#### Example

**Get a global task listener**

```ts
async function getGlobalTaskListenerExample(id: GlobalListenerId) {
  const camunda = createCamundaClient();

  const listener = await camunda.getGlobalTaskListener(
    { id },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Listener: ${listener.type} (${listener.eventTypes})`);
}
```

#### Operation Id

getGlobalTaskListener

#### Tags

Global listener

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getGroup()

```ts
getGroup(
   input,
   consistencyManagement,
options?): CancelablePromise<GroupResult>;
```

Get group

Get a group by its ID. *

#### Parameters

##### input

[`getGroupInput`](../type-aliases/getGroupInput.md)

##### consistencyManagement

[`getGroupConsistency`](../type-aliases/getGroupConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupResult`](../type-aliases/GroupResult.md)\>

#### Example

**Get a group**

```ts
async function getGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  const group = await camunda.getGroup(
    { groupId },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Group: ${group.name}`);
}
```

#### Operation Id

getGroup

#### Tags

Group

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getIncident()

```ts
getIncident(
   input,
   consistencyManagement,
options?): CancelablePromise<IncidentResult>;
```

Get incident

Returns incident as JSON.

-

#### Parameters

##### input

[`getIncidentInput`](../type-aliases/getIncidentInput.md)

##### consistencyManagement

[`getIncidentConsistency`](../type-aliases/getIncidentConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`IncidentResult`](../type-aliases/IncidentResult.md)\>

#### Example

**Get an incident**

```ts
async function getIncidentExample(incidentKey: IncidentKey) {
  const camunda = createCamundaClient();

  const incident = await camunda.getIncident(
    { incidentKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Type: ${incident.errorType}`);
  console.log(`State: ${incident.state}`);
  console.log(`Message: ${incident.errorMessage}`);
}
```

#### Operation Id

getIncident

#### Tags

Incident

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getJobErrorStatistics()

```ts
getJobErrorStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<JobErrorStatisticsQueryResult>;
```

Get error metrics for a job type

Returns aggregated metrics per error for the given jobType.

-

#### Parameters

##### input

[`JobErrorStatisticsQuery`](../type-aliases/JobErrorStatisticsQuery.md)

##### consistencyManagement

[`getJobErrorStatisticsConsistency`](../type-aliases/getJobErrorStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`JobErrorStatisticsQueryResult`](../type-aliases/JobErrorStatisticsQueryResult.md)\>

#### Example

**Get job error statistics**

```ts
async function getJobErrorStatisticsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getJobErrorStatistics(
    {
      filter: {
        from: "2025-01-01T00:00:00Z",
        to: "2025-12-31T23:59:59Z",
        jobType: "payment-processing",
      },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(`Error: ${stat.errorMessage}, workers: ${stat.workers}`);
  }
}
```

#### Operation Id

getJobErrorStatistics

#### Tags

Job

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getJobTimeSeriesStatistics()

```ts
getJobTimeSeriesStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<JobTimeSeriesStatisticsQueryResult>;
```

Get time-series metrics for a job type

Returns a list of time-bucketed metrics ordered ascending by time.
The `from` and `to` fields select the time window of interest.
Each item in the response corresponds to one time bucket of the requested resolution.

-

#### Parameters

##### input

[`JobTimeSeriesStatisticsQuery`](../type-aliases/JobTimeSeriesStatisticsQuery.md)

##### consistencyManagement

[`getJobTimeSeriesStatisticsConsistency`](../type-aliases/getJobTimeSeriesStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`JobTimeSeriesStatisticsQueryResult`](../type-aliases/JobTimeSeriesStatisticsQueryResult.md)\>

#### Example

**Get job time series statistics**

```ts
async function getJobTimeSeriesStatisticsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getJobTimeSeriesStatistics(
    {
      filter: {
        from: "2025-01-01T00:00:00Z",
        to: "2025-12-31T23:59:59Z",
        jobType: "payment-processing",
      },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const point of result.items ?? []) {
    console.log(`Time: ${point.time}, created: ${point.created.count}`);
  }
}
```

#### Operation Id

getJobTimeSeriesStatistics

#### Tags

Job

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getJobTypeStatistics()

```ts
getJobTypeStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<JobTypeStatisticsQueryResult>;
```

Get job statistics by type

Get statistics about jobs, grouped by job type.

-

#### Parameters

##### input

[`JobTypeStatisticsQuery`](../type-aliases/JobTypeStatisticsQuery.md)

##### consistencyManagement

[`getJobTypeStatisticsConsistency`](../type-aliases/getJobTypeStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`JobTypeStatisticsQueryResult`](../type-aliases/JobTypeStatisticsQueryResult.md)\>

#### Example

**Get job type statistics**

```ts
async function getJobTypeStatisticsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getJobTypeStatistics(
    {},
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(`Type: ${stat.jobType}, workers: ${stat.workers}`);
  }
}
```

#### Operation Id

getJobTypeStatistics

#### Tags

Job

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getJobWorkerStatistics()

```ts
getJobWorkerStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<JobWorkerStatisticsQueryResult>;
```

Get job statistics by worker

Get statistics about jobs, grouped by worker, for a given job type.

-

#### Parameters

##### input

[`JobWorkerStatisticsQuery`](../type-aliases/JobWorkerStatisticsQuery.md)

##### consistencyManagement

[`getJobWorkerStatisticsConsistency`](../type-aliases/getJobWorkerStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`JobWorkerStatisticsQueryResult`](../type-aliases/JobWorkerStatisticsQueryResult.md)\>

#### Example

**Get job worker statistics**

```ts
async function getJobWorkerStatisticsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getJobWorkerStatistics(
    {
      filter: {
        from: "2025-01-01T00:00:00Z",
        to: "2025-12-31T23:59:59Z",
        jobType: "payment-processing",
      },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(`Worker: ${stat.worker}, completed: ${stat.completed.count}`);
  }
}
```

#### Operation Id

getJobWorkerStatistics

#### Tags

Job

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getLicense()

```ts
getLicense(options?): CancelablePromise<LicenseResponse>;
```

Get license status

Obtains the status of the current Camunda license. *

#### Parameters

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`LicenseResponse`](../type-aliases/LicenseResponse.md)\>

#### Example

**Get license information**

```ts
async function getLicenseExample() {
  const camunda = createCamundaClient();

  const license = await camunda.getLicense();

  console.log(`License type: ${license.validLicense}`);
}
```

#### Operation Id

getLicense

#### Tags

License

---

### getMappingRule()

```ts
getMappingRule(
   input,
   consistencyManagement,
options?): CancelablePromise<MappingRuleResult>;
```

Get a mapping rule

Gets the mapping rule with the given ID.

-

#### Parameters

##### input

[`getMappingRuleInput`](../type-aliases/getMappingRuleInput.md)

##### consistencyManagement

[`getMappingRuleConsistency`](../type-aliases/getMappingRuleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MappingRuleResult`](../type-aliases/MappingRuleResult.md)\>

#### Example

**Get a mapping rule**

```ts
async function getMappingRuleExample(mappingRuleId: MappingRuleId) {
  const camunda = createCamundaClient();

  const rule = await camunda.getMappingRule(
    { mappingRuleId },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Rule: ${rule.name} (${rule.claimName}=${rule.claimValue})`);
}
```

#### Operation Id

getMappingRule

#### Tags

Mapping rule

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessDefinition()

```ts
getProcessDefinition(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessDefinitionResult>;
```

Get process definition

Returns process definition as JSON. *

#### Parameters

##### input

[`getProcessDefinitionInput`](../type-aliases/getProcessDefinitionInput.md)

##### consistencyManagement

[`getProcessDefinitionConsistency`](../type-aliases/getProcessDefinitionConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessDefinitionResult`](../type-aliases/ProcessDefinitionResult.md)\>

#### Example

**Get a process definition**

```ts
async function getProcessDefinitionExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const definition = await camunda.getProcessDefinition(
    { processDefinitionKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(
    `Process: ${definition.processDefinitionId} v${definition.version}`
  );
}
```

#### Operation Id

getProcessDefinition

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessDefinitionInstanceStatistics()

```ts
getProcessDefinitionInstanceStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessDefinitionInstanceStatisticsQueryResult>;
```

Get process instance statistics

Get statistics about process instances, grouped by process definition and tenant.

-

#### Parameters

##### input

[`ProcessDefinitionInstanceStatisticsQuery`](../type-aliases/ProcessDefinitionInstanceStatisticsQuery.md)

##### consistencyManagement

[`getProcessDefinitionInstanceStatisticsConsistency`](../type-aliases/getProcessDefinitionInstanceStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessDefinitionInstanceStatisticsQueryResult`](../type-aliases/ProcessDefinitionInstanceStatisticsQueryResult.md)\>

#### Example

**Get process definition instance statistics**

```ts
async function getProcessDefinitionInstanceStatisticsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessDefinitionInstanceStatistics(
    {},
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(
      `Definition ${stat.processDefinitionId}: ${stat.activeInstancesWithoutIncidentCount} active`
    );
  }
}
```

#### Operation Id

getProcessDefinitionInstanceStatistics

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessDefinitionInstanceVersionStatistics()

```ts
getProcessDefinitionInstanceVersionStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessDefinitionInstanceVersionStatisticsQueryResult>;
```

Get process instance statistics by version

Get statistics about process instances, grouped by version for a given process definition.
The process definition ID must be provided as a required field in the request body filter.

-

#### Parameters

##### input

[`ProcessDefinitionInstanceVersionStatisticsQuery`](../type-aliases/ProcessDefinitionInstanceVersionStatisticsQuery.md)

##### consistencyManagement

[`getProcessDefinitionInstanceVersionStatisticsConsistency`](../type-aliases/getProcessDefinitionInstanceVersionStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessDefinitionInstanceVersionStatisticsQueryResult`](../type-aliases/ProcessDefinitionInstanceVersionStatisticsQueryResult.md)\>

#### Example

**Get version statistics**

```ts
async function getProcessDefinitionInstanceVersionStatisticsExample(
  processDefinitionId: ProcessDefinitionId
) {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessDefinitionInstanceVersionStatistics(
    {
      filter: {
        processDefinitionId,
      },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(
      `Version ${stat.processDefinitionVersion}: ${stat.activeInstancesWithoutIncidentCount} active`
    );
  }
}
```

#### Operation Id

getProcessDefinitionInstanceVersionStatistics

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessDefinitionMessageSubscriptionStatistics()

```ts
getProcessDefinitionMessageSubscriptionStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>;
```

Get message subscription statistics

Get message subscription statistics, grouped by process definition.

-

#### Parameters

##### input

[`ProcessDefinitionMessageSubscriptionStatisticsQuery`](../type-aliases/ProcessDefinitionMessageSubscriptionStatisticsQuery.md)

##### consistencyManagement

[`getProcessDefinitionMessageSubscriptionStatisticsConsistency`](../type-aliases/getProcessDefinitionMessageSubscriptionStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessDefinitionMessageSubscriptionStatisticsQueryResult`](../type-aliases/ProcessDefinitionMessageSubscriptionStatisticsQueryResult.md)\>

#### Example

**Get message subscription statistics**

```ts
async function getProcessDefinitionMessageSubscriptionStatisticsExample() {
  const camunda = createCamundaClient();

  const result =
    await camunda.getProcessDefinitionMessageSubscriptionStatistics(
      {},
      { consistency: { waitUpToMs: 5000 } }
    );

  for (const stat of result.items ?? []) {
    console.log(
      `Definition ${stat.processDefinitionId}: ${stat.activeSubscriptions} subscriptions`
    );
  }
}
```

#### Operation Id

getProcessDefinitionMessageSubscriptionStatistics

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessDefinitionStatistics()

```ts
getProcessDefinitionStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessDefinitionElementStatisticsQueryResult>;
```

Get process definition statistics

Get statistics about elements in currently running process instances by process definition key and search filter. *

#### Parameters

##### input

[`getProcessDefinitionStatisticsInput`](../type-aliases/getProcessDefinitionStatisticsInput.md)

##### consistencyManagement

[`getProcessDefinitionStatisticsConsistency`](../type-aliases/getProcessDefinitionStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessDefinitionElementStatisticsQueryResult`](../type-aliases/ProcessDefinitionElementStatisticsQueryResult.md)\>

#### Example

**Get process definition element statistics**

```ts
async function getProcessDefinitionStatisticsExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessDefinitionStatistics(
    { processDefinitionKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(`Element ${stat.elementId}: active=${stat.active}`);
  }
}
```

#### Operation Id

getProcessDefinitionStatistics

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessDefinitionXml()

```ts
getProcessDefinitionXml(
   input,
   consistencyManagement,
options?): CancelablePromise<string>;
```

Get process definition XML

Returns process definition as XML. *

#### Parameters

##### input

[`getProcessDefinitionXmlInput`](../type-aliases/getProcessDefinitionXmlInput.md)

##### consistencyManagement

[`getProcessDefinitionXmlConsistency`](../type-aliases/getProcessDefinitionXmlConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`string`\>

#### Example

**Get process definition XML**

```ts
async function getProcessDefinitionXmlExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const xml = await camunda.getProcessDefinitionXml(
    { processDefinitionKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`XML length: ${JSON.stringify(xml).length}`);
}
```

#### Operation Id

getProcessDefinitionXML

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstance()

```ts
getProcessInstance(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessInstanceResult>;
```

Get process instance

Get the process instance by the process instance key. *

#### Parameters

##### input

[`getProcessInstanceInput`](../type-aliases/getProcessInstanceInput.md)

##### consistencyManagement

[`getProcessInstanceConsistency`](../type-aliases/getProcessInstanceConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessInstanceResult`](../type-aliases/ProcessInstanceResult.md)\>

#### Example

**Get a process instance**

```ts
async function getProcessInstanceExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const instance = await camunda.getProcessInstance(
    { processInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`State: ${instance.state}`);
  console.log(`Process: ${instance.processDefinitionId}`);
}
```

#### Operation Id

getProcessInstance

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstanceCallHierarchy()

```ts
getProcessInstanceCallHierarchy(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessInstanceCallHierarchyEntry[]>;
```

Get call hierarchy

Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance. *

#### Parameters

##### input

[`getProcessInstanceCallHierarchyInput`](../type-aliases/getProcessInstanceCallHierarchyInput.md)

##### consistencyManagement

[`getProcessInstanceCallHierarchyConsistency`](../type-aliases/getProcessInstanceCallHierarchyConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessInstanceCallHierarchyEntry`](../type-aliases/ProcessInstanceCallHierarchyEntry.md)[]\>

#### Example

**Get process instance call hierarchy**

```ts
async function getProcessInstanceCallHierarchyExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessInstanceCallHierarchy(
    { processInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Call hierarchy entries: ${result.length}`);
}
```

#### Operation Id

getProcessInstanceCallHierarchy

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstanceSequenceFlows()

```ts
getProcessInstanceSequenceFlows(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessInstanceSequenceFlowsQueryResult>;
```

Get sequence flows

Get sequence flows taken by the process instance. *

#### Parameters

##### input

[`getProcessInstanceSequenceFlowsInput`](../type-aliases/getProcessInstanceSequenceFlowsInput.md)

##### consistencyManagement

[`getProcessInstanceSequenceFlowsConsistency`](../type-aliases/getProcessInstanceSequenceFlowsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessInstanceSequenceFlowsQueryResult`](../type-aliases/ProcessInstanceSequenceFlowsQueryResult.md)\>

#### Example

**Get process instance sequence flows**

```ts
async function getProcessInstanceSequenceFlowsExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessInstanceSequenceFlows(
    { processInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const flow of result.items ?? []) {
    console.log(`Sequence flow: ${flow.sequenceFlowId}`);
  }
}
```

#### Operation Id

getProcessInstanceSequenceFlows

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstanceStatistics()

```ts
getProcessInstanceStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessInstanceElementStatisticsQueryResult>;
```

Get element instance statistics

Get statistics about elements by the process instance key. *

#### Parameters

##### input

[`getProcessInstanceStatisticsInput`](../type-aliases/getProcessInstanceStatisticsInput.md)

##### consistencyManagement

[`getProcessInstanceStatisticsConsistency`](../type-aliases/getProcessInstanceStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessInstanceElementStatisticsQueryResult`](../type-aliases/ProcessInstanceElementStatisticsQueryResult.md)\>

#### Example

**Get process instance statistics**

```ts
async function getProcessInstanceStatisticsExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessInstanceStatistics(
    { processInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(`Element ${stat.elementId}: active=${stat.active}`);
  }
}
```

#### Operation Id

getProcessInstanceStatistics

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstanceStatisticsByDefinition()

```ts
getProcessInstanceStatisticsByDefinition(
   input,
   consistencyManagement,
options?): CancelablePromise<IncidentProcessInstanceStatisticsByDefinitionQueryResult>;
```

Get process instance statistics by definition

Returns statistics for active process instances with incidents, grouped by process
definition. The result set is scoped to a specific incident error hash code, which must be
provided as a filter in the request body.

-

#### Parameters

##### input

[`IncidentProcessInstanceStatisticsByDefinitionQuery`](../type-aliases/IncidentProcessInstanceStatisticsByDefinitionQuery.md)

##### consistencyManagement

[`getProcessInstanceStatisticsByDefinitionConsistency`](../type-aliases/getProcessInstanceStatisticsByDefinitionConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`IncidentProcessInstanceStatisticsByDefinitionQueryResult`](../type-aliases/IncidentProcessInstanceStatisticsByDefinitionQueryResult.md)\>

#### Example

**Get instance statistics by definition**

```ts
async function getProcessInstanceStatisticsByDefinitionExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessInstanceStatisticsByDefinition(
    {
      filter: {
        errorHashCode: 12345,
      },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(
      `Definition ${stat.processDefinitionId}: ${stat.activeInstancesWithErrorCount} incidents`
    );
  }
}
```

#### Operation Id

getProcessInstanceStatisticsByDefinition

#### Tags

Incident

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstanceStatisticsByError()

```ts
getProcessInstanceStatisticsByError(
   input,
   consistencyManagement,
options?): CancelablePromise<IncidentProcessInstanceStatisticsByErrorQueryResult>;
```

Get process instance statistics by error

Returns statistics for active process instances that currently have active incidents,
grouped by incident error hash code.

-

#### Parameters

##### input

[`IncidentProcessInstanceStatisticsByErrorQuery`](../type-aliases/IncidentProcessInstanceStatisticsByErrorQuery.md)

##### consistencyManagement

[`getProcessInstanceStatisticsByErrorConsistency`](../type-aliases/getProcessInstanceStatisticsByErrorConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`IncidentProcessInstanceStatisticsByErrorQueryResult`](../type-aliases/IncidentProcessInstanceStatisticsByErrorQueryResult.md)\>

#### Example

**Get instance statistics by error**

```ts
async function getProcessInstanceStatisticsByErrorExample() {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessInstanceStatisticsByError(
    {},
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(
      `Error: ${stat.errorMessage}, count: ${stat.activeInstancesWithErrorCount}`
    );
  }
}
```

#### Operation Id

getProcessInstanceStatisticsByError

#### Tags

Incident

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getProcessInstanceWaitStateStatistics()

```ts
getProcessInstanceWaitStateStatistics(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessInstanceWaitStateStatisticsQueryResult>;
```

Get wait state statistics

Get statistics about waiting element instances by the process instance key, grouped by element id. *

#### Parameters

##### input

[`getProcessInstanceWaitStateStatisticsInput`](../type-aliases/getProcessInstanceWaitStateStatisticsInput.md)

##### consistencyManagement

[`getProcessInstanceWaitStateStatisticsConsistency`](../type-aliases/getProcessInstanceWaitStateStatisticsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessInstanceWaitStateStatisticsQueryResult`](../type-aliases/ProcessInstanceWaitStateStatisticsQueryResult.md)\>

#### Example

**Get process instance wait state statistics**

```ts
async function getProcessInstanceWaitStateStatisticsExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.getProcessInstanceWaitStateStatistics(
    { processInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const stat of result.items ?? []) {
    console.log(`Element ${stat.elementId}: waiting=${stat.waitingCount}`);
  }
}
```

#### Operation Id

getProcessInstanceWaitStateStatistics

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getResource()

```ts
getResource(
   input,
   consistencyManagement,
options?): CancelablePromise<ResourceResult>;
```

Get resource

Returns a deployed resource.
:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective APIs.
:::

-

#### Parameters

##### input

[`getResourceInput`](../type-aliases/getResourceInput.md)

##### consistencyManagement

[`getResourceConsistency`](../type-aliases/getResourceConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ResourceResult`](../type-aliases/ResourceResult.md)\>

#### Example

**Get a resource**

```ts
async function getResourceExample(resourceKey: ProcessDefinitionKey) {
  const camunda = createCamundaClient();

  const resource = await camunda.getResource(
    {
      resourceKey,
    },
    { consistency: { waitUpToMs: 0 } }
  );

  console.log(`Resource: ${resource.resourceName} (${resource.resourceId})`);
}
```

#### Operation Id

getResource

#### Tags

Resource

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### ~~getResourceContent()~~

```ts
getResourceContent(
   input,
   consistencyManagement,
   options?): CancelablePromise<{
[key: string]: unknown;
}>;
```

Get RPA resource content (deprecated)

**Deprecated** — use `/resources/{resourceKey}/content/binary` instead, which supports all
resource types and returns content as binary (octet-stream).

Returns the content of a deployed RPA resource as JSON.
:::info
This endpoint only supports RPA resources. For generic resource content in binary format,
use the `/resources/{resourceKey}/content/binary` endpoint.
:::

#### Parameters

##### input

[`getResourceContentInput`](../type-aliases/getResourceContentInput.md)

##### consistencyManagement

[`getResourceContentConsistency`](../type-aliases/getResourceContentConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
\[`key`: `string`\]: `unknown`;
\}\>

#### Deprecated

-

#### Example

**Get resource content**

```ts
async function getResourceContentExample(resourceKey: ProcessDefinitionKey) {
  const camunda = createCamundaClient();

  const content = await camunda.getResourceContent(
    {
      resourceKey,
    },
    { consistency: { waitUpToMs: 0 } }
  );

  console.log(`Content retrieved (type: ${typeof content})`);
}
```

#### Operation Id

getResourceContent

#### Tags

Resource

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getResourceContentBinary()

```ts
getResourceContentBinary(
   input,
   consistencyManagement,
options?): CancelablePromise<Blob>;
```

Get resource content as binary

Returns the content of a deployed resource in binary format (octet-stream).
:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective APIs.
:::

-

#### Parameters

##### input

[`getResourceContentBinaryInput`](../type-aliases/getResourceContentBinaryInput.md)

##### consistencyManagement

[`getResourceContentBinaryConsistency`](../type-aliases/getResourceContentBinaryConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`Blob`\>

#### Example

**Get resource content as binary**

```ts
async function getResourceContentBinaryExample(
  resourceKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const content = await camunda.getResourceContentBinary(
    {
      resourceKey,
    },
    { consistency: { waitUpToMs: 0 } }
  );

  console.log(`Binary content retrieved (type: ${typeof content})`);
}
```

#### Operation Id

getResourceContentBinary

#### Tags

Resource

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getRole()

```ts
getRole(
   input,
   consistencyManagement,
options?): CancelablePromise<RoleResult>;
```

Get role

Get a role by its ID. *

#### Parameters

##### input

[`getRoleInput`](../type-aliases/getRoleInput.md)

##### consistencyManagement

[`getRoleConsistency`](../type-aliases/getRoleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleResult`](../type-aliases/RoleResult.md)\>

#### Example

**Get a role**

```ts
async function getRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  const role = await camunda.getRole(
    { roleId },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Role: ${role.name}`);
}
```

#### Operation Id

getRole

#### Tags

Role

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getStartProcessForm()

```ts
getStartProcessForm(
   input,
   consistencyManagement,
options?): CancelablePromise<void | FormResult>;
```

Get process start form

Get the start form of a process.
Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.

-

#### Parameters

##### input

[`getStartProcessFormInput`](../type-aliases/getStartProcessFormInput.md)

##### consistencyManagement

[`getStartProcessFormConsistency`](../type-aliases/getStartProcessFormConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void` \| [`FormResult`](../type-aliases/FormResult.md)\>

#### Example

**Get start process form**

```ts
async function getStartProcessFormExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const form = await camunda.getStartProcessForm(
    { processDefinitionKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  if (form) {
    console.log(`Form key: ${form.formKey}`);
  }
}
```

#### Operation Id

getStartProcessForm

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getStatus()

```ts
getStatus(options?): CancelablePromise<void>;
```

Get cluster status

Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader. *

#### Parameters

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Check cluster status**

```ts
async function getStatusExample() {
  const camunda = createCamundaClient();

  await camunda.getStatus();

  console.log("Cluster is healthy");
}
```

#### Operation Id

getStatus

#### Tags

Cluster

---

### getSystemConfiguration()

```ts
getSystemConfiguration(options?): CancelablePromise<SystemConfigurationResponse>;
```

System configuration (alpha)

Returns the current system configuration. The response is an envelope
that groups settings by feature area.

This endpoint is an alpha feature and may be subject to change
in future releases.

-

#### Parameters

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`SystemConfigurationResponse`](../type-aliases/SystemConfigurationResponse.md)\>

#### Example

**Get system configuration**

```ts
async function getSystemConfigurationExample() {
  const camunda = createCamundaClient();

  const config = await camunda.getSystemConfiguration();

  console.log(`Configuration loaded: ${JSON.stringify(config)}`);
}
```

#### Operation Id

getSystemConfiguration

#### Tags

System

---

### getTenant()

```ts
getTenant(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantResult>;
```

Get tenant

Retrieves a single tenant by tenant ID. *

#### Parameters

##### input

[`getTenantInput`](../type-aliases/getTenantInput.md)

##### consistencyManagement

[`getTenantConsistency`](../type-aliases/getTenantConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantResult`](../type-aliases/TenantResult.md)\>

#### Example

**Get a tenant**

```ts
async function getTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const tenant = await camunda.getTenant(
    { tenantId },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Tenant: ${tenant.name}`);
}
```

#### Operation Id

getTenant

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getTenantClusterVariable()

```ts
getTenantClusterVariable(
   input,
   consistencyManagement,
options?): CancelablePromise<ClusterVariableResult>;
```

Get a tenant-scoped cluster variable

Get a tenant-scoped cluster variable. *

#### Parameters

##### input

[`getTenantClusterVariableInput`](../type-aliases/getTenantClusterVariableInput.md)

##### consistencyManagement

[`getTenantClusterVariableConsistency`](../type-aliases/getTenantClusterVariableConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableResult`](../type-aliases/ClusterVariableResult.md)\>

#### Example

**Get a tenant cluster variable**

```ts
async function getTenantClusterVariableExample(
  tenantId: TenantId,
  name: ClusterVariableName
) {
  const camunda = createCamundaClient();

  const variable = await camunda.getTenantClusterVariable(
    {
      tenantId,
      name,
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`${variable.name} = ${variable.value}`);
}
```

#### Operation Id

getTenantClusterVariable

#### Tags

Cluster Variable

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getTopology()

```ts
getTopology(options?): CancelablePromise<TopologyResponse>;
```

Get cluster topology

Obtains the current topology of the cluster the gateway is part of. *

#### Parameters

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TopologyResponse`](../type-aliases/TopologyResponse.md)\>

#### Example

**Get cluster topology**

```ts
async function getTopologyExample() {
  const camunda = createCamundaClient();

  const topology = await camunda.getTopology();

  console.log(`Cluster size: ${topology.clusterSize}`);
  console.log(`Partitions: ${topology.partitionsCount}`);
  for (const broker of topology.brokers ?? []) {
    console.log(`  Broker ${broker.nodeId}: ${broker.host}:${broker.port}`);
  }
}
```

#### Operation Id

getTopology

#### Tags

Cluster

---

### getUsageMetrics()

```ts
getUsageMetrics(
   input,
   consistencyManagement,
options?): CancelablePromise<UsageMetricsResponse>;
```

Get usage metrics

Retrieve the usage metrics based on given criteria. *

#### Parameters

##### input

[`getUsageMetricsInput`](../type-aliases/getUsageMetricsInput.md)

##### consistencyManagement

[`getUsageMetricsConsistency`](../type-aliases/getUsageMetricsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UsageMetricsResponse`](../type-aliases/UsageMetricsResponse.md)\>

#### Example

**Get usage metrics**

```ts
async function getUsageMetricsExample() {
  const camunda = createCamundaClient();

  const metrics = await camunda.getUsageMetrics(
    {
      startTime: "2025-01-01T00:00:00Z",
      endTime: "2025-12-31T23:59:59Z",
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Usage metrics retrieved: ${JSON.stringify(metrics)}`);
}
```

#### Operation Id

getUsageMetrics

#### Tags

System

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getUser()

```ts
getUser(
   input,
   consistencyManagement,
options?): CancelablePromise<UserResult>;
```

Get user

Get a user by its username. *

#### Parameters

##### input

[`getUserInput`](../type-aliases/getUserInput.md)

##### consistencyManagement

[`getUserConsistency`](../type-aliases/getUserConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserResult`](../type-aliases/UserResult.md)\>

#### Example

**Get a user**

```ts
async function getUserExample(username: Username) {
  const camunda = createCamundaClient();

  const user = await camunda.getUser(
    { username },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`User: ${user.name} (${user.email})`);
}
```

#### Operation Id

getUser

#### Tags

User

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getUserTask()

```ts
getUserTask(
   input,
   consistencyManagement,
options?): CancelablePromise<UserTaskResult>;
```

Get user task

Get the user task by the user task key. *

#### Parameters

##### input

[`getUserTaskInput`](../type-aliases/getUserTaskInput.md)

##### consistencyManagement

[`getUserTaskConsistency`](../type-aliases/getUserTaskConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserTaskResult`](../type-aliases/UserTaskResult.md)\>

#### Example

**Get a user task**

```ts
async function getUserTaskExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  const task = await camunda.getUserTask(
    { userTaskKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`Task: ${task.name} (${task.state})`);
}
```

#### Operation Id

getUserTask

#### Tags

User task

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getUserTaskForm()

```ts
getUserTaskForm(
   input,
   consistencyManagement,
options?): CancelablePromise<void | FormResult>;
```

Get user task form

Get the form of a user task.
Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.

-

#### Parameters

##### input

[`getUserTaskFormInput`](../type-aliases/getUserTaskFormInput.md)

##### consistencyManagement

[`getUserTaskFormConsistency`](../type-aliases/getUserTaskFormConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void` \| [`FormResult`](../type-aliases/FormResult.md)\>

#### Example

**Get a user task form**

```ts
async function getUserTaskFormExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  const form = await camunda.getUserTaskForm(
    { userTaskKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  if (form) {
    console.log(`Form key: ${form.formKey}`);
  }
}
```

#### Operation Id

getUserTaskForm

#### Tags

User task

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getVariable()

```ts
getVariable(
   input,
   consistencyManagement,
options?): CancelablePromise<VariableResult>;
```

Get variable

Get a variable by its key.

This endpoint returns both process-level and local (element-scoped) variables.
The variable's scopeKey indicates whether it's a process-level variable or scoped to a
specific element instance. *

#### Parameters

##### input

[`getVariableInput`](../type-aliases/getVariableInput.md)

##### consistencyManagement

[`getVariableConsistency`](../type-aliases/getVariableConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`VariableResult`](../type-aliases/VariableResult.md)\>

#### Example

**Get a variable**

```ts
async function getVariableExample(variableKey: VariableKey) {
  const camunda = createCamundaClient();

  const variable = await camunda.getVariable(
    { variableKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  console.log(`${variable.name} = ${variable.value}`);
}
```

#### Operation Id

getVariable

#### Tags

Variable

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### getWorkers()

```ts
getWorkers(): any[];
```

Return a read-only snapshot of currently registered job workers.

#### Returns

`any`[]

---

### logger()

```ts
logger(scope?): Logger;
```

Access a scoped logger (internal & future user emission).

#### Parameters

##### scope?

`string`

#### Returns

[`Logger`](../../logger/interfaces/Logger.md)

---

### migrateProcessInstance()

```ts
migrateProcessInstance(input, options?): CancelablePromise<void>;
```

Migrate process instance

Migrates a process instance to a new process definition.
This request can contain multiple mapping instructions to define mapping between the active
process instance's elements and target process definition elements.

Use this to upgrade a process instance to a new version of a process or to
a different process definition, e.g. to keep your running instances up-to-date with the
latest process improvements.

-

#### Parameters

##### input

[`migrateProcessInstanceInput`](../type-aliases/migrateProcessInstanceInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Migrate a process instance**

```ts
async function migrateProcessInstanceExample(
  processInstanceKey: ProcessInstanceKey,
  targetProcessDefinitionKey: ProcessDefinitionKey,
  sourceElementId: ElementId,
  targetElementId: ElementId
) {
  const camunda = createCamundaClient();

  await camunda.migrateProcessInstance({
    processInstanceKey,
    targetProcessDefinitionKey,
    mappingInstructions: [
      {
        sourceElementId,
        targetElementId,
      },
    ],
  });
}
```

#### Operation Id

migrateProcessInstance

#### Tags

Process instance

---

### migrateProcessInstancesBatchOperation()

```ts
migrateProcessInstancesBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Migrate process instances (batch)

Migrate multiple process instances.
Since only process instances with ACTIVE state can be migrated, any given
filters for state are ignored and overridden during this batch operation.
This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`ProcessInstanceMigrationBatchOperationRequest`](../type-aliases/ProcessInstanceMigrationBatchOperationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Migrate process instances in batch**

```ts
async function migrateProcessInstancesBatchOperationExample(
  processDefinitionKey: ProcessDefinitionKey,
  targetProcessDefinitionKey: ProcessDefinitionKey,
  sourceElementId: ElementId,
  targetElementId: ElementId
) {
  const camunda = createCamundaClient();

  const result = await camunda.migrateProcessInstancesBatchOperation({
    filter: {
      processDefinitionKey,
    },
    migrationPlan: {
      targetProcessDefinitionKey,
      mappingInstructions: [
        {
          sourceElementId,
          targetElementId,
        },
      ],
    },
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

migrateProcessInstancesBatchOperation

#### Tags

Process instance

---

### modifyProcessInstance()

```ts
modifyProcessInstance(input, options?): CancelablePromise<void>;
```

Modify process instance

Modifies a running process instance.
This request can contain multiple instructions to activate an element of the process or
to terminate an active instance of an element.

Use this to repair a process instance that is stuck on an element or took an unintended path.
For example, because an external system is not available or doesn't respond as expected.

-

#### Parameters

##### input

[`modifyProcessInstanceInput`](../type-aliases/modifyProcessInstanceInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Modify a process instance**

```ts
async function modifyProcessInstanceExample(
  processInstanceKey: ProcessInstanceKey,
  elementId: ElementId,
  elementInstanceKey: ElementInstanceKey
) {
  const camunda = createCamundaClient();

  await camunda.modifyProcessInstance({
    processInstanceKey,
    activateInstructions: [{ elementId }],
    terminateInstructions: [{ elementInstanceKey }],
  });
}
```

#### Operation Id

modifyProcessInstance

#### Tags

Process instance

---

### modifyProcessInstancesBatchOperation()

```ts
modifyProcessInstancesBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Modify process instances (batch)

Modify multiple process instances.
Since only process instances with ACTIVE state can be modified, any given
filters for state are ignored and overridden during this batch operation.
In contrast to single modification operation, it is not possible to add variable instructions or modify by element key.
It is only possible to use the element id of the source and target.
This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`ProcessInstanceModificationBatchOperationRequest`](../type-aliases/ProcessInstanceModificationBatchOperationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Modify process instances in batch**

```ts
async function modifyProcessInstancesBatchOperationExample(
  processDefinitionKey: ProcessDefinitionKey,
  sourceElementId: ElementId,
  targetElementId: ElementId
) {
  const camunda = createCamundaClient();

  const result = await camunda.modifyProcessInstancesBatchOperation({
    filter: {
      processDefinitionKey,
    },
    moveInstructions: [
      {
        sourceElementId,
        targetElementId,
      },
    ],
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

modifyProcessInstancesBatchOperation

#### Tags

Process instance

---

### onAuthHeaders()

```ts
onAuthHeaders(h): void;
```

#### Parameters

##### h

(`headers`) =>
\| `Record`\<`string`, `string`\>
\| `Promise`\<`Record`\<`string`, `string`\>\>

#### Returns

`void`

---

### pinClock()

```ts
pinClock(input, options?): CancelablePromise<void>;
```

Pin internal clock (alpha)

Set a precise, static time for the Zeebe engine's internal clock.
When the clock is pinned, it remains at the specified time and does not advance.
To change the time, the clock must be pinned again with a new timestamp.

This endpoint is an alpha feature and may be subject to change
in future releases.

-

#### Parameters

##### input

[`ClockPinRequest`](../type-aliases/ClockPinRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Pin the cluster clock**

```ts
async function pinClockExample() {
  const camunda = createCamundaClient();

  await camunda.pinClock({
    timestamp: 1735689599000,
  });

  console.log("Clock pinned");
}
```

#### Operation Id

pinClock

#### Tags

Clock

---

### publishMessage()

```ts
publishMessage(input, options?): CancelablePromise<MessagePublicationResult>;
```

Publish message

Publishes a single message.
Messages are published to specific partitions computed from their correlation keys.
Messages can be buffered.
The endpoint does not wait for a correlation result.
Use the message correlation endpoint for such use cases.

-

#### Parameters

##### input

[`MessagePublicationRequest`](../type-aliases/MessagePublicationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MessagePublicationResult`](../type-aliases/MessagePublicationResult.md)\>

#### Example

**Publish a message**

```ts
async function publishMessageExample() {
  const camunda = createCamundaClient();

  await camunda.publishMessage({
    name: "order-payment-received",
    correlationKey: "ORD-12345",
    timeToLive: 60000,
    variables: {
      paymentId: "PAY-123",
    },
  });
}
```

#### Operation Id

publishMessage

#### Tags

Message

---

### resetClock()

```ts
resetClock(options?): CancelablePromise<void>;
```

Reset internal clock (alpha)

Resets the Zeebe engine's internal clock to the current system time, enabling it to tick in real-time.
This operation is useful for returning the clock to
normal behavior after it has been pinned to a specific time.

This endpoint is an alpha feature and may be subject to change
in future releases.

-

#### Parameters

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Reset the cluster clock**

```ts
async function resetClockExample() {
  const camunda = createCamundaClient();

  await camunda.resetClock();

  console.log("Clock reset");
}
```

#### Operation Id

resetClock

#### Tags

Clock

---

### resolveIncident()

```ts
resolveIncident(input, options?): CancelablePromise<void>;
```

Resolve incident

Marks the incident as resolved; most likely a call to Update job will be necessary
to reset the job's retries, followed by this call.

-

#### Parameters

##### input

[`resolveIncidentInput`](../type-aliases/resolveIncidentInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Resolve an incident**

```ts
async function resolveIncidentExample(incidentKey: IncidentKey) {
  const camunda = createCamundaClient();

  await camunda.resolveIncident({ incidentKey });
}
```

#### Operation Id

resolveIncident

#### Tags

Incident

---

### resolveIncidentsBatchOperation()

```ts
resolveIncidentsBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Resolve related incidents (batch)

Resolves multiple instances of process instances.
Since only process instances with ACTIVE state can have unresolved incidents, any given
filters for state are ignored and overridden during this batch operation.
This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`ProcessInstanceIncidentResolutionBatchOperationRequest`](../type-aliases/ProcessInstanceIncidentResolutionBatchOperationRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Resolve incidents in batch**

```ts
async function resolveIncidentsBatchOperationExample(
  processDefinitionKey: ProcessDefinitionKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.resolveIncidentsBatchOperation({
    filter: {
      processDefinitionKey,
    },
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

resolveIncidentsBatchOperation

#### Tags

Process instance

---

### resolveProcessInstanceIncidents()

```ts
resolveProcessInstanceIncidents(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Resolve related incidents

Creates a batch operation to resolve multiple incidents of a process instance. *

#### Parameters

##### input

[`resolveProcessInstanceIncidentsInput`](../type-aliases/resolveProcessInstanceIncidentsInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Resolve process instance incidents**

```ts
async function resolveProcessInstanceIncidentsExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.resolveProcessInstanceIncidents({
    processInstanceKey,
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

resolveProcessInstanceIncidents

#### Tags

Process instance

---

### resumeBatchOperation()

```ts
resumeBatchOperation(input, options?): CancelablePromise<void>;
```

Resume Batch operation

Resumes a suspended batch operation.
This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

###### batchOperationKey

[`BatchOperationKey`](../type-aliases/BatchOperationKey.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Resume a batch operation**

```ts
async function resumeBatchOperationExample(
  batchOperationKey: BatchOperationKey
) {
  const camunda = createCamundaClient();

  await camunda.resumeBatchOperation({ batchOperationKey });
}
```

#### Operation Id

resumeBatchOperation

#### Tags

Batch operation

---

### searchAgentInstanceHistory()

```ts
searchAgentInstanceHistory(
   input,
   consistencyManagement,
options?): CancelablePromise<AgentInstanceHistorySearchQueryResult>;
```

Search agent instance history

Searches the conversation history of an agent instance. Committed items
are returned by default.

-

#### Parameters

##### input

[`searchAgentInstanceHistoryInput`](../type-aliases/searchAgentInstanceHistoryInput.md)

##### consistencyManagement

[`searchAgentInstanceHistoryConsistency`](../type-aliases/searchAgentInstanceHistoryConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AgentInstanceHistorySearchQueryResult`](../type-aliases/AgentInstanceHistorySearchQueryResult.md)\>

#### Example

**Search agent instance history**

```ts
async function searchAgentInstanceHistoryExample(
  agentInstanceKey: AgentInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchAgentInstanceHistory(
    {
      agentInstanceKey,
      filter: { role: { $eq: "ASSISTANT" } },
      sort: [{ field: "producedAt", order: "ASC" }],
      page: { limit: 20 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const item of result.items ?? []) {
    console.log(`${item.historyItemKey} (${item.role})`);
  }
  console.log(`Total: ${result.page.totalItems}`);
}
```

#### Operation Id

searchAgentInstanceHistory

#### Tags

Agent instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchAgentInstances()

```ts
searchAgentInstances(
   input,
   consistencyManagement,
options?): CancelablePromise<AgentInstanceSearchQueryResult>;
```

Search agent instances

Search for agent instances based on given criteria. *

#### Parameters

##### input

[`AgentInstanceSearchQuery`](../type-aliases/AgentInstanceSearchQuery.md)

##### consistencyManagement

[`searchAgentInstancesConsistency`](../type-aliases/searchAgentInstancesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AgentInstanceSearchQueryResult`](../type-aliases/AgentInstanceSearchQueryResult.md)\>

#### Example

**Search agent instances**

```ts
async function searchAgentInstancesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchAgentInstances(
    {
      filter: { status: { $eq: "IDLE" } },
      sort: [{ field: "creationDate", order: "DESC" }],
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const instance of result.items ?? []) {
    console.log(`${instance.agentInstanceKey}: ${instance.status}`);
  }
  console.log(`Total: ${result.page.totalItems}`);
}
```

#### Operation Id

searchAgentInstances

#### Tags

Agent instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchAuditLogs()

```ts
searchAuditLogs(
   input,
   consistencyManagement,
options?): CancelablePromise<AuditLogSearchQueryResult>;
```

Search audit logs

Search for audit logs based on given criteria. *

#### Parameters

##### input

[`AuditLogSearchQueryRequest`](../type-aliases/AuditLogSearchQueryRequest.md)

##### consistencyManagement

[`searchAuditLogsConsistency`](../type-aliases/searchAuditLogsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AuditLogSearchQueryResult`](../type-aliases/AuditLogSearchQueryResult.md)\>

#### Example

**Search audit logs**

```ts
async function searchAuditLogsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchAuditLogs(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const log of result.items ?? []) {
    console.log(`${log.auditLogKey}: ${log.operationType}`);
  }
}
```

#### Operation Id

searchAuditLogs

#### Tags

Audit Log

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchAuthorizations()

```ts
searchAuthorizations(
   input,
   consistencyManagement,
options?): CancelablePromise<AuthorizationSearchResult>;
```

Search authorizations

Search for authorizations based on given criteria. *

#### Parameters

##### input

[`AuthorizationSearchQuery`](../type-aliases/AuthorizationSearchQuery.md)

##### consistencyManagement

[`searchAuthorizationsConsistency`](../type-aliases/searchAuthorizationsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AuthorizationSearchResult`](../type-aliases/AuthorizationSearchResult.md)\>

#### Example

**Search authorizations**

```ts
async function searchAuthorizationsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchAuthorizations(
    {
      filter: { ownerType: "USER" },
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const auth of result.items ?? []) {
    console.log(
      `${auth.authorizationKey}: ${auth.ownerId} - ${auth.resourceType}`
    );
  }
}
```

#### Operation Id

searchAuthorizations

#### Tags

Authorization

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchBatchOperationItems()

```ts
searchBatchOperationItems(
   input,
   consistencyManagement,
options?): CancelablePromise<BatchOperationItemSearchQueryResult>;
```

Search batch operation items

Search for batch operation items based on given criteria. *

#### Parameters

##### input

[`BatchOperationItemSearchQuery`](../type-aliases/BatchOperationItemSearchQuery.md)

##### consistencyManagement

[`searchBatchOperationItemsConsistency`](../type-aliases/searchBatchOperationItemsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationItemSearchQueryResult`](../type-aliases/BatchOperationItemSearchQueryResult.md)\>

#### Example

**Search batch operation items**

```ts
async function searchBatchOperationItemsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchBatchOperationItems(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const item of result.items ?? []) {
    console.log(`Item: ${item.itemKey} (${item.state})`);
  }
}
```

#### Operation Id

searchBatchOperationItems

#### Tags

Batch operation

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchBatchOperations()

```ts
searchBatchOperations(
   input,
   consistencyManagement,
options?): CancelablePromise<BatchOperationSearchQueryResult>;
```

Search batch operations

Search for batch operations based on given criteria. *

#### Parameters

##### input

[`BatchOperationSearchQuery`](../type-aliases/BatchOperationSearchQuery.md)

##### consistencyManagement

[`searchBatchOperationsConsistency`](../type-aliases/searchBatchOperationsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationSearchQueryResult`](../type-aliases/BatchOperationSearchQueryResult.md)\>

#### Example

**Search batch operations**

```ts
async function searchBatchOperationsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchBatchOperations(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const batch of result.items ?? []) {
    console.log(
      `${batch.batchOperationKey}: ${batch.batchOperationType} (${batch.state})`
    );
  }
}
```

#### Operation Id

searchBatchOperations

#### Tags

Batch operation

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchClientsForGroup()

```ts
searchClientsForGroup(
   input,
   consistencyManagement,
options?): CancelablePromise<GroupClientSearchResult>;
```

Search group clients

Search clients assigned to a group. *

#### Parameters

##### input

[`searchClientsForGroupInput`](../type-aliases/searchClientsForGroupInput.md)

##### consistencyManagement

[`searchClientsForGroupConsistency`](../type-aliases/searchClientsForGroupConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupClientSearchResult`](../type-aliases/GroupClientSearchResult.md)\>

#### Example

**Search clients in a group**

```ts
async function searchClientsForGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchClientsForGroup(
    { groupId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const client of result.items ?? []) {
    console.log(`Client: ${client.clientId}`);
  }
}
```

#### Operation Id

searchClientsForGroup

#### Tags

Group

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchClientsForRole()

```ts
searchClientsForRole(
   input,
   consistencyManagement,
options?): CancelablePromise<RoleClientSearchResult>;
```

Search role clients

Search clients with assigned role. *

#### Parameters

##### input

[`searchClientsForRoleInput`](../type-aliases/searchClientsForRoleInput.md)

##### consistencyManagement

[`searchClientsForRoleConsistency`](../type-aliases/searchClientsForRoleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleClientSearchResult`](../type-aliases/RoleClientSearchResult.md)\>

#### Example

**Search clients for a role**

```ts
async function searchClientsForRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchClientsForRole(
    { roleId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const client of result.items ?? []) {
    console.log(`Client: ${client.clientId}`);
  }
}
```

#### Operation Id

searchClientsForRole

#### Tags

Role

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchClientsForTenant()

```ts
searchClientsForTenant(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantClientSearchResult>;
```

Search clients for tenant

Retrieves a filtered and sorted list of clients for a specified tenant. *

#### Parameters

##### input

[`searchClientsForTenantInput`](../type-aliases/searchClientsForTenantInput.md)

##### consistencyManagement

[`searchClientsForTenantConsistency`](../type-aliases/searchClientsForTenantConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantClientSearchResult`](../type-aliases/TenantClientSearchResult.md)\>

#### Example

**Search clients for a tenant**

```ts
async function searchClientsForTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchClientsForTenant(
    { tenantId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const client of result.items ?? []) {
    console.log(`Client: ${client.clientId}`);
  }
}
```

#### Operation Id

searchClientsForTenant

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchClusterVariables()

```ts
searchClusterVariables(
   input,
   consistencyManagement,
options?): CancelablePromise<ClusterVariableSearchQueryResult>;
```

Search for cluster variables based on given criteria. By default, long variable values in the response are truncated. *

#### Parameters

##### input

[`searchClusterVariablesInput`](../type-aliases/searchClusterVariablesInput.md)

##### consistencyManagement

[`searchClusterVariablesConsistency`](../type-aliases/searchClusterVariablesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableSearchQueryResult`](../type-aliases/ClusterVariableSearchQueryResult.md)\>

#### Example

**Search cluster variables**

```ts
async function searchClusterVariablesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchClusterVariables(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const variable of result.items ?? []) {
    console.log(`${variable.name} = ${variable.value}`);
  }
}
```

#### Operation Id

searchClusterVariables

#### Tags

Cluster Variable

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchCorrelatedMessageSubscriptions()

```ts
searchCorrelatedMessageSubscriptions(
   input,
   consistencyManagement,
options?): CancelablePromise<CorrelatedMessageSubscriptionSearchQueryResult>;
```

Search correlated message subscriptions

Search correlated message subscriptions based on given criteria. *

#### Parameters

##### input

[`CorrelatedMessageSubscriptionSearchQuery`](../type-aliases/CorrelatedMessageSubscriptionSearchQuery.md)

##### consistencyManagement

[`searchCorrelatedMessageSubscriptionsConsistency`](../type-aliases/searchCorrelatedMessageSubscriptionsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`CorrelatedMessageSubscriptionSearchQueryResult`](../type-aliases/CorrelatedMessageSubscriptionSearchQueryResult.md)\>

#### Example

**Search correlated message subscriptions**

```ts
async function searchCorrelatedMessageSubscriptionsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchCorrelatedMessageSubscriptions(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const sub of result.items ?? []) {
    console.log(`Correlated subscription: ${sub.messageName}`);
  }
}
```

#### Operation Id

searchCorrelatedMessageSubscriptions

#### Tags

Message subscription

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchDecisionDefinitions()

```ts
searchDecisionDefinitions(
   input,
   consistencyManagement,
options?): CancelablePromise<DecisionDefinitionSearchQueryResult>;
```

Search decision definitions

Search for decision definitions based on given criteria. *

#### Parameters

##### input

[`DecisionDefinitionSearchQuery`](../type-aliases/DecisionDefinitionSearchQuery.md)

##### consistencyManagement

[`searchDecisionDefinitionsConsistency`](../type-aliases/searchDecisionDefinitionsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DecisionDefinitionSearchQueryResult`](../type-aliases/DecisionDefinitionSearchQueryResult.md)\>

#### Example

**Search decision definitions**

```ts
async function searchDecisionDefinitionsExample(
  decisionDefinitionId: DecisionDefinitionId
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchDecisionDefinitions(
    {
      filter: { decisionDefinitionId },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const definition of result.items ?? []) {
    console.log(`${definition.decisionDefinitionId} v${definition.version}`);
  }
}
```

#### Operation Id

searchDecisionDefinitions

#### Tags

Decision definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchDecisionInstances()

```ts
searchDecisionInstances(
   input,
   consistencyManagement,
options?): CancelablePromise<DecisionInstanceSearchQueryResult>;
```

Search decision instances

Search for decision instances based on given criteria. *

#### Parameters

##### input

[`DecisionInstanceSearchQuery`](../type-aliases/DecisionInstanceSearchQuery.md)

##### consistencyManagement

[`searchDecisionInstancesConsistency`](../type-aliases/searchDecisionInstancesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DecisionInstanceSearchQueryResult`](../type-aliases/DecisionInstanceSearchQueryResult.md)\>

#### Example

**Search decision instances**

```ts
async function searchDecisionInstancesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchDecisionInstances(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const instance of result.items ?? []) {
    console.log(
      `${instance.decisionEvaluationKey}: ${instance.decisionDefinitionId}`
    );
  }
}
```

#### Operation Id

searchDecisionInstances

#### Tags

Decision instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchDecisionRequirements()

```ts
searchDecisionRequirements(
   input,
   consistencyManagement,
options?): CancelablePromise<DecisionRequirementsSearchQueryResult>;
```

Search decision requirements

Search for decision requirements based on given criteria. *

#### Parameters

##### input

[`DecisionRequirementsSearchQuery`](../type-aliases/DecisionRequirementsSearchQuery.md)

##### consistencyManagement

[`searchDecisionRequirementsConsistency`](../type-aliases/searchDecisionRequirementsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`DecisionRequirementsSearchQueryResult`](../type-aliases/DecisionRequirementsSearchQueryResult.md)\>

#### Example

**Search decision requirements**

```ts
async function searchDecisionRequirementsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchDecisionRequirements(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const req of result.items ?? []) {
    console.log(
      `${req.decisionRequirementsKey}: ${req.decisionRequirementsId}`
    );
  }
}
```

#### Operation Id

searchDecisionRequirements

#### Tags

Decision requirements

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchElementInstanceIncidents()

```ts
searchElementInstanceIncidents(
   input,
   consistencyManagement,
options?): CancelablePromise<IncidentSearchQueryResult>;
```

Search for incidents of a specific element instance

Search for incidents caused by the specified element instance, including incidents of any child instances created from this element instance.

Although the `elementInstanceKey` is provided as a path parameter to indicate the root element instance,
you may also include an `elementInstanceKey` within the filter object to narrow results to specific
child element instances. This is useful, for example, if you want to isolate incidents associated with
nested or subordinate elements within the given element instance while excluding incidents directly tied
to the root element itself.

-

#### Parameters

##### input

[`searchElementInstanceIncidentsInput`](../type-aliases/searchElementInstanceIncidentsInput.md)

##### consistencyManagement

[`searchElementInstanceIncidentsConsistency`](../type-aliases/searchElementInstanceIncidentsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`IncidentSearchQueryResult`](../type-aliases/IncidentSearchQueryResult.md)\>

#### Example

**Search element instance incidents**

```ts
async function searchElementInstanceIncidentsExample(
  elementInstanceKey: ElementInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchElementInstanceIncidents(
    { elementInstanceKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const incident of result.items ?? []) {
    console.log(`Incident: ${incident.errorType}`);
  }
}
```

#### Operation Id

searchElementInstanceIncidents

#### Tags

Element instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchElementInstances()

```ts
searchElementInstances(
   input,
   consistencyManagement,
options?): CancelablePromise<ElementInstanceSearchQueryResult>;
```

Search element instances

Search for element instances based on given criteria. *

#### Parameters

##### input

[`ElementInstanceSearchQuery`](../type-aliases/ElementInstanceSearchQuery.md)

##### consistencyManagement

[`searchElementInstancesConsistency`](../type-aliases/searchElementInstancesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ElementInstanceSearchQueryResult`](../type-aliases/ElementInstanceSearchQueryResult.md)\>

#### Example

**Search element instances**

```ts
async function searchElementInstancesExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchElementInstances(
    {
      filter: {
        processInstanceKey,
      },
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const element of result.items ?? []) {
    console.log(`${element.elementId}: ${element.type} (${element.state})`);
  }
}
```

#### Operation Id

searchElementInstances

#### Tags

Element instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchElementInstanceWaitStates()

```ts
searchElementInstanceWaitStates(
   input,
   consistencyManagement,
options?): CancelablePromise<ElementInstanceWaitStateQueryResult>;
```

Search element instance wait states

Returns the wait states for element instances matching the given filter.

-

#### Parameters

##### input

[`ElementInstanceWaitStateQuery`](../type-aliases/ElementInstanceWaitStateQuery.md)

##### consistencyManagement

[`searchElementInstanceWaitStatesConsistency`](../type-aliases/searchElementInstanceWaitStatesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ElementInstanceWaitStateQueryResult`](../type-aliases/ElementInstanceWaitStateQueryResult.md)\>

#### Example

**Search element instance wait states**

```ts
async function searchElementInstanceWaitStatesExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchElementInstanceWaitStates(
    {
      filter: {
        processInstanceKey,
      },
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const waitState of result.items ?? []) {
    const { details } = waitState;
    let description: string;
    if (details.waitStateType === "JOB") {
      description = `waiting on job '${details.jobType}'`;
    } else if (details.waitStateType === "MESSAGE") {
      description = `waiting for message '${details.messageName}'`;
    } else {
      description = `waiting (${details.waitStateType})`;
    }
    console.log(`${waitState.elementId}: ${description}`);
  }
}
```

#### Operation Id

searchElementInstanceWaitStates

#### Tags

Element instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchGlobalTaskListeners()

```ts
searchGlobalTaskListeners(
   input,
   consistencyManagement,
options?): CancelablePromise<GlobalTaskListenerSearchQueryResult>;
```

Search global user task listeners

Search for global user task listeners based on given criteria. *

#### Parameters

##### input

[`GlobalTaskListenerSearchQueryRequest`](../type-aliases/GlobalTaskListenerSearchQueryRequest.md)

##### consistencyManagement

[`searchGlobalTaskListenersConsistency`](../type-aliases/searchGlobalTaskListenersConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GlobalTaskListenerSearchQueryResult`](../type-aliases/GlobalTaskListenerSearchQueryResult.md)\>

#### Example

**Search global task listeners**

```ts
async function searchGlobalTaskListenersExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchGlobalTaskListeners(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const listener of result.items ?? []) {
    console.log(`${listener.id}: ${listener.type} (${listener.eventTypes})`);
  }
}
```

#### Operation Id

searchGlobalTaskListeners

#### Tags

Global listener

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchGroupIdsForTenant()

```ts
searchGroupIdsForTenant(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantGroupSearchResult>;
```

Search groups for tenant

Retrieves a filtered and sorted list of groups for a specified tenant. *

#### Parameters

##### input

[`searchGroupIdsForTenantInput`](../type-aliases/searchGroupIdsForTenantInput.md)

##### consistencyManagement

[`searchGroupIdsForTenantConsistency`](../type-aliases/searchGroupIdsForTenantConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantGroupSearchResult`](../type-aliases/TenantGroupSearchResult.md)\>

#### Example

**Search groups for a tenant**

```ts
async function searchGroupIdsForTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchGroupIdsForTenant(
    { tenantId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const group of result.items ?? []) {
    console.log(`Group: ${group.groupId}`);
  }
}
```

#### Operation Id

searchGroupIdsForTenant

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchGroups()

```ts
searchGroups(
   input,
   consistencyManagement,
options?): CancelablePromise<GroupSearchQueryResult>;
```

Search groups

Search for groups based on given criteria. *

#### Parameters

##### input

[`GroupSearchQueryRequest`](../type-aliases/GroupSearchQueryRequest.md)

##### consistencyManagement

[`searchGroupsConsistency`](../type-aliases/searchGroupsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupSearchQueryResult`](../type-aliases/GroupSearchQueryResult.md)\>

#### Example

**Search groups**

```ts
async function searchGroupsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchGroups(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const group of result.items ?? []) {
    console.log(`${group.groupId}: ${group.name}`);
  }
}
```

#### Operation Id

searchGroups

#### Tags

Group

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchGroupsForRole()

```ts
searchGroupsForRole(
   input,
   consistencyManagement,
options?): CancelablePromise<RoleGroupSearchResult>;
```

Search role groups

Search groups with assigned role. *

#### Parameters

##### input

[`searchGroupsForRoleInput`](../type-aliases/searchGroupsForRoleInput.md)

##### consistencyManagement

[`searchGroupsForRoleConsistency`](../type-aliases/searchGroupsForRoleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleGroupSearchResult`](../type-aliases/RoleGroupSearchResult.md)\>

#### Example

**Search groups for a role**

```ts
async function searchGroupsForRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchGroupsForRole(
    { roleId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const group of result.items ?? []) {
    console.log(`Group: ${group.groupId}`);
  }
}
```

#### Operation Id

searchGroupsForRole

#### Tags

Role

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchIncidents()

```ts
searchIncidents(
   input,
   consistencyManagement,
options?): CancelablePromise<IncidentSearchQueryResult>;
```

Search incidents

Search for incidents based on given criteria.

-

#### Parameters

##### input

[`IncidentSearchQuery`](../type-aliases/IncidentSearchQuery.md)

##### consistencyManagement

[`searchIncidentsConsistency`](../type-aliases/searchIncidentsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`IncidentSearchQueryResult`](../type-aliases/IncidentSearchQueryResult.md)\>

#### Example

**Search incidents**

```ts
async function searchIncidentsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchIncidents(
    {
      filter: { state: "ACTIVE" },
      sort: [{ field: "creationTime", order: "DESC" }],
      page: { limit: 20 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const incident of result.items ?? []) {
    console.log(
      `${incident.incidentKey}: ${incident.errorType} — ${incident.errorMessage}`
    );
  }
  console.log(`Total active incidents: ${result.page.totalItems}`);
}
```

#### Operation Id

searchIncidents

#### Tags

Incident

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchJobs()

```ts
searchJobs(
   input,
   consistencyManagement,
options?): CancelablePromise<JobSearchQueryResult>;
```

Search jobs

Search for jobs based on given criteria. *

#### Parameters

##### input

[`JobSearchQuery`](../type-aliases/JobSearchQuery.md)

##### consistencyManagement

[`searchJobsConsistency`](../type-aliases/searchJobsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`JobSearchQueryResult`](../type-aliases/JobSearchQueryResult.md)\>

#### Example

**Search jobs**

```ts
async function searchJobsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchJobs(
    {
      filter: { type: "payment-processing", state: "CREATED" },
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const job of result.items ?? []) {
    console.log(`Job ${job.jobKey}: ${job.type} (${job.state})`);
  }
}
```

#### Operation Id

searchJobs

#### Tags

Job

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchMappingRule()

```ts
searchMappingRule(
   input,
   consistencyManagement,
options?): CancelablePromise<MappingRuleSearchQueryResult>;
```

Search mapping rules

Search for mapping rules based on given criteria.

-

#### Parameters

##### input

[`MappingRuleSearchQueryRequest`](../type-aliases/MappingRuleSearchQueryRequest.md)

##### consistencyManagement

[`searchMappingRuleConsistency`](../type-aliases/searchMappingRuleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MappingRuleSearchQueryResult`](../type-aliases/MappingRuleSearchQueryResult.md)\>

#### Example

**Search mapping rules**

```ts
async function searchMappingRulesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchMappingRule(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const rule of result.items ?? []) {
    console.log(`${rule.mappingRuleId}: ${rule.name}`);
  }
}
```

#### Operation Id

searchMappingRule

#### Tags

Mapping rule

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchMappingRulesForGroup()

```ts
searchMappingRulesForGroup(
   input,
   consistencyManagement,
options?): CancelablePromise<GroupMappingRuleSearchResult>;
```

Search group mapping rules

Search mapping rules assigned to a group. *

#### Parameters

##### input

[`searchMappingRulesForGroupInput`](../type-aliases/searchMappingRulesForGroupInput.md)

##### consistencyManagement

[`searchMappingRulesForGroupConsistency`](../type-aliases/searchMappingRulesForGroupConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupMappingRuleSearchResult`](../type-aliases/GroupMappingRuleSearchResult.md)\>

#### Example

**Search mapping rules for a group**

```ts
async function searchMappingRulesForGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchMappingRulesForGroup(
    { groupId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const rule of result.items ?? []) {
    console.log(`Mapping rule: ${rule.name}`);
  }
}
```

#### Operation Id

searchMappingRulesForGroup

#### Tags

Group

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchMappingRulesForRole()

```ts
searchMappingRulesForRole(
   input,
   consistencyManagement,
options?): CancelablePromise<RoleMappingRuleSearchResult>;
```

Search role mapping rules

Search mapping rules with assigned role. *

#### Parameters

##### input

[`searchMappingRulesForRoleInput`](../type-aliases/searchMappingRulesForRoleInput.md)

##### consistencyManagement

[`searchMappingRulesForRoleConsistency`](../type-aliases/searchMappingRulesForRoleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleMappingRuleSearchResult`](../type-aliases/RoleMappingRuleSearchResult.md)\>

#### Example

**Search mapping rules for a role**

```ts
async function searchMappingRulesForRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchMappingRulesForRole(
    { roleId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const rule of result.items ?? []) {
    console.log(`Mapping rule: ${rule.name}`);
  }
}
```

#### Operation Id

searchMappingRulesForRole

#### Tags

Role

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchMappingRulesForTenant()

```ts
searchMappingRulesForTenant(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantMappingRuleSearchResult>;
```

Search mapping rules for tenant

Retrieves a filtered and sorted list of MappingRules for a specified tenant. *

#### Parameters

##### input

[`searchMappingRulesForTenantInput`](../type-aliases/searchMappingRulesForTenantInput.md)

##### consistencyManagement

[`searchMappingRulesForTenantConsistency`](../type-aliases/searchMappingRulesForTenantConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantMappingRuleSearchResult`](../type-aliases/TenantMappingRuleSearchResult.md)\>

#### Example

**Search mapping rules for a tenant**

```ts
async function searchMappingRulesForTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchMappingRulesForTenant(
    { tenantId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const rule of result.items ?? []) {
    console.log(`Mapping rule: ${rule.name}`);
  }
}
```

#### Operation Id

searchMappingRulesForTenant

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchMessageSubscriptions()

```ts
searchMessageSubscriptions(
   input,
   consistencyManagement,
options?): CancelablePromise<MessageSubscriptionSearchQueryResult>;
```

Search message subscriptions

Search for message subscriptions based on given criteria.

By default, both start and intermediate event subscriptions are returned. Use the
`messageSubscriptionType` filter to restrict results to a single type.

**Version notes:**

- Start event subscriptions are only captured for deployments made with 8.10 or later.
- The `messageSubscriptionType` field is only populated for data created
  with Camunda 8.10 or later. For pre-8.10 data, intermediate event entries have no
  `messageSubscriptionType` value stored. For convenience, the API returns `PROCESS_EVENT`
  as a default for such search results, though.
- Searching for intermediate event subscriptions **including legacy data** can be achieved
  by filtering for `messageSubscriptionType` not matching `START_EVENT`.

*

#### Parameters

##### input

[`MessageSubscriptionSearchQuery`](../type-aliases/MessageSubscriptionSearchQuery.md)

##### consistencyManagement

[`searchMessageSubscriptionsConsistency`](../type-aliases/searchMessageSubscriptionsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MessageSubscriptionSearchQueryResult`](../type-aliases/MessageSubscriptionSearchQueryResult.md)\>

#### Example

**Search message subscriptions**

```ts
async function searchMessageSubscriptionsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchMessageSubscriptions(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const sub of result.items ?? []) {
    console.log(`Subscription: ${sub.messageName}`);
  }
}
```

#### Operation Id

searchMessageSubscriptions

#### Tags

Message subscription

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchProcessDefinitions()

```ts
searchProcessDefinitions(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessDefinitionSearchQueryResult>;
```

Search process definitions

Search for process definitions based on given criteria. *

#### Parameters

##### input

[`ProcessDefinitionSearchQuery`](../type-aliases/ProcessDefinitionSearchQuery.md)

##### consistencyManagement

[`searchProcessDefinitionsConsistency`](../type-aliases/searchProcessDefinitionsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessDefinitionSearchQueryResult`](../type-aliases/ProcessDefinitionSearchQueryResult.md)\>

#### Example

**Search process definitions**

```ts
async function searchProcessDefinitionsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchProcessDefinitions(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const def of result.items ?? []) {
    console.log(
      `${def.processDefinitionKey}: ${def.processDefinitionId} v${def.version}`
    );
  }
}
```

#### Operation Id

searchProcessDefinitions

#### Tags

Process definition

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchProcessInstanceIncidents()

```ts
searchProcessInstanceIncidents(
   input,
   consistencyManagement,
options?): CancelablePromise<IncidentSearchQueryResult>;
```

Search related incidents

Search for incidents caused by the process instance or any of its called process or decision instances.

Although the `processInstanceKey` is provided as a path parameter to indicate the root process instance,
you may also include a `processInstanceKey` within the filter object to narrow results to specific
child process instances. This is useful, for example, if you want to isolate incidents associated with
subprocesses or called processes under the root instance while excluding incidents directly tied to the root.

-

#### Parameters

##### input

[`searchProcessInstanceIncidentsInput`](../type-aliases/searchProcessInstanceIncidentsInput.md)

##### consistencyManagement

[`searchProcessInstanceIncidentsConsistency`](../type-aliases/searchProcessInstanceIncidentsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`IncidentSearchQueryResult`](../type-aliases/IncidentSearchQueryResult.md)\>

#### Example

**Search process instance incidents**

```ts
async function searchProcessInstanceIncidentsExample(
  processInstanceKey: ProcessInstanceKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchProcessInstanceIncidents(
    {
      processInstanceKey,
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const incident of result.items ?? []) {
    console.log(`Incident: ${incident.errorType} - ${incident.errorMessage}`);
  }
}
```

#### Operation Id

searchProcessInstanceIncidents

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchProcessInstances()

```ts
searchProcessInstances(
   input,
   consistencyManagement,
options?): CancelablePromise<ProcessInstanceSearchQueryResult>;
```

Search process instances

Search for process instances based on given criteria. *

#### Parameters

##### input

[`ProcessInstanceSearchQuery`](../type-aliases/ProcessInstanceSearchQuery.md)

##### consistencyManagement

[`searchProcessInstancesConsistency`](../type-aliases/searchProcessInstancesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ProcessInstanceSearchQueryResult`](../type-aliases/ProcessInstanceSearchQueryResult.md)\>

#### Example

**Search process instances**

```ts
async function searchProcessInstancesExample(
  processDefinitionId: ProcessDefinitionId
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchProcessInstances(
    {
      filter: { processDefinitionId },
      sort: [{ field: "startDate", order: "DESC" }],
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const instance of result.items ?? []) {
    console.log(`${instance.processInstanceKey}: ${instance.state}`);
  }
  console.log(`Total: ${result.page.totalItems}`);
}
```

#### Operation Id

searchProcessInstances

#### Tags

Process instance

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchResources()

```ts
searchResources(
   input,
   consistencyManagement,
options?): CancelablePromise<ResourceSearchQueryResult>;
```

Search resources

Search for deployed resources based on given criteria.
:::info
This endpoint does not return BPMN process definitions, DMN decision definitions, or form
resources. To query BPMN process definitions or DMN decision definitions, use their
respective search APIs.
:::

-

#### Parameters

##### input

[`ResourceSearchQuery`](../type-aliases/ResourceSearchQuery.md)

##### consistencyManagement

[`searchResourcesConsistency`](../type-aliases/searchResourcesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ResourceSearchQueryResult`](../type-aliases/ResourceSearchQueryResult.md)\>

#### Example

**Search resources**

```ts
async function searchResourcesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchResources(
    { page: { limit: 10 } },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const resource of result.items ?? []) {
    console.log(`Resource: ${resource.resourceName}`);
  }
}
```

#### Operation Id

searchResources

#### Tags

Resource

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchRoles()

```ts
searchRoles(
   input,
   consistencyManagement,
options?): CancelablePromise<RoleSearchQueryResult>;
```

Search roles

Search for roles based on given criteria. *

#### Parameters

##### input

[`RoleSearchQueryRequest`](../type-aliases/RoleSearchQueryRequest.md)

##### consistencyManagement

[`searchRolesConsistency`](../type-aliases/searchRolesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleSearchQueryResult`](../type-aliases/RoleSearchQueryResult.md)\>

#### Example

**Search roles**

```ts
async function searchRolesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchRoles(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const role of result.items ?? []) {
    console.log(`${role.roleId}: ${role.name}`);
  }
}
```

#### Operation Id

searchRoles

#### Tags

Role

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchRolesForGroup()

```ts
searchRolesForGroup(
   input,
   consistencyManagement,
options?): CancelablePromise<GroupRoleSearchResult>;
```

Search group roles

Search roles assigned to a group. *

#### Parameters

##### input

[`searchRolesForGroupInput`](../type-aliases/searchRolesForGroupInput.md)

##### consistencyManagement

[`searchRolesForGroupConsistency`](../type-aliases/searchRolesForGroupConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupRoleSearchResult`](../type-aliases/GroupRoleSearchResult.md)\>

#### Example

**Search roles for a group**

```ts
async function searchRolesForGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchRolesForGroup(
    { groupId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const role of result.items ?? []) {
    console.log(`Role: ${role.name}`);
  }
}
```

#### Operation Id

searchRolesForGroup

#### Tags

Group

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchRolesForTenant()

```ts
searchRolesForTenant(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantRoleSearchResult>;
```

Search roles for tenant

Retrieves a filtered and sorted list of roles for a specified tenant. *

#### Parameters

##### input

[`searchRolesForTenantInput`](../type-aliases/searchRolesForTenantInput.md)

##### consistencyManagement

[`searchRolesForTenantConsistency`](../type-aliases/searchRolesForTenantConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantRoleSearchResult`](../type-aliases/TenantRoleSearchResult.md)\>

#### Example

**Search roles for a tenant**

```ts
async function searchRolesForTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchRolesForTenant(
    { tenantId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const role of result.items ?? []) {
    console.log(`Role: ${role.name}`);
  }
}
```

#### Operation Id

searchRolesForTenant

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchTenants()

```ts
searchTenants(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantSearchQueryResult>;
```

Search tenants

Retrieves a filtered and sorted list of tenants. *

#### Parameters

##### input

[`TenantSearchQueryRequest`](../type-aliases/TenantSearchQueryRequest.md)

##### consistencyManagement

[`searchTenantsConsistency`](../type-aliases/searchTenantsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantSearchQueryResult`](../type-aliases/TenantSearchQueryResult.md)\>

#### Example

**Search tenants**

```ts
async function searchTenantsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchTenants(
    {
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const tenant of result.items ?? []) {
    console.log(`${tenant.tenantId}: ${tenant.name}`);
  }
}
```

#### Operation Id

searchTenants

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUsers()

```ts
searchUsers(
   input,
   consistencyManagement,
options?): CancelablePromise<UserSearchResult>;
```

Search users

Search for users based on given criteria. *

#### Parameters

##### input

[`UserSearchQueryRequest`](../type-aliases/UserSearchQueryRequest.md)

##### consistencyManagement

[`searchUsersConsistency`](../type-aliases/searchUsersConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserSearchResult`](../type-aliases/UserSearchResult.md)\>

#### Example

**Search users**

```ts
async function searchUsersExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchUsers(
    {
      filter: {},
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const user of result.items ?? []) {
    console.log(`${user.username}: ${user.name}`);
  }
}
```

#### Operation Id

searchUsers

#### Tags

User

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUsersForGroup()

```ts
searchUsersForGroup(
   input,
   consistencyManagement,
options?): CancelablePromise<GroupUserSearchResult>;
```

Search group users

Search users assigned to a group. *

#### Parameters

##### input

[`searchUsersForGroupInput`](../type-aliases/searchUsersForGroupInput.md)

##### consistencyManagement

[`searchUsersForGroupConsistency`](../type-aliases/searchUsersForGroupConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupUserSearchResult`](../type-aliases/GroupUserSearchResult.md)\>

#### Example

**Search users in a group**

```ts
async function searchUsersForGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchUsersForGroup(
    { groupId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const user of result.items ?? []) {
    console.log(`Member: ${user.username}`);
  }
}
```

#### Operation Id

searchUsersForGroup

#### Tags

Group

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUsersForRole()

```ts
searchUsersForRole(
   input,
   consistencyManagement,
options?): CancelablePromise<RoleUserSearchResult>;
```

Search role users

Search users with assigned role. *

#### Parameters

##### input

[`searchUsersForRoleInput`](../type-aliases/searchUsersForRoleInput.md)

##### consistencyManagement

[`searchUsersForRoleConsistency`](../type-aliases/searchUsersForRoleConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleUserSearchResult`](../type-aliases/RoleUserSearchResult.md)\>

#### Example

**Search users for a role**

```ts
async function searchUsersForRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchUsersForRole(
    { roleId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const user of result.items ?? []) {
    console.log(`User: ${user.username}`);
  }
}
```

#### Operation Id

searchUsersForRole

#### Tags

Role

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUsersForTenant()

```ts
searchUsersForTenant(
   input,
   consistencyManagement,
options?): CancelablePromise<TenantUserSearchResult>;
```

Search users for tenant

Retrieves a filtered and sorted list of users for a specified tenant. *

#### Parameters

##### input

[`searchUsersForTenantInput`](../type-aliases/searchUsersForTenantInput.md)

##### consistencyManagement

[`searchUsersForTenantConsistency`](../type-aliases/searchUsersForTenantConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantUserSearchResult`](../type-aliases/TenantUserSearchResult.md)\>

#### Example

**Search users for a tenant**

```ts
async function searchUsersForTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  const result = await camunda.searchUsersForTenant(
    { tenantId },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const user of result.items ?? []) {
    console.log(`Tenant member: ${user.username}`);
  }
}
```

#### Operation Id

searchUsersForTenant

#### Tags

Tenant

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUserTaskAuditLogs()

```ts
searchUserTaskAuditLogs(
   input,
   consistencyManagement,
options?): CancelablePromise<AuditLogSearchQueryResult>;
```

Search user task audit logs

Search for user task audit logs based on given criteria. *

#### Parameters

##### input

[`searchUserTaskAuditLogsInput`](../type-aliases/searchUserTaskAuditLogsInput.md)

##### consistencyManagement

[`searchUserTaskAuditLogsConsistency`](../type-aliases/searchUserTaskAuditLogsConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`AuditLogSearchQueryResult`](../type-aliases/AuditLogSearchQueryResult.md)\>

#### Example

**Search user task audit logs**

```ts
async function searchUserTaskAuditLogsExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  const result = await camunda.searchUserTaskAuditLogs(
    { userTaskKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const log of result.items ?? []) {
    console.log(`Audit: ${log.operationType} at ${log.timestamp}`);
  }
}
```

#### Operation Id

searchUserTaskAuditLogs

#### Tags

User task

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUserTaskEffectiveVariables()

```ts
searchUserTaskEffectiveVariables(
   input,
   consistencyManagement,
options?): CancelablePromise<VariableSearchQueryResult>;
```

Search user task effective variables

Search for the effective variables of a user task. This endpoint returns deduplicated
variables where each variable name appears at most once. When the same variable name exists
at multiple scope levels in the scope hierarchy, the value from the innermost scope (closest
to the user task) takes precedence. This is useful for retrieving the actual runtime state
of variables as seen by the user task. By default, long variable values in the response are
truncated.

-

#### Parameters

##### input

[`searchUserTaskEffectiveVariablesInput`](../type-aliases/searchUserTaskEffectiveVariablesInput.md)

##### consistencyManagement

[`searchUserTaskEffectiveVariablesConsistency`](../type-aliases/searchUserTaskEffectiveVariablesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`VariableSearchQueryResult`](../type-aliases/VariableSearchQueryResult.md)\>

#### Example

**Search user task effective variables**

```ts
async function searchUserTaskEffectiveVariablesExample(
  userTaskKey: UserTaskKey
) {
  const camunda = createCamundaClient();

  const result = await camunda.searchUserTaskEffectiveVariables(
    { userTaskKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const variable of result.items ?? []) {
    console.log(`${variable.name} = ${variable.value}`);
  }
}
```

#### Operation Id

searchUserTaskEffectiveVariables

#### Tags

User task

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUserTasks()

```ts
searchUserTasks(
   input,
   consistencyManagement,
options?): CancelablePromise<UserTaskSearchQueryResult>;
```

Search user tasks

Search for user tasks based on given criteria. *

#### Parameters

##### input

[`UserTaskSearchQuery`](../type-aliases/UserTaskSearchQuery.md)

##### consistencyManagement

[`searchUserTasksConsistency`](../type-aliases/searchUserTasksConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserTaskSearchQueryResult`](../type-aliases/UserTaskSearchQueryResult.md)\>

#### Example

**Search user tasks**

```ts
async function searchUserTasksExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchUserTasks(
    {
      filter: { assignee: "alice", state: "CREATED" },
      sort: [{ field: "creationDate", order: "DESC" }],
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const task of result.items ?? []) {
    console.log(`${task.userTaskKey}: ${task.name} (${task.state})`);
  }
}
```

#### Operation Id

searchUserTasks

#### Tags

User task

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchUserTaskVariables()

```ts
searchUserTaskVariables(
   input,
   consistencyManagement,
options?): CancelablePromise<VariableSearchQueryResult>;
```

Search user task variables

Search for user task variables based on given criteria. This endpoint returns all variable
documents visible from the user task's scope, including variables from parent scopes in the
scope hierarchy. If the same variable name exists at multiple scope levels, each scope's
variable is returned as a separate result. Use the
`/user-tasks/{userTaskKey}/effective-variables/search` endpoint to get deduplicated variables
where the innermost scope takes precedence. By default, long variable values in the response
are truncated.

-

#### Parameters

##### input

[`searchUserTaskVariablesInput`](../type-aliases/searchUserTaskVariablesInput.md)

##### consistencyManagement

[`searchUserTaskVariablesConsistency`](../type-aliases/searchUserTaskVariablesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`VariableSearchQueryResult`](../type-aliases/VariableSearchQueryResult.md)\>

#### Example

**Search user task variables**

```ts
async function searchUserTaskVariablesExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  const result = await camunda.searchUserTaskVariables(
    { userTaskKey },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const variable of result.items ?? []) {
    console.log(`${variable.name} = ${variable.value}`);
  }
}
```

#### Operation Id

searchUserTaskVariables

#### Tags

User task

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchVariables()

```ts
searchVariables(
   input,
   consistencyManagement,
options?): CancelablePromise<VariableSearchQueryResult>;
```

Search variables

Search for variables based on given criteria.

This endpoint returns variables that exist directly at the specified scopes - it does not
include variables from parent scopes that would be visible through the scope hierarchy.

Variables can be process-level (scoped to the process instance) or local (scoped to specific
BPMN elements like tasks, subprocesses, etc.).

By default, long variable values in the response are truncated. *

#### Parameters

##### input

[`searchVariablesInput`](../type-aliases/searchVariablesInput.md)

##### consistencyManagement

[`searchVariablesConsistency`](../type-aliases/searchVariablesConsistency.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`VariableSearchQueryResult`](../type-aliases/VariableSearchQueryResult.md)\>

#### Example

**Search variables**

```ts
async function searchVariablesExample(processInstanceKey: ProcessInstanceKey) {
  const camunda = createCamundaClient();

  const result = await camunda.searchVariables(
    {
      filter: {
        processInstanceKey,
      },
      page: { limit: 10 },
    },
    { consistency: { waitUpToMs: 5000 } }
  );

  for (const variable of result.items ?? []) {
    console.log(`${variable.name} = ${variable.value}`);
  }
}
```

#### Operation Id

searchVariables

#### Tags

Variable

#### Consistency

eventual - this endpoint is backed by data that is eventually consistent with the system state.

---

### searchVariablesAsDto()

```ts
searchVariablesAsDto<TSchema>(schema, options): CancelablePromise<VariableMap<TSchema>>;
```

Search for process variables and bind them to a Zod schema (the DTO).

The schema's keys are the exact variable names to fetch; its shape drives validation. Only
those declared variables are queried (via a `name $in [...]` filter), so memory stays bound
by the DTO shape rather than the total number of variables on the instance. Results are
paged internally until every declared variable is found or the result set is exhausted.

Returns a [VariableMap](VariableMap.md) offering lenient access (`has` / `get`) and a strict
`validate()` that parses the collected values against the schema — returning a fully-typed
object or throwing a `ZodError` when a required variable is missing or malformed.

#### Type Parameters

##### TSchema

`TSchema` _extends_ [`AnyVariableSchema`](../type-aliases/AnyVariableSchema.md)

#### Parameters

##### schema

`TSchema`

A Zod object schema declaring the variables to fetch.

##### options

Query scope. `processInstanceKey` is required; `scopeKey` narrows to a single
element-instance scope, `tenantId` filters by tenant, and `pageSize` tunes the page limit.
`consistency` controls eventual-consistency tolerance for the underlying `searchVariables`
calls: it defaults to `{ waitUpToMs: 0 }` (no waiting), but a non-zero `waitUpToMs` makes the
paging calls poll until the data is consistent, avoiding intermittent missing variables /
`ZodError` on a freshly-updated instance.

###### consistency?

\{
`pollIntervalMs?`: `number`;
`waitUpToMs`: `number`;
\}

###### consistency.pollIntervalMs?

`number`

###### consistency.waitUpToMs

`number`

###### pageSize?

`number`

###### processInstanceKey

[`ProcessInstanceKey`](../type-aliases/ProcessInstanceKey.md)

###### scopeKey?

[`ScopeKey`](../type-aliases/ScopeKey.md)

###### tenantId?

[`TenantId`](../type-aliases/TenantId.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`VariableMap`](VariableMap.md)\<`TSchema`\>\>

#### Throws

when a declared variable is found at more than one
scope and no `scopeKey` was provided to disambiguate.

#### Throws

when a variable's value is not valid JSON.

#### Example

```ts

const OrderVariables = z.object({
  orderId: z.string(),
  amount: z.number().optional(),
});
const map = await client.searchVariablesAsDto(OrderVariables, {
  processInstanceKey,
});
if (map.has("amount")) console.log(map.get("amount"));
const order = map.validate(); // { orderId: string; amount?: number }
```

---

### stopAllWorkers()

```ts
stopAllWorkers(): void;
```

Stop all registered job workers (best-effort) and terminate the shared thread pool.

#### Returns

`void`

---

### suspendBatchOperation()

```ts
suspendBatchOperation(input, options?): CancelablePromise<void>;
```

Suspend Batch operation

Suspends a running batch operation.
This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

###### batchOperationKey

[`BatchOperationKey`](../type-aliases/BatchOperationKey.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Suspend a batch operation**

```ts
async function suspendBatchOperationExample(
  batchOperationKey: BatchOperationKey
) {
  const camunda = createCamundaClient();

  await camunda.suspendBatchOperation({ batchOperationKey });
}
```

#### Operation Id

suspendBatchOperation

#### Tags

Batch operation

---

### throwJobError()

```ts
throwJobError(input, options?): CancelablePromise<void>;
```

Throw error for job

Reports a business error (i.e. non-technical) that occurs while processing a job.

-

#### Parameters

##### input

[`throwJobErrorInput`](../type-aliases/throwJobErrorInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Throw a job error**

```ts
async function throwJobErrorExample(jobKey: JobKey) {
  const camunda = createCamundaClient();

  await camunda.throwJobError({
    jobKey,
    errorCode: "PAYMENT_FAILED",
    errorMessage: "Payment provider returned error",
  });
}
```

#### Operation Id

throwJobError

#### Tags

Job

---

### unassignClientFromGroup()

```ts
unassignClientFromGroup(input, options?): CancelablePromise<void>;
```

Unassign a client from a group

Unassigns a client from a group.
The client is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.

-

#### Parameters

##### input

[`unassignClientFromGroupInput`](../type-aliases/unassignClientFromGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a client from a group**

```ts
async function unassignClientFromGroupExample(
  groupId: GroupId,
  clientId: ClientId
) {
  const camunda = createCamundaClient();

  await camunda.unassignClientFromGroup({
    groupId,
    clientId,
  });
}
```

#### Operation Id

unassignClientFromGroup

#### Tags

Group

---

### unassignClientFromTenant()

```ts
unassignClientFromTenant(input, options?): CancelablePromise<void>;
```

Unassign a client from a tenant

Unassigns the client from the specified tenant.
The client can no longer access tenant data.

-

#### Parameters

##### input

[`unassignClientFromTenantInput`](../type-aliases/unassignClientFromTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a client from a tenant**

```ts
async function unassignClientFromTenantExample(
  tenantId: TenantId,
  clientId: ClientId
) {
  const camunda = createCamundaClient();

  await camunda.unassignClientFromTenant({
    tenantId,
    clientId,
  });
}
```

#### Operation Id

unassignClientFromTenant

#### Tags

Tenant

---

### unassignGroupFromTenant()

```ts
unassignGroupFromTenant(input, options?): CancelablePromise<void>;
```

Unassign a group from a tenant

Unassigns a group from a specified tenant.
Members of the group (users, clients) will no longer have access to the tenant's data - except they are assigned directly to the tenant.

-

#### Parameters

##### input

[`unassignGroupFromTenantInput`](../type-aliases/unassignGroupFromTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a group from a tenant**

```ts
async function unassignGroupFromTenantExample(
  tenantId: TenantId,
  groupId: GroupId
) {
  const camunda = createCamundaClient();

  await camunda.unassignGroupFromTenant({
    tenantId,
    groupId,
  });
}
```

#### Operation Id

unassignGroupFromTenant

#### Tags

Tenant

---

### unassignMappingRuleFromGroup()

```ts
unassignMappingRuleFromGroup(input, options?): CancelablePromise<void>;
```

Unassign a mapping rule from a group

Unassigns a mapping rule from a group. *

#### Parameters

##### input

[`unassignMappingRuleFromGroupInput`](../type-aliases/unassignMappingRuleFromGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a mapping rule from a group**

```ts
async function unassignMappingRuleFromGroupExample(
  groupId: GroupId,
  mappingRuleId: MappingRuleId
) {
  const camunda = createCamundaClient();

  await camunda.unassignMappingRuleFromGroup({
    groupId,
    mappingRuleId,
  });
}
```

#### Operation Id

unassignMappingRuleFromGroup

#### Tags

Group

---

### unassignMappingRuleFromTenant()

```ts
unassignMappingRuleFromTenant(input, options?): CancelablePromise<void>;
```

Unassign a mapping rule from a tenant

Unassigns a single mapping rule from a specified tenant without deleting the rule. *

#### Parameters

##### input

[`unassignMappingRuleFromTenantInput`](../type-aliases/unassignMappingRuleFromTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a mapping rule from a tenant**

```ts
async function unassignMappingRuleFromTenantExample(
  tenantId: TenantId,
  mappingRuleId: MappingRuleId
) {
  const camunda = createCamundaClient();

  await camunda.unassignMappingRuleFromTenant({
    tenantId,
    mappingRuleId,
  });
}
```

#### Operation Id

unassignMappingRuleFromTenant

#### Tags

Tenant

---

### unassignRoleFromClient()

```ts
unassignRoleFromClient(input, options?): CancelablePromise<void>;
```

Unassign a role from a client

Unassigns the specified role from the client. The client will no longer inherit the authorizations associated with this role. *

#### Parameters

##### input

[`unassignRoleFromClientInput`](../type-aliases/unassignRoleFromClientInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a role from a client**

```ts
async function unassignRoleFromClientExample(
  roleId: RoleId,
  clientId: ClientId
) {
  const camunda = createCamundaClient();

  await camunda.unassignRoleFromClient({
    roleId,
    clientId,
  });
}
```

#### Operation Id

unassignRoleFromClient

#### Tags

Role

---

### unassignRoleFromGroup()

```ts
unassignRoleFromGroup(input, options?): CancelablePromise<void>;
```

Unassign a role from a group

Unassigns the specified role from the group. All group members (user or client) no longer inherit the authorizations associated with this role. *

#### Parameters

##### input

[`unassignRoleFromGroupInput`](../type-aliases/unassignRoleFromGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a role from a group**

```ts
async function unassignRoleFromGroupExample(roleId: RoleId, groupId: GroupId) {
  const camunda = createCamundaClient();

  await camunda.unassignRoleFromGroup({
    roleId,
    groupId,
  });
}
```

#### Operation Id

unassignRoleFromGroup

#### Tags

Role

---

### unassignRoleFromMappingRule()

```ts
unassignRoleFromMappingRule(input, options?): CancelablePromise<void>;
```

Unassign a role from a mapping rule

Unassigns a role from a mapping rule. *

#### Parameters

##### input

[`unassignRoleFromMappingRuleInput`](../type-aliases/unassignRoleFromMappingRuleInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a role from a mapping rule**

```ts
async function unassignRoleFromMappingRuleExample(
  roleId: RoleId,
  mappingRuleId: MappingRuleId
) {
  const camunda = createCamundaClient();

  await camunda.unassignRoleFromMappingRule({
    roleId,
    mappingRuleId,
  });
}
```

#### Operation Id

unassignRoleFromMappingRule

#### Tags

Role

---

### unassignRoleFromTenant()

```ts
unassignRoleFromTenant(input, options?): CancelablePromise<void>;
```

Unassign a role from a tenant

Unassigns a role from a specified tenant.
Users, Clients or Groups, that have the role assigned, will no longer have access to the
tenant's data - unless they are assigned directly to the tenant.

-

#### Parameters

##### input

[`unassignRoleFromTenantInput`](../type-aliases/unassignRoleFromTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a role from a tenant**

```ts
async function unassignRoleFromTenantExample(
  tenantId: TenantId,
  roleId: RoleId
) {
  const camunda = createCamundaClient();

  await camunda.unassignRoleFromTenant({
    tenantId,
    roleId,
  });
}
```

#### Operation Id

unassignRoleFromTenant

#### Tags

Tenant

---

### unassignRoleFromUser()

```ts
unassignRoleFromUser(input, options?): CancelablePromise<void>;
```

Unassign a role from a user

Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role. *

#### Parameters

##### input

[`unassignRoleFromUserInput`](../type-aliases/unassignRoleFromUserInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a role from a user**

```ts
async function unassignRoleFromUserExample(roleId: RoleId, username: Username) {
  const camunda = createCamundaClient();

  await camunda.unassignRoleFromUser({
    roleId,
    username,
  });
}
```

#### Operation Id

unassignRoleFromUser

#### Tags

Role

---

### unassignUserFromGroup()

```ts
unassignUserFromGroup(input, options?): CancelablePromise<void>;
```

Unassign a user from a group

Unassigns a user from a group.
The user is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.

-

#### Parameters

##### input

[`unassignUserFromGroupInput`](../type-aliases/unassignUserFromGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a user from a group**

```ts
async function unassignUserFromGroupExample(
  groupId: GroupId,
  username: Username
) {
  const camunda = createCamundaClient();

  await camunda.unassignUserFromGroup({
    groupId,
    username,
  });
}
```

#### Operation Id

unassignUserFromGroup

#### Tags

Group

---

### unassignUserFromTenant()

```ts
unassignUserFromTenant(input, options?): CancelablePromise<void>;
```

Unassign a user from a tenant

Unassigns the user from the specified tenant.
The user can no longer access tenant data.

-

#### Parameters

##### input

[`unassignUserFromTenantInput`](../type-aliases/unassignUserFromTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a user from a tenant**

```ts
async function unassignUserFromTenantExample(
  tenantId: TenantId,
  username: Username
) {
  const camunda = createCamundaClient();

  await camunda.unassignUserFromTenant({
    tenantId,
    username,
  });
}
```

#### Operation Id

unassignUserFromTenant

#### Tags

Tenant

---

### unassignUserTask()

```ts
unassignUserTask(input, options?): CancelablePromise<void>;
```

Unassign user task

Removes the assignee of a task with the given key. Unassignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

-

#### Parameters

##### input

[`unassignUserTaskInput`](../type-aliases/unassignUserTaskInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Unassign a user task**

```ts
async function unassignUserTaskExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  await camunda.unassignUserTask({ userTaskKey });
}
```

#### Operation Id

unassignUserTask

#### Tags

User task

---

### updateAgentInstance()

```ts
updateAgentInstance(input, options?): CancelablePromise<void>;
```

Update agent instance

Updates the mutable fields of an agent instance: status, metric counters, and
tools. Metric values are treated as deltas and applied immediately to the
aggregate counters. Tool updates replace the existing tool list.

-

#### Parameters

##### input

[`updateAgentInstanceInput`](../type-aliases/updateAgentInstanceInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Update an agent instance**

```ts
async function updateAgentInstanceExample(
  agentInstanceKey: AgentInstanceKey,
  elementInstanceKey: ElementInstanceKey
) {
  const camunda = createCamundaClient();

  await camunda.updateAgentInstance({
    agentInstanceKey,
    elementInstanceKey,
    status: "THINKING",
    metrics: {
      inputTokens: 150,
      outputTokens: 50,
      modelCalls: 1,
    },
  });

  console.log(`Updated agent instance: ${agentInstanceKey}`);
}
```

#### Operation Id

updateAgentInstance

#### Tags

Agent instance

---

### updateAuthorization()

```ts
updateAuthorization(input, options?): CancelablePromise<void>;
```

Update authorization

Update the authorization with the given key. *

#### Parameters

##### input

[`updateAuthorizationInput`](../type-aliases/updateAuthorizationInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Update an authorization**

```ts
async function updateAuthorizationExample(authorizationKey: AuthorizationKey) {
  const camunda = createCamundaClient();

  await camunda.updateAuthorization({
    authorizationKey,
    ownerId: "user-123",
    ownerType: "USER",
    resourceId: "order-process",
    resourceType: "PROCESS_DEFINITION",
    permissionTypes: [
      "CREATE_PROCESS_INSTANCE",
      "READ_PROCESS_INSTANCE",
      "DELETE_PROCESS_INSTANCE",
    ],
  });
}
```

#### Operation Id

updateAuthorization

#### Tags

Authorization

---

### updateGlobalClusterVariable()

```ts
updateGlobalClusterVariable(input, options?): CancelablePromise<ClusterVariableResult>;
```

Update a global-scoped cluster variable

Updates the value of an existing global cluster variable.
The variable must exist, otherwise a 404 error is returned.

-

#### Parameters

##### input

[`updateGlobalClusterVariableInput`](../type-aliases/updateGlobalClusterVariableInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableResult`](../type-aliases/ClusterVariableResult.md)\>

#### Example

**Update a global cluster variable**

```ts
async function updateGlobalClusterVariableExample(name: ClusterVariableName) {
  const camunda = createCamundaClient();

  await camunda.updateGlobalClusterVariable({
    name,
    value: { darkMode: false },
  });
}
```

#### Operation Id

updateGlobalClusterVariable

#### Tags

Cluster Variable

---

### updateGlobalTaskListener()

```ts
updateGlobalTaskListener(input, options?): CancelablePromise<GlobalTaskListenerResult>;
```

Update global user task listener

Updates a global user task listener. *

#### Parameters

##### input

[`updateGlobalTaskListenerInput`](../type-aliases/updateGlobalTaskListenerInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GlobalTaskListenerResult`](../type-aliases/GlobalTaskListenerResult.md)\>

#### Example

**Update a global task listener**

```ts
async function updateGlobalTaskListenerExample(id: GlobalListenerId) {
  const camunda = createCamundaClient();

  await camunda.updateGlobalTaskListener({
    id,
    eventTypes: ["completing"],
    type: "updated-audit-listener",
  });
}
```

#### Operation Id

updateGlobalTaskListener

#### Tags

Global listener

---

### updateGroup()

```ts
updateGroup(input, options?): CancelablePromise<GroupUpdateResult>;
```

Update group

Update a group with the given ID. *

#### Parameters

##### input

[`updateGroupInput`](../type-aliases/updateGroupInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`GroupUpdateResult`](../type-aliases/GroupUpdateResult.md)\>

#### Example

**Update a group**

```ts
async function updateGroupExample(groupId: GroupId) {
  const camunda = createCamundaClient();

  await camunda.updateGroup({
    groupId,
    name: "Engineering Team",
  });
}
```

#### Operation Id

updateGroup

#### Tags

Group

---

### updateJob()

```ts
updateJob(input, options?): CancelablePromise<void>;
```

Update job

Update a job with the given key. *

#### Parameters

##### input

[`updateJobInput`](../type-aliases/updateJobInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Update a job**

```ts
async function updateJobExample(jobKey: JobKey) {
  const camunda = createCamundaClient();

  await camunda.updateJob({
    jobKey,
    changeset: { retries: 5, timeout: 60000 },
  });
}
```

#### Operation Id

updateJob

#### Tags

Job

---

### updateJobsBatchOperation()

```ts
updateJobsBatchOperation(input, options?): CancelablePromise<BatchOperationCreatedResult>;
```

Update jobs (batch)

Creates a batch operation to update jobs matching the given filter. At least one changeset field must be non-null. This is done asynchronously; the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

-

#### Parameters

##### input

[`JobBatchUpdateRequest`](../type-aliases/JobBatchUpdateRequest.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`BatchOperationCreatedResult`](../type-aliases/BatchOperationCreatedResult.md)\>

#### Example

**Update jobs in batch**

```ts
async function updateJobsBatchOperationExample() {
  const camunda = createCamundaClient();

  const result = await camunda.updateJobsBatchOperation({
    filter: {
      type: "payment-processing",
      hasFailedWithRetriesLeft: false,
    },
    changeset: {
      retries: 3,
    },
  });

  console.log(`Batch operation key: ${result.batchOperationKey}`);
}
```

#### Operation Id

updateJobsBatchOperation

#### Tags

Job

---

### updateMappingRule()

```ts
updateMappingRule(input, options?): CancelablePromise<MappingRuleCreateUpdateResult>;
```

Update mapping rule

Update a mapping rule.

-

#### Parameters

##### input

[`updateMappingRuleInput`](../type-aliases/updateMappingRuleInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`MappingRuleCreateUpdateResult`](../type-aliases/MappingRuleCreateUpdateResult.md)\>

#### Example

**Update a mapping rule**

```ts
async function updateMappingRuleExample(mappingRuleId: MappingRuleId) {
  const camunda = createCamundaClient();

  await camunda.updateMappingRule({
    mappingRuleId,
    name: "LDAP Group Mapping",
    claimName: "groups",
    claimValue: "engineering-team",
  });
}
```

#### Operation Id

updateMappingRule

#### Tags

Mapping rule

---

### updateRole()

```ts
updateRole(input, options?): CancelablePromise<RoleUpdateResult>;
```

Update role

Update a role with the given ID. *

#### Parameters

##### input

[`updateRoleInput`](../type-aliases/updateRoleInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`RoleUpdateResult`](../type-aliases/RoleUpdateResult.md)\>

#### Example

**Update a role**

```ts
async function updateRoleExample(roleId: RoleId) {
  const camunda = createCamundaClient();

  await camunda.updateRole({
    roleId,
    name: "Process Administrator",
  });
}
```

#### Operation Id

updateRole

#### Tags

Role

---

### updateTenant()

```ts
updateTenant(input, options?): CancelablePromise<TenantUpdateResult>;
```

Update tenant

Updates an existing tenant. *

#### Parameters

##### input

[`updateTenantInput`](../type-aliases/updateTenantInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`TenantUpdateResult`](../type-aliases/TenantUpdateResult.md)\>

#### Example

**Update a tenant**

```ts
async function updateTenantExample(tenantId: TenantId) {
  const camunda = createCamundaClient();

  await camunda.updateTenant({
    tenantId,
    name: "Customer Service Team",
  });
}
```

#### Operation Id

updateTenant

#### Tags

Tenant

---

### updateTenantClusterVariable()

```ts
updateTenantClusterVariable(input, options?): CancelablePromise<ClusterVariableResult>;
```

Update a tenant-scoped cluster variable

Updates the value of an existing tenant-scoped cluster variable.
The variable must exist, otherwise a 404 error is returned.

-

#### Parameters

##### input

[`updateTenantClusterVariableInput`](../type-aliases/updateTenantClusterVariableInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`ClusterVariableResult`](../type-aliases/ClusterVariableResult.md)\>

#### Example

**Update a tenant cluster variable**

```ts
async function updateTenantClusterVariableExample(
  tenantId: TenantId,
  name: ClusterVariableName
) {
  const camunda = createCamundaClient();

  await camunda.updateTenantClusterVariable({
    tenantId,
    name,
    value: { region: "eu-west-1" },
  });
}
```

#### Operation Id

updateTenantClusterVariable

#### Tags

Cluster Variable

---

### updateUser()

```ts
updateUser(input, options?): CancelablePromise<UserUpdateResult>;
```

Update user

Updates a user. *

#### Parameters

##### input

[`updateUserInput`](../type-aliases/updateUserInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<[`UserUpdateResult`](../type-aliases/UserUpdateResult.md)\>

#### Example

**Update a user**

```ts
async function updateUserExample(username: Username) {
  const camunda = createCamundaClient();

  await camunda.updateUser({
    username,
    name: "Alice Jones",
    email: "alice.jones@example.com",
  });
}
```

#### Operation Id

updateUser

#### Tags

User

---

### updateUserTask()

```ts
updateUserTask(input, options?): CancelablePromise<void>;
```

Update user task

Update a user task with the given key. Updates wait for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

-

#### Parameters

##### input

[`updateUserTaskInput`](../type-aliases/updateUserTaskInput.md)

##### options?

[`OperationOptions`](../interfaces/OperationOptions.md)

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

#### Example

**Update a user task**

```ts
async function updateUserTaskExample(userTaskKey: UserTaskKey) {
  const camunda = createCamundaClient();

  await camunda.updateUserTask({
    userTaskKey,
    changeset: {
      candidateUsers: ["alice", "bob"],
      dueDate: "2025-12-31T23:59:59Z",
      priority: 80,
    },
  });
}
```

#### Operation Id

updateUserTask

#### Tags

User task

---

### withCorrelation()

```ts
withCorrelation<T>(id, fn): Promise<T>;
```

#### Type Parameters

##### T

`T`

#### Parameters

##### id

`string`

##### fn

() => `T` \| `Promise`\<`T`\>

#### Returns

`Promise`\<`T`\>

---

## Class: CamundaValidationError


## Extends

- `Error`

## Constructors

### Constructor

```ts
new CamundaValidationError(params): CamundaValidationError;
```

#### Parameters

##### params

###### issues

`string`[]

###### message

`string`

###### operationId?

`string`

###### side

`"request"` \| `"response"`

###### summary

`string`

#### Returns

`CamundaValidationError`

#### Overrides

```ts
Error.constructor;
```

## Properties

### issues

```ts
issues: string[];
```

---

### operationId?

```ts
optional operationId?: string;
```

---

### side

```ts
side: "request" | "response";
```

---

### summary

```ts
summary: string;
```

---

## Class: CancelError


## Extends

- `Error`

## Constructors

### Constructor

```ts
new CancelError(): CancelError;
```

#### Returns

`CancelError`

#### Overrides

```ts
Error.constructor;
```

---

## Class: EventualConsistencyTimeoutError


## Extends

- `Error`

## Constructors

### Constructor

```ts
new EventualConsistencyTimeoutError(params): EventualConsistencyTimeoutError;
```

#### Parameters

##### params

###### attempts

`number`

###### elapsedMs

`number`

###### lastResponse?

`any`

###### lastStatus?

`number`

###### message?

`string`

###### operationId?

`string`

#### Returns

`EventualConsistencyTimeoutError`

#### Overrides

```ts
Error.constructor;
```

## Properties

### attempts

```ts
attempts: number;
```

---

### code

```ts
code: string = "CAMUNDA_SDK_EVENTUAL_TIMEOUT";
```

---

### elapsedMs

```ts
elapsedMs: number;
```

---

### lastResponseSnippet?

```ts
optional lastResponseSnippet?: string;
```

---

### lastStatus?

```ts
optional lastStatus?: number;
```

---

### operationId?

```ts
optional operationId?: string;
```

---

## Class: TypedVariablesError


Base class for all typed-variable errors, so callers can catch the whole family.

## Extends

- `Error`

## Extended by

- [`VariableDeserializationError`](VariableDeserializationError.md)
- [`VariableScopeCollisionError`](VariableScopeCollisionError.md)

## Constructors

### Constructor

```ts
new TypedVariablesError(message, options?): TypedVariablesError;
```

#### Parameters

##### message

`string`

##### options?

###### cause?

`unknown`

#### Returns

`TypedVariablesError`

#### Overrides

```ts
Error.constructor;
```

---

## Class: VariableCollector


Incrementally collapses paged variable items into a parsed name-to-value map.

Memory stays bounded by the DTO shape rather than the total number of paged items: only the
first value seen per requested name is retained, alongside the set of scope keys observed for
that name (used for collision detection). Items for undeclared variables are dropped, so large
values for variables outside the DTO are never accumulated.

## Constructors

### Constructor

```ts
new VariableCollector(queryNames): VariableCollector;
```

#### Parameters

##### queryNames

`Iterable`\<`string`\>

#### Returns

`VariableCollector`

## Methods

### build()

```ts
build(): Record<string, unknown>;
```

Parse retained values, raising on scope collisions or malformed JSON.

#### Returns

`Record`\<`string`, `unknown`\>

#### Throws

when a name was observed at more than one scope.

#### Throws

when a retained value is not valid JSON.

---

### ingest()

```ts
ingest(items): void;
```

Fold one page of results into the retained per-name state.

#### Parameters

##### items

`Iterable`\<[`TypedVariableItem`](../interfaces/TypedVariableItem.md)\>

#### Returns

`void`

---

## Class: VariableDeserializationError


Raised when a variable's serialized value is not valid JSON.

## Extends

- [`TypedVariablesError`](TypedVariablesError.md)

## Constructors

### Constructor

```ts
new VariableDeserializationError(variableName, options?): VariableDeserializationError;
```

#### Parameters

##### variableName

`string`

##### options?

###### cause?

`unknown`

#### Returns

`VariableDeserializationError`

#### Overrides

[`TypedVariablesError`](TypedVariablesError.md).[`constructor`](TypedVariablesError.md#constructor)

## Properties

### variableName

```ts
readonly variableName: string;
```

---

## Class: VariableMap<TSchema>

# Class: VariableMap\<TSchema\>

Result of a DTO-driven variable search.

Holds the parsed variable values keyed by their declared name. Provides lenient, defensive
access via [has](#has) / [get](#get), and a strict [validate](#validate) that parses the values
against the schema — returning a fully-typed object or throwing a `ZodError` when a required
variable is missing or malformed.

## Type Parameters

### TSchema

`TSchema` _extends_ [`AnyVariableSchema`](../type-aliases/AnyVariableSchema.md)

## Constructors

### Constructor

```ts
new VariableMap<TSchema>(_raw, _schema): VariableMap<TSchema>;
```

#### Parameters

##### \_raw

`Readonly`\<`Record`\<`string`, `unknown`\>\>

##### \_schema

`TSchema`

#### Returns

`VariableMap`\<`TSchema`\>

## Accessors

### raw

#### Get Signature

```ts
get raw(): Readonly<Record<string, unknown>>;
```

The parsed variable values, keyed by variable name.

##### Returns

`Readonly`\<`Record`\<`string`, `unknown`\>\>

## Methods

### get()

```ts
get<K>(variableName): K extends keyof input<TSchema> ? input<TSchema>[K] | undefined : undefined;
```

Lenient access. Returns the JSON-parsed wire value, or `undefined` when the variable is absent.

The value is _not_ run through the schema, so a declared key is narrowed to that field's schema
_input_ type (`z.input`) unioned with `undefined` — not the post-validation output type. This
keeps the type honest for schemas with transforms or effects, where the parsed wire value can
differ from `validate()`'s output. Any other key resolves to `undefined`: the result only ever
holds the declared variable names, so an undeclared key can never carry a value.

#### Type Parameters

##### K

`K` _extends_ `string`

#### Parameters

##### variableName

`K`

#### Returns

`K` _extends_ keyof `input`\<`TSchema`\> ? `input`\<`TSchema`\>\[`K`\] \| `undefined` : `undefined`

---

### has()

#### Call Signature

```ts
has(variableName): boolean;
```

Whether a variable with the given name is present in the result.

##### Parameters

###### variableName

keyof `input`\<`TSchema`\> & `string`

##### Returns

`boolean`

#### Call Signature

```ts
has(variableName): boolean;
```

Whether a variable with the given name is present in the result.

##### Parameters

###### variableName

`string`

##### Returns

`boolean`

---

### validate()

```ts
validate(): output<TSchema>;
```

Strict access. Parses the collected values against the schema and returns the typed object.
Required variables must be present and well-formed, otherwise a `ZodError` is thrown.

#### Returns

`output`\<`TSchema`\>

---

## Class: VariableScopeCollisionError


Raised when a declared variable name is observed at more than one scope (for example a local
variable shadowing a process-level variable). The result would be ambiguous, so the search
fails loudly rather than silently picking one. Pass an explicit `scopeKey` to disambiguate.

## Extends

- [`TypedVariablesError`](TypedVariablesError.md)

## Constructors

### Constructor

```ts
new VariableScopeCollisionError(variableName, scopeKeys): VariableScopeCollisionError;
```

#### Parameters

##### variableName

`string`

##### scopeKeys

readonly `string`[]

#### Returns

`VariableScopeCollisionError`

#### Overrides

[`TypedVariablesError`](TypedVariablesError.md).[`constructor`](TypedVariablesError.md#constructor)

## Properties

### scopeKeys

```ts
readonly scopeKeys: readonly string[];
```

---

### variableName

```ts
readonly variableName: string;
```

---

## Function: assertConstraint()


```ts
function assertConstraint(value, label, c): void;
```

## Parameters

### value

`string`

### label

`string`

### c

#### maxLength?

`number`

#### minLength?

`number`

#### pattern?

`string`

## Returns

`void`

---

## Function: collectTypedVariables()


```ts
function collectTypedVariables<TSchema>(params): Promise<VariableMap<TSchema>>;
```

Page through variable search results until every declared variable is found or the result set
is exhausted, then collapse them into a [VariableMap](../classes/VariableMap.md).

Eventual-consistency waiting (when `consistency.waitUpToMs > 0`) is applied here, at the
collection level — not on the underlying search calls. A freshly-written instance indexes its
declared variables independently, so an early read can return only a subset (e.g. `orderId`
before `amount`). Waiting on the first _search_ alone is too weak: that search's success
condition is "at least one matching variable", so it settles on a partial result. Instead we
re-run the whole collection until every declared name is visible or the budget expires. On
expiry we return the best snapshot gathered so far rather than throwing: a genuinely-absent
variable is indistinguishable from a late one, and [VariableMap.validate](../classes/VariableMap.md#validate) is the right
place to surface a missing required variable. This also keeps pagination correct — a paging
read that legitimately returns zero items never blocks, because the inner search never waits.

The `fetchPage` callback isolates the HTTP call so the paging and collapse logic is
unit-testable in isolation; `clock` isolates time so the consistency loop is too.

## Type Parameters

### TSchema

`TSchema` _extends_ [`AnyVariableSchema`](../type-aliases/AnyVariableSchema.md)

## Parameters

### params

#### clock?

`CollectClock`

Injectable clock for deterministic tests; defaults to real time.

#### consistency?

`VariableConsistencyOptions`

Eventual-consistency tolerance. Omitted or `waitUpToMs: 0` reads exactly once.

#### fetchPage

(`after`) => `Promise`\<[`TypedVariablePage`](../interfaces/TypedVariablePage.md)\>

#### schema

`TSchema`

#### singleScope

`boolean`

Whether the query is scoped to a single scope (collisions impossible, early-stop safe).

## Returns

`Promise`\<[`VariableMap`](../classes/VariableMap.md)\<`TSchema`\>\>

---

## Function: createCamundaClient()


```ts
function createCamundaClient(options?): CamundaClient;
```

## Parameters

### options?

[`CamundaOptions`](../interfaces/CamundaOptions.md)

## Returns

[`CamundaClient`](../classes/CamundaClient.md)

---

## Function: createCamundaClientLoose()


```ts
function createCamundaClientLoose(...args): object;
```

Create a client where all branded key types are widened to string.
Use when integrating with external systems or when dynamic string keys are common and brand friction is unwanted.
For maximum type safety prefer the strict createCamundaClient.

## Parameters

### args

...\[[`CamundaOptions`](../interfaces/CamundaOptions.md)\]

## Returns

`object`

### config

```ts
config: object;
```

#### config.\_\_raw

```ts
readonly __raw: object;
```

##### Index Signature

```ts
[key: string]: string | undefined
```

#### config.auth

```ts
readonly auth: object;
```

#### config.auth.basic?

```ts
optional basic?: object;
```

#### config.auth.basic.password?

```ts
optional password?: string;
```

#### config.auth.basic.username?

```ts
optional username?: string;
```

#### config.auth.strategy

```ts
strategy: AuthStrategy;
```

#### config.backpressure

```ts
readonly backpressure: object;
```

#### config.backpressure.decayQuietMs

```ts
decayQuietMs: number;
```

#### config.backpressure.enabled

```ts
enabled: boolean;
```

#### config.backpressure.floor

```ts
floor: number;
```

#### config.backpressure.healthyRecoveryMultiplier

```ts
healthyRecoveryMultiplier: number;
```

#### config.backpressure.initialMax

```ts
initialMax: number;
```

#### config.backpressure.maxWaiters

```ts
maxWaiters: number;
```

#### config.backpressure.observeOnly

```ts
observeOnly: boolean;
```

#### config.backpressure.profile

```ts
profile: string;
```

#### config.backpressure.recoveryIntervalMs

```ts
recoveryIntervalMs: number;
```

#### config.backpressure.recoveryStep

```ts
recoveryStep: number;
```

#### config.backpressure.severeFactor

```ts
severeFactor: number;
```

#### config.backpressure.severeThreshold

```ts
severeThreshold: number;
```

#### config.backpressure.softFactor

```ts
softFactor: number;
```

#### config.backpressure.unlimitedAfterHealthyMs

```ts
unlimitedAfterHealthyMs: number;
```

#### config.defaultTenantId

```ts
readonly defaultTenantId: string;
```

#### config.eventual?

```ts
readonly optional eventual?: object;
```

#### config.eventual.pollDefaultMs

```ts
pollDefaultMs: number;
```

#### config.httpRetry

```ts
readonly httpRetry: object;
```

#### config.httpRetry.baseDelayMs

```ts
baseDelayMs: number;
```

#### config.httpRetry.maxAttempts

```ts
maxAttempts: number;
```

#### config.httpRetry.maxDelayMs

```ts
maxDelayMs: number;
```

#### config.logLevel

```ts
readonly logLevel: "trace" | "error" | "silent" | "warn" | "info" | "debug";
```

#### config.mtls?

```ts
readonly optional mtls?: object;
```

#### config.mtls.ca?

```ts
optional ca?: string;
```

#### config.mtls.caPath?

```ts
optional caPath?: string;
```

#### config.mtls.cert?

```ts
optional cert?: string;
```

#### config.mtls.certPath?

```ts
optional certPath?: string;
```

#### config.mtls.key?

```ts
optional key?: string;
```

#### config.mtls.keyPassphrase?

```ts
optional keyPassphrase?: string;
```

#### config.mtls.keyPath?

```ts
optional keyPath?: string;
```

#### config.oauth

```ts
readonly oauth: object;
```

#### config.oauth.cacheDir?

```ts
optional cacheDir?: string;
```

#### config.oauth.clientId?

```ts
optional clientId?: string;
```

#### config.oauth.clientSecret?

```ts
optional clientSecret?: string;
```

#### config.oauth.grantType

```ts
grantType: string;
```

#### config.oauth.oauthUrl

```ts
oauthUrl: string;
```

#### config.oauth.retry

```ts
retry: object;
```

#### config.oauth.retry.baseDelayMs

```ts
baseDelayMs: number;
```

#### config.oauth.retry.max

```ts
max: number;
```

#### config.oauth.scope?

```ts
optional scope?: string;
```

#### config.oauth.timeoutMs

```ts
timeoutMs: number;
```

#### config.restAddress

```ts
readonly restAddress: string;
```

#### config.supportLog?

```ts
readonly optional supportLog?: object;
```

#### config.supportLog.enabled

```ts
enabled: boolean;
```

#### config.supportLog.filePath

```ts
filePath: string;
```

#### config.telemetry?

```ts
readonly optional telemetry?: object;
```

#### config.telemetry.correlation

```ts
correlation: boolean;
```

#### config.telemetry.log

```ts
log: boolean;
```

#### config.tokenAudience

```ts
readonly tokenAudience: string;
```

#### config.validation

```ts
readonly validation: object;
```

#### config.validation.raw

```ts
raw: string;
```

#### config.validation.req

```ts
req: ValidationMode;
```

#### config.validation.res

```ts
res: ValidationMode;
```

#### config.workerDefaults?

```ts
readonly optional workerDefaults?: object;
```

#### config.workerDefaults.jobTimeoutMs?

```ts
optional jobTimeoutMs?: number;
```

#### config.workerDefaults.maxParallelJobs?

```ts
optional maxParallelJobs?: number;
```

#### config.workerDefaults.pollTimeoutMs?

```ts
optional pollTimeoutMs?: number;
```

#### config.workerDefaults.startupJitterMaxSeconds?

```ts
optional startupJitterMaxSeconds?: number;
```

#### config.workerDefaults.workerName?

```ts
optional workerName?: string;
```

### \_getSupportLogger()

```ts
_getSupportLogger(...a): object;
```

#### Parameters

##### a

...\[\]

#### Returns

`object`

##### log()

```ts
log(...a): void;
```

###### Parameters

###### a

...\[`string` \| `number` \| `boolean` \| `object`, `boolean`\]

###### Returns

`void`

### \_invokeWithRetry()

```ts
_invokeWithRetry(...a): Promise<unknown>;
```

#### Parameters

##### a

...\[(...`a`) => `Promise`\<`unknown`\>, `object`\]

#### Returns

`Promise`\<`unknown`\>

### activateAdHocSubProcessActivities()

```ts
activateAdHocSubProcessActivities(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### activateJobs()

```ts
activateJobs(...a): CancelablePromise<{
  jobs: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`jobs`: `object`[];
\}\>

### assignClientToGroup()

```ts
assignClientToGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignClientToTenant()

```ts
assignClientToTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignGroupToTenant()

```ts
assignGroupToTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignMappingRuleToGroup()

```ts
assignMappingRuleToGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignMappingRuleToTenant()

```ts
assignMappingRuleToTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignRoleToClient()

```ts
assignRoleToClient(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignRoleToGroup()

```ts
assignRoleToGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignRoleToMappingRule()

```ts
assignRoleToMappingRule(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignRoleToTenant()

```ts
assignRoleToTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignRoleToUser()

```ts
assignRoleToUser(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignUserTask()

```ts
assignUserTask(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignUserToGroup()

```ts
assignUserToGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### assignUserToTenant()

```ts
assignUserToTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### broadcastSignal()

```ts
broadcastSignal(...a): CancelablePromise<{
  signalKey: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`signalKey`: `string`;
`tenantId`: `string`;
\}\>

### cancelBatchOperation()

```ts
cancelBatchOperation(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### cancelProcessInstance()

```ts
cancelProcessInstance(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### cancelProcessInstancesBatchOperation()

```ts
cancelProcessInstancesBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### clearAuthCache()

```ts
clearAuthCache(...a): void;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

`void`

### completeJob()

```ts
completeJob(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### completeUserTask()

```ts
completeUserTask(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### configure()

```ts
configure(...a): void;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

`void`

### correlateMessage()

```ts
correlateMessage(...a): CancelablePromise<{
  messageKey: string;
  processInstanceKey: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`messageKey`: `string`;
`processInstanceKey`: `string`;
`tenantId`: `string`;
\}\>

### createAdminUser()

```ts
createAdminUser(...a): CancelablePromise<{
  email: string | null;
  name: string | null;
  username: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`email`: `string` \| `null`;
`name`: `string` \| `null`;
`username`: `string`;
\}\>

### createAgentInstance()

```ts
createAgentInstance(...a): CancelablePromise<{
  agentInstanceKey: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`agentInstanceKey`: `string`;
\}\>

### createAgentInstanceHistoryItem()

```ts
createAgentInstanceHistoryItem(...a): CancelablePromise<{
  historyItemKey: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`historyItemKey`: `string`;
\}\>

### createAuthorization()

```ts
createAuthorization(...a): CancelablePromise<{
  authorizationKey: string;
}>;
```

#### Parameters

##### a

...\[
\| \{
`ownerId`: `string`;
`ownerType`: [`OwnerTypeEnum`](../type-aliases/OwnerTypeEnum.md);
`permissionTypes`: [`PermissionTypeEnum`](../type-aliases/PermissionTypeEnum.md)[];
`resourceId`: `string`;
`resourceType`: [`ResourceTypeEnum`](../type-aliases/ResourceTypeEnum.md);
\}
\| \{
`ownerId`: `string`;
`ownerType`: [`OwnerTypeEnum`](../type-aliases/OwnerTypeEnum.md);
`permissionTypes`: [`PermissionTypeEnum`](../type-aliases/PermissionTypeEnum.md)[];
`resourcePropertyName`: `string`;
`resourceType`: [`ResourceTypeEnum`](../type-aliases/ResourceTypeEnum.md);
\}, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`authorizationKey`: `string`;
\}\>

### createDeployment()

```ts
createDeployment(...a): CancelablePromise<{
  decisionRequirements: object[];
  decisions: object[];
  deploymentKey: string;
  deployments: object[];
  forms: object[];
  processes: object[];
  resources: object[];
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`decisionRequirements`: `object`[];
`decisions`: `object`[];
`deploymentKey`: `string`;
`deployments`: `object`[];
`forms`: `object`[];
`processes`: `object`[];
`resources`: `object`[];
`tenantId`: `string`;
\}\>

### createDocument()

```ts
createDocument(...a): CancelablePromise<{
  camunda.document.type: "camunda";
  contentHash: string | null;
  documentId: string;
  metadata: {
     contentType: string;
     customProperties: {
      [key: string]: unknown;
     };
     expiresAt: string | null;
     fileName: string;
     processDefinitionId:   | {
      [key: number]: string;
        __brand: "ProcessDefinitionId";
      }
        | null;
     processInstanceKey:   | {
      [key: number]: string;
        __brand: "ProcessInstanceKey";
      }
        | null;
     size: number;
  };
  storeId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`camunda.document.type`: `"camunda"`;
`contentHash`: `string` \| `null`;
`documentId`: `string`;
`metadata`: \{
`contentType`: `string`;
`customProperties`: \{
\[`key`: `string`\]: `unknown`;
\};
`expiresAt`: `string` \| `null`;
`fileName`: `string`;
`processDefinitionId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessDefinitionId"`;
\}
\| `null`;
`processInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`size`: `number`;
\};
`storeId`: `string`;
\}\>

### createDocumentLink()

```ts
createDocumentLink(...a): CancelablePromise<{
  expiresAt: string;
  url: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`expiresAt`: `string`;
`url`: `string`;
\}\>

### createDocuments()

```ts
createDocuments(...a): CancelablePromise<{
  createdDocuments: object[];
  failedDocuments: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`createdDocuments`: `object`[];
`failedDocuments`: `object`[];
\}\>

### createElementInstanceVariables()

```ts
createElementInstanceVariables(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### createGlobalClusterVariable()

```ts
createGlobalClusterVariable(...a): CancelablePromise<{
  name: string;
  scope: ClusterVariableScopeEnum;
  tenantId: string | null;
  value: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`scope`: [`ClusterVariableScopeEnum`](../type-aliases/ClusterVariableScopeEnum.md);
`tenantId`: `string` \| `null`;
`value`: `string`;
\}\>

### createGlobalTaskListener()

```ts
createGlobalTaskListener(...a): CancelablePromise<{
  afterNonGlobal?: boolean;
  eventTypes: GlobalTaskListenerEventTypeEnum[];
  id: string;
  priority?: number;
  retries?: number;
  source: GlobalListenerSourceEnum;
  type?: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`afterNonGlobal?`: `boolean`;
`eventTypes`: [`GlobalTaskListenerEventTypeEnum`](../type-aliases/GlobalTaskListenerEventTypeEnum.md)[];
`id`: `string`;
`priority?`: `number`;
`retries?`: `number`;
`source`: [`GlobalListenerSourceEnum`](../type-aliases/GlobalListenerSourceEnum.md);
`type?`: `string`;
\}\>

### createGroup()

```ts
createGroup(...a): CancelablePromise<{
  description: string | null;
  groupId: string;
  name: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`groupId`: `string`;
`name`: `string`;
\}\>

### createJobWorker()

```ts
createJobWorker(...a): object;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

`object`

##### activeJobs

```ts
activeJobs: number;
```

##### name

```ts
name: string;
```

##### stopped

```ts
stopped: boolean;
```

##### start()

```ts
start(...a): void;
```

###### Parameters

###### a

...\[\]

###### Returns

`void`

##### stop()

```ts
stop(...a): void;
```

###### Parameters

###### a

...\[\]

###### Returns

`void`

##### stopGracefully()

```ts
stopGracefully(...a): Promise<{
  remainingJobs: number;
  timedOut: boolean;
}>;
```

###### Parameters

###### a

...\[`object`\]

###### Returns

`Promise`\<\{
`remainingJobs`: `number`;
`timedOut`: `boolean`;
\}\>

### createMappingRule()

```ts
createMappingRule(...a): CancelablePromise<{
  claimName: string;
  claimValue: string;
  mappingRuleId: string;
  name: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`claimName`: `string`;
`claimValue`: `string`;
`mappingRuleId`: `string`;
`name`: `string`;
\}\>

### createProcessInstance()

```ts
createProcessInstance(...a): CancelablePromise<{
  businessId:   | {
   [key: number]: string;
     __brand: "BusinessId";
   }
     | null;
  processDefinitionId: string;
  processDefinitionKey: string;
  processDefinitionVersion: number;
  processInstanceKey: string;
  tags: string[];
  tenantId: string;
  variables: {
   [key: string]: unknown;
  };
}>;
```

#### Parameters

##### a

...\[
\| \{
`awaitCompletion?`: `boolean`;
`businessId?`: \{
\[`key`: `number`\]: `string`;
`__brand`: `"BusinessId"`;
\};
`fetchVariables?`: `string`[];
`operationReference?`: `number`;
`processDefinitionKey`: `string`;
`processDefinitionVersion?`: `number`;
`requestTimeout?`: `number`;
`runtimeInstructions?`: `object`[];
`startInstructions?`: `object`[];
`tags?`: `string`[];
`tenantId?`: \{
\[`key`: `number`\]: `string`;
`__brand`: `"TenantId"`;
\};
`variables?`: \{
\[`key`: `string`\]: `unknown`;
\};
\}
\| \{
`awaitCompletion?`: `boolean`;
`businessId?`: \{
\[`key`: `number`\]: `string`;
`__brand`: `"BusinessId"`;
\};
`fetchVariables?`: `string`[];
`operationReference?`: `number`;
`processDefinitionId`: `string`;
`processDefinitionVersion?`: `number`;
`requestTimeout?`: `number`;
`runtimeInstructions?`: `object`[];
`startInstructions?`: `object`[];
`tags?`: `string`[];
`tenantId?`: \{
\[`key`: `number`\]: `string`;
`__brand`: `"TenantId"`;
\};
`variables?`: \{
\[`key`: `string`\]: `unknown`;
\};
\}, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`businessId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"BusinessId"`;
\}
\| `null`;
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`processDefinitionVersion`: `number`;
`processInstanceKey`: `string`;
`tags`: `string`[];
`tenantId`: `string`;
`variables`: \{
\[`key`: `string`\]: `unknown`;
\};
\}\>

### createRole()

```ts
createRole(...a): CancelablePromise<{
  description: string | null;
  name: string;
  roleId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`name`: `string`;
`roleId`: `string`;
\}\>

### createTenant()

```ts
createTenant(...a): CancelablePromise<{
  description: string | null;
  name: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`name`: `string`;
`tenantId`: `string`;
\}\>

### createTenantClusterVariable()

```ts
createTenantClusterVariable(...a): CancelablePromise<{
  name: string;
  scope: ClusterVariableScopeEnum;
  tenantId: string | null;
  value: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`scope`: [`ClusterVariableScopeEnum`](../type-aliases/ClusterVariableScopeEnum.md);
`tenantId`: `string` \| `null`;
`value`: `string`;
\}\>

### createThreadedJobWorker()

```ts
createThreadedJobWorker(...a): object;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

`object`

##### activeJobs

```ts
activeJobs: number;
```

##### busyThreads

```ts
busyThreads: number;
```

##### name

```ts
name: string;
```

##### poolSize

```ts
poolSize: number;
```

##### ready

```ts
ready: Promise<void>;
```

##### stopped

```ts
stopped: boolean;
```

##### start()

```ts
start(...a): void;
```

###### Parameters

###### a

...\[\]

###### Returns

`void`

##### stop()

```ts
stop(...a): void;
```

###### Parameters

###### a

...\[\]

###### Returns

`void`

##### stopGracefully()

```ts
stopGracefully(...a): Promise<{
  remainingJobs: number;
  timedOut: boolean;
}>;
```

###### Parameters

###### a

...\[`object`\]

###### Returns

`Promise`\<\{
`remainingJobs`: `number`;
`timedOut`: `boolean`;
\}\>

### createUser()

```ts
createUser(...a): CancelablePromise<{
  email: string | null;
  name: string | null;
  username: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`email`: `string` \| `null`;
`name`: `string` \| `null`;
`username`: `string`;
\}\>

### deleteAuthorization()

```ts
deleteAuthorization(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteDecisionInstance()

```ts
deleteDecisionInstance(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteDecisionInstancesBatchOperation()

```ts
deleteDecisionInstancesBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### deleteDocument()

```ts
deleteDocument(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteGlobalClusterVariable()

```ts
deleteGlobalClusterVariable(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteGlobalTaskListener()

```ts
deleteGlobalTaskListener(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteGroup()

```ts
deleteGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteMappingRule()

```ts
deleteMappingRule(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteProcessInstance()

```ts
deleteProcessInstance(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteProcessInstancesBatchOperation()

```ts
deleteProcessInstancesBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### deleteResource()

```ts
deleteResource(...a): CancelablePromise<{
  batchOperation:   | {
     batchOperationKey: string;
     batchOperationType: BatchOperationTypeEnum;
   }
     | null;
  resourceKey: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperation`: \| \{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}
\| `null`;
`resourceKey`: `string`;
\}\>

### deleteRole()

```ts
deleteRole(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteTenant()

```ts
deleteTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteTenantClusterVariable()

```ts
deleteTenantClusterVariable(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deleteUser()

```ts
deleteUser(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### deployResourcesFromFiles()

```ts
deployResourcesFromFiles(...a): CancelablePromise<{
  decisionRequirements: object[];
  decisions: object[];
  deploymentKey: string;
  deployments: object[];
  forms: object[];
  processes: object[];
  resources: object[];
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`string`[], `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`decisionRequirements`: `object`[];
`decisions`: `object`[];
`deploymentKey`: `string`;
`deployments`: `object`[];
`forms`: `object`[];
`processes`: `object`[];
`resources`: `object`[];
`tenantId`: `string`;
\}\>

### emitSupportLogPreamble()

```ts
emitSupportLogPreamble(...a): void;
```

#### Parameters

##### a

...\[\]

#### Returns

`void`

### evaluateConditionals()

```ts
evaluateConditionals(...a): CancelablePromise<{
  conditionalEvaluationKey: string;
  processInstances: object[];
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`conditionalEvaluationKey`: `string`;
`processInstances`: `object`[];
`tenantId`: `string`;
\}\>

### evaluateDecision()

```ts
evaluateDecision(...a): CancelablePromise<{
  decisionDefinitionId: string;
  decisionDefinitionKey: string;
  decisionDefinitionName: string;
  decisionDefinitionVersion: number;
  decisionEvaluationKey: string;
  decisionInstanceKey: string;
  decisionRequirementsId: string;
  decisionRequirementsKey: string;
  evaluatedDecisions: object[];
  failedDecisionDefinitionId:   | {
   [key: number]: string;
     __brand: "DecisionDefinitionId";
   }
     | null;
  failureMessage: string | null;
  output: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[
\| \{
`decisionDefinitionId`: `string`;
`tenantId?`: \{
\[`key`: `number`\]: `string`;
`__brand`: `"TenantId"`;
\};
`variables?`: \{
\[`key`: `string`\]: `unknown`;
\};
\}
\| \{
`decisionDefinitionKey`: `string`;
`tenantId?`: \{
\[`key`: `number`\]: `string`;
`__brand`: `"TenantId"`;
\};
`variables?`: \{
\[`key`: `string`\]: `unknown`;
\};
\}, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`decisionDefinitionId`: `string`;
`decisionDefinitionKey`: `string`;
`decisionDefinitionName`: `string`;
`decisionDefinitionVersion`: `number`;
`decisionEvaluationKey`: `string`;
`decisionInstanceKey`: `string`;
`decisionRequirementsId`: `string`;
`decisionRequirementsKey`: `string`;
`evaluatedDecisions`: `object`[];
`failedDecisionDefinitionId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionDefinitionId"`;
\}
\| `null`;
`failureMessage`: `string` \| `null`;
`output`: `string`;
`tenantId`: `string`;
\}\>

### evaluateExpression()

```ts
evaluateExpression(...a): CancelablePromise<{
  expression: string;
  result: unknown;
  warnings: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`expression`: `string`;
`result`: `unknown`;
`warnings`: `object`[];
\}\>

### failJob()

```ts
failJob(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### forceAuthRefresh()

```ts
forceAuthRefresh(...a): Promise<string | undefined>;
```

#### Parameters

##### a

...\[\]

#### Returns

`Promise`\<`string` \| `undefined`\>

### getAgentInstance()

```ts
getAgentInstance(...a): CancelablePromise<{
  agentInstanceKey: string;
  completionDate: string | null;
  creationDate: string;
  definition: {
     model: string;
     provider: string;
     systemPrompt: string;
  };
  elementId: string;
  elementInstanceKeys: string[];
  lastUpdatedDate: string;
  limits: {
     maxModelCalls: number;
     maxTokens: number;
     maxToolCalls: number;
  };
  metrics: {
     inputTokens: number;
     modelCalls: number;
     outputTokens: number;
     toolCalls: number;
  };
  processDefinitionId: string;
  processDefinitionKey: string;
  processDefinitionVersion: number;
  processDefinitionVersionTag: string | null;
  processInstanceKey: string;
  rootProcessInstanceKey: string;
  status: AgentInstanceStatusEnum;
  tenantId: string;
  tools: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`agentInstanceKey`: `string`;
`completionDate`: `string` \| `null`;
`creationDate`: `string`;
`definition`: \{
`model`: `string`;
`provider`: `string`;
`systemPrompt`: `string`;
\};
`elementId`: `string`;
`elementInstanceKeys`: `string`[];
`lastUpdatedDate`: `string`;
`limits`: \{
`maxModelCalls`: `number`;
`maxTokens`: `number`;
`maxToolCalls`: `number`;
\};
`metrics`: \{
`inputTokens`: `number`;
`modelCalls`: `number`;
`outputTokens`: `number`;
`toolCalls`: `number`;
\};
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`processDefinitionVersion`: `number`;
`processDefinitionVersionTag`: `string` \| `null`;
`processInstanceKey`: `string`;
`rootProcessInstanceKey`: `string`;
`status`: [`AgentInstanceStatusEnum`](../type-aliases/AgentInstanceStatusEnum.md);
`tenantId`: `string`;
`tools`: `object`[];
\}\>

### getAuditLog()

```ts
getAuditLog(...a): CancelablePromise<{
  actorId: string | null;
  actorType:   | AuditLogActorTypeEnum
     | null;
  agentElementId: string | null;
  auditLogKey: string;
  batchOperationKey:   | {
   [key: number]: string;
     __brand: "BatchOperationKey";
   }
     | null;
  batchOperationType:   | BatchOperationTypeEnum
     | null;
  category: AuditLogCategoryEnum;
  decisionDefinitionId:   | {
   [key: number]: string;
     __brand: "DecisionDefinitionId";
   }
     | null;
  decisionDefinitionKey:   | {
   [key: number]: string;
     __brand: "DecisionDefinitionKey";
   }
     | null;
  decisionEvaluationKey:   | {
   [key: number]: string;
     __brand: "DecisionEvaluationKey";
   }
     | null;
  decisionRequirementsId: string | null;
  decisionRequirementsKey:   | {
   [key: number]: string;
     __brand: "DecisionRequirementsKey";
   }
     | null;
  deploymentKey:   | {
   [key: number]: string;
     __brand: "DeploymentKey";
   }
     | null;
  elementInstanceKey:   | {
   [key: number]: string;
     __brand: "ElementInstanceKey";
   }
     | null;
  entityDescription: string | null;
  entityKey: string;
  entityType: AuditLogEntityTypeEnum;
  formKey:   | {
   [key: number]: string;
     __brand: "FormKey";
   }
     | null;
  inboundChannelToolName: string | null;
  inboundChannelType: string | null;
  jobKey:   | {
   [key: number]: string;
     __brand: "JobKey";
   }
     | null;
  operationType: AuditLogOperationTypeEnum;
  processDefinitionId:   | {
   [key: number]: string;
     __brand: "ProcessDefinitionId";
   }
     | null;
  processDefinitionKey:   | {
   [key: number]: string;
     __brand: "ProcessDefinitionKey";
   }
     | null;
  processInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  relatedEntityKey:   | {
   [key: number]: string;
     __brand: "AuditLogEntityKey";
   }
     | null;
  relatedEntityType:   | AuditLogEntityTypeEnum
     | null;
  resourceKey:   | {
   [key: number]: string;
     __brand: "FormKey";
   }
     | {
   [key: number]: string;
     __brand: "ProcessDefinitionKey";
   }
     | {
   [key: number]: string;
     __brand: "DecisionRequirementsKey";
   }
     | {
   [key: number]: string;
     __brand: "DecisionDefinitionKey";
   }
     | null;
  result: AuditLogResultEnum;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  tenantId:   | {
   [key: number]: string;
     __brand: "TenantId";
   }
     | null;
  timestamp: string;
  userTaskKey:   | {
   [key: number]: string;
     __brand: "UserTaskKey";
   }
     | null;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`actorId`: `string` \| `null`;
`actorType`: \| [`AuditLogActorTypeEnum`](../type-aliases/AuditLogActorTypeEnum.md)
\| `null`;
`agentElementId`: `string` \| `null`;
`auditLogKey`: `string`;
`batchOperationKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"BatchOperationKey"`;
\}
\| `null`;
`batchOperationType`: \| [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md)
\| `null`;
`category`: [`AuditLogCategoryEnum`](../type-aliases/AuditLogCategoryEnum.md);
`decisionDefinitionId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionDefinitionId"`;
\}
\| `null`;
`decisionDefinitionKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionDefinitionKey"`;
\}
\| `null`;
`decisionEvaluationKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionEvaluationKey"`;
\}
\| `null`;
`decisionRequirementsId`: `string` \| `null`;
`decisionRequirementsKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionRequirementsKey"`;
\}
\| `null`;
`deploymentKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DeploymentKey"`;
\}
\| `null`;
`elementInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ElementInstanceKey"`;
\}
\| `null`;
`entityDescription`: `string` \| `null`;
`entityKey`: `string`;
`entityType`: [`AuditLogEntityTypeEnum`](../type-aliases/AuditLogEntityTypeEnum.md);
`formKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"FormKey"`;
\}
\| `null`;
`inboundChannelToolName`: `string` \| `null`;
`inboundChannelType`: `string` \| `null`;
`jobKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"JobKey"`;
\}
\| `null`;
`operationType`: [`AuditLogOperationTypeEnum`](../type-aliases/AuditLogOperationTypeEnum.md);
`processDefinitionId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessDefinitionId"`;
\}
\| `null`;
`processDefinitionKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessDefinitionKey"`;
\}
\| `null`;
`processInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`relatedEntityKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"AuditLogEntityKey"`;
\}
\| `null`;
`relatedEntityType`: \| [`AuditLogEntityTypeEnum`](../type-aliases/AuditLogEntityTypeEnum.md)
\| `null`;
`resourceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"FormKey"`;
\}
\| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessDefinitionKey"`;
\}
\| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionRequirementsKey"`;
\}
\| \{
\[`key`: `number`\]: `string`;
`__brand`: `"DecisionDefinitionKey"`;
\}
\| `null`;
`result`: [`AuditLogResultEnum`](../type-aliases/AuditLogResultEnum.md);
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`tenantId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"TenantId"`;
\}
\| `null`;
`timestamp`: `string`;
`userTaskKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"UserTaskKey"`;
\}
\| `null`;
\}\>

### getAuthentication()

```ts
getAuthentication(...a): CancelablePromise<{
  authorizedComponents: string[];
  c8Links: {
   [key: string]: string;
  };
  canLogout: boolean;
  displayName: string | null;
  email: string | null;
  groups: string[];
  roles: string[];
  salesPlanType: string | null;
  tenants: object[];
  username: string;
}>;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`authorizedComponents`: `string`[];
`c8Links`: \{
\[`key`: `string`\]: `string`;
\};
`canLogout`: `boolean`;
`displayName`: `string` \| `null`;
`email`: `string` \| `null`;
`groups`: `string`[];
`roles`: `string`[];
`salesPlanType`: `string` \| `null`;
`tenants`: `object`[];
`username`: `string`;
\}\>

### getAuthHeaders()

```ts
getAuthHeaders(...a): Promise<{
[key: string]: string;
}>;
```

#### Parameters

##### a

...\[\]

#### Returns

`Promise`\<\{
\[`key`: `string`\]: `string`;
\}\>

### getAuthorization()

```ts
getAuthorization(...a): CancelablePromise<{
  authorizationKey: string;
  ownerId: string;
  ownerType: OwnerTypeEnum;
  permissionTypes: PermissionTypeEnum[];
  resourceId: string | null;
  resourcePropertyName: string | null;
  resourceType: ResourceTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`authorizationKey`: `string`;
`ownerId`: `string`;
`ownerType`: [`OwnerTypeEnum`](../type-aliases/OwnerTypeEnum.md);
`permissionTypes`: [`PermissionTypeEnum`](../type-aliases/PermissionTypeEnum.md)[];
`resourceId`: `string` \| `null`;
`resourcePropertyName`: `string` \| `null`;
`resourceType`: [`ResourceTypeEnum`](../type-aliases/ResourceTypeEnum.md);
\}\>

### getBackpressureState()

```ts
getBackpressureState(...a):
  | {
  backoffMs: number;
  consecutive: number;
  permitsCurrent: number;
  permitsMax: number | null;
  severity: BackpressureSeverity;
  waiters: number;
}
  | {
  consecutive: number;
  permitsCurrent: number;
  permitsMax: null;
  severity: string;
  waiters: number;
};
```

#### Parameters

##### a

...\[\]

#### Returns

\| \{
`backoffMs`: `number`;
`consecutive`: `number`;
`permitsCurrent`: `number`;
`permitsMax`: `number` \| `null`;
`severity`: [`BackpressureSeverity`](../type-aliases/BackpressureSeverity.md);
`waiters`: `number`;
\}
\| \{
`consecutive`: `number`;
`permitsCurrent`: `number`;
`permitsMax`: `null`;
`severity`: `string`;
`waiters`: `number`;
\}

### getBatchOperation()

```ts
getBatchOperation(...a): CancelablePromise<{
  actorId: string | null;
  actorType:   | AuditLogActorTypeEnum
     | null;
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
  endDate: string | null;
  errors: object[];
  operationsCompletedCount: number;
  operationsFailedCount: number;
  operationsTotalCount: number;
  startDate: string | null;
  state: BatchOperationStateEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`actorId`: `string` \| `null`;
`actorType`: \| [`AuditLogActorTypeEnum`](../type-aliases/AuditLogActorTypeEnum.md)
\| `null`;
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
`endDate`: `string` \| `null`;
`errors`: `object`[];
`operationsCompletedCount`: `number`;
`operationsFailedCount`: `number`;
`operationsTotalCount`: `number`;
`startDate`: `string` \| `null`;
`state`: [`BatchOperationStateEnum`](../type-aliases/BatchOperationStateEnum.md);
\}\>

### getConfig()

```ts
getConfig(...a): object;
```

#### Parameters

##### a

...\[\]

#### Returns

`object`

##### \_\_raw

```ts
readonly __raw: object;
```

###### Index Signature

```ts
[key: string]: string | undefined
```

##### auth

```ts
readonly auth: object;
```

###### auth.basic?

```ts
optional basic?: object;
```

###### auth.basic.password?

```ts
optional password?: string;
```

###### auth.basic.username?

```ts
optional username?: string;
```

###### auth.strategy

```ts
strategy: AuthStrategy;
```

##### backpressure

```ts
readonly backpressure: object;
```

###### backpressure.decayQuietMs

```ts
decayQuietMs: number;
```

###### backpressure.enabled

```ts
enabled: boolean;
```

###### backpressure.floor

```ts
floor: number;
```

###### backpressure.healthyRecoveryMultiplier

```ts
healthyRecoveryMultiplier: number;
```

###### backpressure.initialMax

```ts
initialMax: number;
```

###### backpressure.maxWaiters

```ts
maxWaiters: number;
```

###### backpressure.observeOnly

```ts
observeOnly: boolean;
```

###### backpressure.profile

```ts
profile: string;
```

###### backpressure.recoveryIntervalMs

```ts
recoveryIntervalMs: number;
```

###### backpressure.recoveryStep

```ts
recoveryStep: number;
```

###### backpressure.severeFactor

```ts
severeFactor: number;
```

###### backpressure.severeThreshold

```ts
severeThreshold: number;
```

###### backpressure.softFactor

```ts
softFactor: number;
```

###### backpressure.unlimitedAfterHealthyMs

```ts
unlimitedAfterHealthyMs: number;
```

##### defaultTenantId

```ts
readonly defaultTenantId: string;
```

##### eventual?

```ts
readonly optional eventual?: object;
```

###### eventual.pollDefaultMs

```ts
pollDefaultMs: number;
```

##### httpRetry

```ts
readonly httpRetry: object;
```

###### httpRetry.baseDelayMs

```ts
baseDelayMs: number;
```

###### httpRetry.maxAttempts

```ts
maxAttempts: number;
```

###### httpRetry.maxDelayMs

```ts
maxDelayMs: number;
```

##### logLevel

```ts
readonly logLevel: "trace" | "error" | "silent" | "warn" | "info" | "debug";
```

##### mtls?

```ts
readonly optional mtls?: object;
```

###### mtls.ca?

```ts
optional ca?: string;
```

###### mtls.caPath?

```ts
optional caPath?: string;
```

###### mtls.cert?

```ts
optional cert?: string;
```

###### mtls.certPath?

```ts
optional certPath?: string;
```

###### mtls.key?

```ts
optional key?: string;
```

###### mtls.keyPassphrase?

```ts
optional keyPassphrase?: string;
```

###### mtls.keyPath?

```ts
optional keyPath?: string;
```

##### oauth

```ts
readonly oauth: object;
```

###### oauth.cacheDir?

```ts
optional cacheDir?: string;
```

###### oauth.clientId?

```ts
optional clientId?: string;
```

###### oauth.clientSecret?

```ts
optional clientSecret?: string;
```

###### oauth.grantType

```ts
grantType: string;
```

###### oauth.oauthUrl

```ts
oauthUrl: string;
```

###### oauth.retry

```ts
retry: object;
```

###### oauth.retry.baseDelayMs

```ts
baseDelayMs: number;
```

###### oauth.retry.max

```ts
max: number;
```

###### oauth.scope?

```ts
optional scope?: string;
```

###### oauth.timeoutMs

```ts
timeoutMs: number;
```

##### restAddress

```ts
readonly restAddress: string;
```

##### supportLog?

```ts
readonly optional supportLog?: object;
```

###### supportLog.enabled

```ts
enabled: boolean;
```

###### supportLog.filePath

```ts
filePath: string;
```

##### telemetry?

```ts
readonly optional telemetry?: object;
```

###### telemetry.correlation

```ts
correlation: boolean;
```

###### telemetry.log

```ts
log: boolean;
```

##### tokenAudience

```ts
readonly tokenAudience: string;
```

##### validation

```ts
readonly validation: object;
```

###### validation.raw

```ts
raw: string;
```

###### validation.req

```ts
req: ValidationMode;
```

###### validation.res

```ts
res: ValidationMode;
```

##### workerDefaults?

```ts
readonly optional workerDefaults?: object;
```

###### workerDefaults.jobTimeoutMs?

```ts
optional jobTimeoutMs?: number;
```

###### workerDefaults.maxParallelJobs?

```ts
optional maxParallelJobs?: number;
```

###### workerDefaults.pollTimeoutMs?

```ts
optional pollTimeoutMs?: number;
```

###### workerDefaults.startupJitterMaxSeconds?

```ts
optional startupJitterMaxSeconds?: number;
```

###### workerDefaults.workerName?

```ts
optional workerName?: string;
```

### getDecisionDefinition()

```ts
getDecisionDefinition(...a): CancelablePromise<{
  decisionDefinitionId: string;
  decisionDefinitionKey: string;
  decisionRequirementsId: string;
  decisionRequirementsKey: string;
  decisionRequirementsName: string;
  decisionRequirementsVersion: number;
  name: string;
  tenantId: string;
  version: number;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`decisionDefinitionId`: `string`;
`decisionDefinitionKey`: `string`;
`decisionRequirementsId`: `string`;
`decisionRequirementsKey`: `string`;
`decisionRequirementsName`: `string`;
`decisionRequirementsVersion`: `number`;
`name`: `string`;
`tenantId`: `string`;
`version`: `number`;
\}\>

### getDecisionDefinitionXml()

```ts
getDecisionDefinitionXml(...a): CancelablePromise<string>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`string`\>

### getDecisionInstance()

```ts
getDecisionInstance(...a): CancelablePromise<{
  businessId:   | {
   [key: number]: string;
     __brand: "BusinessId";
   }
     | null;
  decisionDefinitionId: string;
  decisionDefinitionKey: string;
  decisionDefinitionName: string;
  decisionDefinitionType: DecisionDefinitionTypeEnum;
  decisionDefinitionVersion: number;
  decisionEvaluationInstanceKey: string;
  decisionEvaluationKey: string;
  elementInstanceKey:   | {
   [key: number]: string;
     __brand: "ElementInstanceKey";
   }
     | null;
  evaluatedInputs: object[];
  evaluationDate: string;
  evaluationFailure: string | null;
  matchedRules: object[];
  processDefinitionKey:   | {
   [key: number]: string;
     __brand: "ProcessDefinitionKey";
   }
     | null;
  processInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  result: string;
  rootDecisionDefinitionKey: string;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  state: DecisionInstanceStateEnum;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`businessId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"BusinessId"`;
\}
\| `null`;
`decisionDefinitionId`: `string`;
`decisionDefinitionKey`: `string`;
`decisionDefinitionName`: `string`;
`decisionDefinitionType`: [`DecisionDefinitionTypeEnum`](../type-aliases/DecisionDefinitionTypeEnum.md);
`decisionDefinitionVersion`: `number`;
`decisionEvaluationInstanceKey`: `string`;
`decisionEvaluationKey`: `string`;
`elementInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ElementInstanceKey"`;
\}
\| `null`;
`evaluatedInputs`: `object`[];
`evaluationDate`: `string`;
`evaluationFailure`: `string` \| `null`;
`matchedRules`: `object`[];
`processDefinitionKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessDefinitionKey"`;
\}
\| `null`;
`processInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`result`: `string`;
`rootDecisionDefinitionKey`: `string`;
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`state`: [`DecisionInstanceStateEnum`](../type-aliases/DecisionInstanceStateEnum.md);
`tenantId`: `string`;
\}\>

### getDecisionRequirements()

```ts
getDecisionRequirements(...a): CancelablePromise<{
  decisionRequirementsId: string;
  decisionRequirementsKey: string;
  decisionRequirementsName: string;
  resourceName: string;
  tenantId: string;
  version: number;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`decisionRequirementsId`: `string`;
`decisionRequirementsKey`: `string`;
`decisionRequirementsName`: `string`;
`resourceName`: `string`;
`tenantId`: `string`;
`version`: `number`;
\}\>

### getDecisionRequirementsXml()

```ts
getDecisionRequirementsXml(...a): CancelablePromise<string>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`string`\>

### getDocument()

```ts
getDocument(...a): CancelablePromise<{
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
\}\>

### getElementInstance()

```ts
getElementInstance(...a): CancelablePromise<{
  elementId: string;
  elementInstanceKey: string;
  elementName: string;
  endDate: string | null;
  hasIncident: boolean;
  incidentKey:   | {
   [key: number]: string;
     __brand: "IncidentKey";
   }
     | null;
  processDefinitionId: string;
  processDefinitionKey: string;
  processInstanceKey: string;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  startDate: string;
  state: ElementInstanceStateEnum;
  tenantId: string;
  type:   | "UNKNOWN"
     | "USER_TASK"
     | "UNSPECIFIED"
     | "PROCESS"
     | "SUB_PROCESS"
     | "EVENT_SUB_PROCESS"
     | "AD_HOC_SUB_PROCESS"
     | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
     | "START_EVENT"
     | "INTERMEDIATE_CATCH_EVENT"
     | "INTERMEDIATE_THROW_EVENT"
     | "BOUNDARY_EVENT"
     | "END_EVENT"
     | "SERVICE_TASK"
     | "RECEIVE_TASK"
     | "MANUAL_TASK"
     | "TASK"
     | "EXCLUSIVE_GATEWAY"
     | "INCLUSIVE_GATEWAY"
     | "PARALLEL_GATEWAY"
     | "EVENT_BASED_GATEWAY"
     | "SEQUENCE_FLOW"
     | "MULTI_INSTANCE_BODY"
     | "CALL_ACTIVITY"
     | "BUSINESS_RULE_TASK"
     | "SCRIPT_TASK"
     | "SEND_TASK";
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`elementId`: `string`;
`elementInstanceKey`: `string`;
`elementName`: `string`;
`endDate`: `string` \| `null`;
`hasIncident`: `boolean`;
`incidentKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"IncidentKey"`;
\}
\| `null`;
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`processInstanceKey`: `string`;
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`startDate`: `string`;
`state`: [`ElementInstanceStateEnum`](../type-aliases/ElementInstanceStateEnum.md);
`tenantId`: `string`;
`type`: \| `"UNKNOWN"`
\| `"USER_TASK"`
\| `"UNSPECIFIED"`
\| `"PROCESS"`
\| `"SUB_PROCESS"`
\| `"EVENT_SUB_PROCESS"`
\| `"AD_HOC_SUB_PROCESS"`
\| `"AD_HOC_SUB_PROCESS_INNER_INSTANCE"`
\| `"START_EVENT"`
\| `"INTERMEDIATE_CATCH_EVENT"`
\| `"INTERMEDIATE_THROW_EVENT"`
\| `"BOUNDARY_EVENT"`
\| `"END_EVENT"`
\| `"SERVICE_TASK"`
\| `"RECEIVE_TASK"`
\| `"MANUAL_TASK"`
\| `"TASK"`
\| `"EXCLUSIVE_GATEWAY"`
\| `"INCLUSIVE_GATEWAY"`
\| `"PARALLEL_GATEWAY"`
\| `"EVENT_BASED_GATEWAY"`
\| `"SEQUENCE_FLOW"`
\| `"MULTI_INSTANCE_BODY"`
\| `"CALL_ACTIVITY"`
\| `"BUSINESS_RULE_TASK"`
\| `"SCRIPT_TASK"`
\| `"SEND_TASK"`;
\}\>

### getErrorMode()

```ts
getErrorMode(...a): "throw" | "result";
```

#### Parameters

##### a

...\[\]

#### Returns

`"throw"` \| `"result"`

### getFormByKey()

```ts
getFormByKey(...a): CancelablePromise<{
  formId: string;
  formKey: string;
  schema: string;
  tenantId: string;
  version: number;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`formId`: `string`;
`formKey`: `string`;
`schema`: `string`;
`tenantId`: `string`;
`version`: `number`;
\}\>

### getGlobalClusterVariable()

```ts
getGlobalClusterVariable(...a): CancelablePromise<{
  name: string;
  scope: ClusterVariableScopeEnum;
  tenantId: string | null;
  value: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`scope`: [`ClusterVariableScopeEnum`](../type-aliases/ClusterVariableScopeEnum.md);
`tenantId`: `string` \| `null`;
`value`: `string`;
\}\>

### getGlobalJobStatistics()

```ts
getGlobalJobStatistics(...a): CancelablePromise<{
  completed: {
     count: number;
     lastUpdatedAt: string | null;
  };
  created: {
     count: number;
     lastUpdatedAt: string | null;
  };
  failed: {
     count: number;
     lastUpdatedAt: string | null;
  };
  isIncomplete: boolean;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`completed`: \{
`count`: `number`;
`lastUpdatedAt`: `string` \| `null`;
\};
`created`: \{
`count`: `number`;
`lastUpdatedAt`: `string` \| `null`;
\};
`failed`: \{
`count`: `number`;
`lastUpdatedAt`: `string` \| `null`;
\};
`isIncomplete`: `boolean`;
\}\>

### getGlobalTaskListener()

```ts
getGlobalTaskListener(...a): CancelablePromise<{
  afterNonGlobal?: boolean;
  eventTypes: GlobalTaskListenerEventTypeEnum[];
  id: string;
  priority?: number;
  retries?: number;
  source: GlobalListenerSourceEnum;
  type?: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`afterNonGlobal?`: `boolean`;
`eventTypes`: [`GlobalTaskListenerEventTypeEnum`](../type-aliases/GlobalTaskListenerEventTypeEnum.md)[];
`id`: `string`;
`priority?`: `number`;
`retries?`: `number`;
`source`: [`GlobalListenerSourceEnum`](../type-aliases/GlobalListenerSourceEnum.md);
`type?`: `string`;
\}\>

### getGroup()

```ts
getGroup(...a): CancelablePromise<{
  description: string | null;
  groupId: string;
  name: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`groupId`: `string`;
`name`: `string`;
\}\>

### getIncident()

```ts
getIncident(...a): CancelablePromise<{
  creationTime: string;
  elementId: string;
  elementInstanceKey: string;
  errorMessage: string;
  errorType: IncidentErrorTypeEnum;
  incidentKey: string;
  jobKey:   | {
   [key: number]: string;
     __brand: "JobKey";
   }
     | null;
  processDefinitionId: string;
  processDefinitionKey: string;
  processInstanceKey: string;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  state: IncidentStateEnum;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`creationTime`: `string`;
`elementId`: `string`;
`elementInstanceKey`: `string`;
`errorMessage`: `string`;
`errorType`: [`IncidentErrorTypeEnum`](../type-aliases/IncidentErrorTypeEnum.md);
`incidentKey`: `string`;
`jobKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"JobKey"`;
\}
\| `null`;
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`processInstanceKey`: `string`;
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`state`: [`IncidentStateEnum`](../type-aliases/IncidentStateEnum.md);
`tenantId`: `string`;
\}\>

### getJobErrorStatistics()

```ts
getJobErrorStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getJobTimeSeriesStatistics()

```ts
getJobTimeSeriesStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getJobTypeStatistics()

```ts
getJobTypeStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getJobWorkerStatistics()

```ts
getJobWorkerStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getLicense()

```ts
getLicense(...a): CancelablePromise<{
  expiresAt: string | null;
  isCommercial: boolean;
  licenseType: string;
  validLicense: boolean;
}>;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`expiresAt`: `string` \| `null`;
`isCommercial`: `boolean`;
`licenseType`: `string`;
`validLicense`: `boolean`;
\}\>

### getMappingRule()

```ts
getMappingRule(...a): CancelablePromise<{
  claimName: string;
  claimValue: string;
  mappingRuleId: string;
  name: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`claimName`: `string`;
`claimValue`: `string`;
`mappingRuleId`: `string`;
`name`: `string`;
\}\>

### getProcessDefinition()

```ts
getProcessDefinition(...a): CancelablePromise<{
  hasStartForm: boolean;
  name: string | null;
  processDefinitionId: string;
  processDefinitionKey: string;
  resourceName: string;
  tenantId: string;
  version: number;
  versionTag: string | null;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`hasStartForm`: `boolean`;
`name`: `string` \| `null`;
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`resourceName`: `string`;
`tenantId`: `string`;
`version`: `number`;
`versionTag`: `string` \| `null`;
\}\>

### getProcessDefinitionInstanceStatistics()

```ts
getProcessDefinitionInstanceStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getProcessDefinitionInstanceVersionStatistics()

```ts
getProcessDefinitionInstanceVersionStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getProcessDefinitionMessageSubscriptionStatistics()

```ts
getProcessDefinitionMessageSubscriptionStatistics(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getProcessDefinitionStatistics()

```ts
getProcessDefinitionStatistics(...a): CancelablePromise<{
  items: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
\}\>

### getProcessDefinitionXml()

```ts
getProcessDefinitionXml(...a): CancelablePromise<string>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`string`\>

### getProcessInstance()

```ts
getProcessInstance(...a): CancelablePromise<{
  businessId:   | {
   [key: number]: string;
     __brand: "BusinessId";
   }
     | null;
  endDate: string | null;
  hasIncident: boolean;
  parentElementInstanceKey:   | {
   [key: number]: string;
     __brand: "ElementInstanceKey";
   }
     | null;
  parentProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  processDefinitionId: string;
  processDefinitionKey: string;
  processDefinitionName: string | null;
  processDefinitionVersion: number;
  processDefinitionVersionTag: string | null;
  processInstanceKey: string;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  startDate: string;
  state: ProcessInstanceStateEnum;
  tags: string[];
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`businessId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"BusinessId"`;
\}
\| `null`;
`endDate`: `string` \| `null`;
`hasIncident`: `boolean`;
`parentElementInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ElementInstanceKey"`;
\}
\| `null`;
`parentProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`processDefinitionName`: `string` \| `null`;
`processDefinitionVersion`: `number`;
`processDefinitionVersionTag`: `string` \| `null`;
`processInstanceKey`: `string`;
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`startDate`: `string`;
`state`: [`ProcessInstanceStateEnum`](../type-aliases/ProcessInstanceStateEnum.md);
`tags`: `string`[];
`tenantId`: `string`;
\}\>

### getProcessInstanceCallHierarchy()

```ts
getProcessInstanceCallHierarchy(...a): CancelablePromise<object[]>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`object`[]\>

### getProcessInstanceSequenceFlows()

```ts
getProcessInstanceSequenceFlows(...a): CancelablePromise<{
  items: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
\}\>

### getProcessInstanceStatistics()

```ts
getProcessInstanceStatistics(...a): CancelablePromise<{
  items: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
\}\>

### getProcessInstanceStatisticsByDefinition()

```ts
getProcessInstanceStatisticsByDefinition(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getProcessInstanceStatisticsByError()

```ts
getProcessInstanceStatisticsByError(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### getProcessInstanceWaitStateStatistics()

```ts
getProcessInstanceWaitStateStatistics(...a): CancelablePromise<{
  items: object[];
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
\}\>

### getResource()

```ts
getResource(...a): CancelablePromise<{
  resourceId: string;
  resourceKey: string;
  resourceName: string;
  tenantId: string;
  version: number;
  versionTag: string | null;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`resourceId`: `string`;
`resourceKey`: `string`;
`resourceName`: `string`;
`tenantId`: `string`;
`version`: `number`;
`versionTag`: `string` \| `null`;
\}\>

### getResourceContent()

```ts
getResourceContent(...a): CancelablePromise<{
[key: string]: unknown;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
\[`key`: `string`\]: `unknown`;
\}\>

### getResourceContentBinary()

```ts
getResourceContentBinary(...a): CancelablePromise<{
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
\}\>

### getRole()

```ts
getRole(...a): CancelablePromise<{
  description: string | null;
  name: string;
  roleId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`name`: `string`;
`roleId`: `string`;
\}\>

### getStartProcessForm()

```ts
getStartProcessForm(...a): CancelablePromise<
  | void
  | {
  formId: string;
  formKey: string;
  schema: string;
  tenantId: string;
  version: number;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<
\| `void`
\| \{
`formId`: `string`;
`formKey`: `string`;
`schema`: `string`;
`tenantId`: `string`;
`version`: `number`;
\}\>

### getStatus()

```ts
getStatus(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### getSystemConfiguration()

```ts
getSystemConfiguration(...a): CancelablePromise<{
  authentication: {
     canLogout: boolean;
     isLoginDelegated: boolean;
  };
  cloud: {
     stage: CloudStage | null;
  };
  components: {
     active: WebappComponent[];
  };
  deployment: {
     isMultiTenancyEnabled: boolean;
     maxRequestSize: number;
  };
  jobMetrics: {
     enabled: boolean;
     exportInterval: string;
     maxJobTypeLength: number;
     maxTenantIdLength: number;
     maxUniqueKeys: number;
     maxWorkerNameLength: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`authentication`: \{
`canLogout`: `boolean`;
`isLoginDelegated`: `boolean`;
\};
`cloud`: \{
`stage`: [`CloudStage`](../type-aliases/CloudStage.md) \| `null`;
\};
`components`: \{
`active`: [`WebappComponent`](../type-aliases/WebappComponent.md)[];
\};
`deployment`: \{
`isMultiTenancyEnabled`: `boolean`;
`maxRequestSize`: `number`;
\};
`jobMetrics`: \{
`enabled`: `boolean`;
`exportInterval`: `string`;
`maxJobTypeLength`: `number`;
`maxTenantIdLength`: `number`;
`maxUniqueKeys`: `number`;
`maxWorkerNameLength`: `number`;
\};
\}\>

### getTenant()

```ts
getTenant(...a): CancelablePromise<{
  description: string | null;
  name: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`name`: `string`;
`tenantId`: `string`;
\}\>

### getTenantClusterVariable()

```ts
getTenantClusterVariable(...a): CancelablePromise<{
  name: string;
  scope: ClusterVariableScopeEnum;
  tenantId: string | null;
  value: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`scope`: [`ClusterVariableScopeEnum`](../type-aliases/ClusterVariableScopeEnum.md);
`tenantId`: `string` \| `null`;
`value`: `string`;
\}\>

### getTopology()

```ts
getTopology(...a): CancelablePromise<{
  brokers: object[];
  clusterId: string | null;
  clusterSize: number;
  gatewayVersion: string;
  lastCompletedChangeId: string;
  partitionsCount: number;
  replicationFactor: number;
}>;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`brokers`: `object`[];
`clusterId`: `string` \| `null`;
`clusterSize`: `number`;
`gatewayVersion`: `string`;
`lastCompletedChangeId`: `string`;
`partitionsCount`: `number`;
`replicationFactor`: `number`;
\}\>

### getUsageMetrics()

```ts
getUsageMetrics(...a): CancelablePromise<{
  activeTenants: number;
  assignees: number;
  decisionInstances: number;
  processInstances: number;
  tenants: {
   [key: string]: object;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`activeTenants`: `number`;
`assignees`: `number`;
`decisionInstances`: `number`;
`processInstances`: `number`;
`tenants`: \{
\[`key`: `string`\]: `object`;
\};
\}\>

### getUser()

```ts
getUser(...a): CancelablePromise<{
  email: string | null;
  name: string | null;
  username: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`email`: `string` \| `null`;
`name`: `string` \| `null`;
`username`: `string`;
\}\>

### getUserTask()

```ts
getUserTask(...a): CancelablePromise<{
  assignee: string | null;
  businessId:   | {
   [key: number]: string;
     __brand: "BusinessId";
   }
     | null;
  candidateGroups: string[];
  candidateUsers: string[];
  completionDate: string | null;
  creationDate: string;
  customHeaders: {
   [key: string]: string;
  };
  dueDate: string | null;
  elementId: string;
  elementInstanceKey: string;
  externalFormReference: string | null;
  followUpDate: string | null;
  formKey:   | {
   [key: number]: string;
     __brand: "FormKey";
   }
     | null;
  name: string | null;
  priority: number;
  processDefinitionId: string;
  processDefinitionKey: string;
  processDefinitionVersion: number;
  processInstanceKey: string;
  processName: string | null;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  state: UserTaskStateEnum;
  tags: string[];
  tenantId: string;
  userTaskKey: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`assignee`: `string` \| `null`;
`businessId`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"BusinessId"`;
\}
\| `null`;
`candidateGroups`: `string`[];
`candidateUsers`: `string`[];
`completionDate`: `string` \| `null`;
`creationDate`: `string`;
`customHeaders`: \{
\[`key`: `string`\]: `string`;
\};
`dueDate`: `string` \| `null`;
`elementId`: `string`;
`elementInstanceKey`: `string`;
`externalFormReference`: `string` \| `null`;
`followUpDate`: `string` \| `null`;
`formKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"FormKey"`;
\}
\| `null`;
`name`: `string` \| `null`;
`priority`: `number`;
`processDefinitionId`: `string`;
`processDefinitionKey`: `string`;
`processDefinitionVersion`: `number`;
`processInstanceKey`: `string`;
`processName`: `string` \| `null`;
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`state`: [`UserTaskStateEnum`](../type-aliases/UserTaskStateEnum.md);
`tags`: `string`[];
`tenantId`: `string`;
`userTaskKey`: `string`;
\}\>

### getUserTaskForm()

```ts
getUserTaskForm(...a): CancelablePromise<
  | void
  | {
  formId: string;
  formKey: string;
  schema: string;
  tenantId: string;
  version: number;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<
\| `void`
\| \{
`formId`: `string`;
`formKey`: `string`;
`schema`: `string`;
`tenantId`: `string`;
`version`: `number`;
\}\>

### getVariable()

```ts
getVariable(...a): CancelablePromise<{
  name: string;
  processInstanceKey: string;
  rootProcessInstanceKey:   | {
   [key: number]: string;
     __brand: "ProcessInstanceKey";
   }
     | null;
  scopeKey: string;
  tenantId: string;
  value: string;
  variableKey: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`processInstanceKey`: `string`;
`rootProcessInstanceKey`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"ProcessInstanceKey"`;
\}
\| `null`;
`scopeKey`: `string`;
`tenantId`: `string`;
`value`: `string`;
`variableKey`: `string`;
\}\>

### getWorkers()

```ts
getWorkers(...a): any[];
```

#### Parameters

##### a

...\[\]

#### Returns

`any`[]

### logger()

```ts
logger(...a): object;
```

#### Parameters

##### a

...\[`string`\]

#### Returns

`object`

##### code()

```ts
code(...a): void;
```

###### Parameters

###### a

...\[[`LogLevel`](../../logger/type-aliases/LogLevel.md), `string`, `string`, `any`\]

###### Returns

`void`

##### debug()

```ts
debug(...a): void;
```

###### Parameters

###### a

...`any`[]

###### Returns

`void`

##### error()

```ts
error(...a): void;
```

###### Parameters

###### a

...`any`[]

###### Returns

`void`

##### info()

```ts
info(...a): void;
```

###### Parameters

###### a

...`any`[]

###### Returns

`void`

##### level()

```ts
level(...a): LogLevel;
```

###### Parameters

###### a

...\[\]

###### Returns

[`LogLevel`](../../logger/type-aliases/LogLevel.md)

##### scope()

```ts
scope(...a): { level: () => LogLevel; setLevel: (level: LogLevel) => void; setTransport: (t?: ((e: { level: LogLevel; scope: string; ts: number; args: any[]; code?: string | undefined; data?: any; }) => void) | undefined) => void; ... 7 more ...; code: (level: LogLevel, code: string, msg: string, data?: any) => void; };
```

###### Parameters

###### a

...\[`string`\]

###### Returns

\{ level: () =\> LogLevel; setLevel: (level: LogLevel) =\> void; setTransport: (t?: ((e: \{ level: LogLevel; scope: string; ts: number; args: any\[\]; code?: string \| undefined; data?: any; \}) =\> void) \| undefined) =\> void; ... 7 more ...; code: (level: LogLevel, code: string, msg: string, data?: any) =\> void; \}

##### setLevel()

```ts
setLevel(...a): void;
```

###### Parameters

###### a

...\[[`LogLevel`](../../logger/type-aliases/LogLevel.md)\]

###### Returns

`void`

##### setTransport()

```ts
setTransport(...a): void;
```

###### Parameters

###### a

...\[(...`a`) => `void`\]

###### Returns

`void`

##### silly()

```ts
silly(...a): void;
```

###### Parameters

###### a

...`any`[]

###### Returns

`void`

##### trace()

```ts
trace(...a): void;
```

###### Parameters

###### a

...`any`[]

###### Returns

`void`

##### warn()

```ts
warn(...a): void;
```

###### Parameters

###### a

...`any`[]

###### Returns

`void`

### migrateProcessInstance()

```ts
migrateProcessInstance(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### migrateProcessInstancesBatchOperation()

```ts
migrateProcessInstancesBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### modifyProcessInstance()

```ts
modifyProcessInstance(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### modifyProcessInstancesBatchOperation()

```ts
modifyProcessInstancesBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### onAuthHeaders()

```ts
onAuthHeaders(...a): void;
```

#### Parameters

##### a

...\[(...`a`) =>
\| `Promise`\<\{
\[`key`: `string`\]: `string`;
\}\>
\| \{
\[`key`: `string`\]: `string`;
\}\]

#### Returns

`void`

### pinClock()

```ts
pinClock(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### publishMessage()

```ts
publishMessage(...a): CancelablePromise<{
  messageKey: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`messageKey`: `string`;
`tenantId`: `string`;
\}\>

### resetClock()

```ts
resetClock(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### resolveIncident()

```ts
resolveIncident(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### resolveIncidentsBatchOperation()

```ts
resolveIncidentsBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### resolveProcessInstanceIncidents()

```ts
resolveProcessInstanceIncidents(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### resumeBatchOperation()

```ts
resumeBatchOperation(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### searchAgentInstanceHistory()

```ts
searchAgentInstanceHistory(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchAgentInstances()

```ts
searchAgentInstances(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchAuditLogs()

```ts
searchAuditLogs(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchAuthorizations()

```ts
searchAuthorizations(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchBatchOperationItems()

```ts
searchBatchOperationItems(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchBatchOperations()

```ts
searchBatchOperations(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchClientsForGroup()

```ts
searchClientsForGroup(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchClientsForRole()

```ts
searchClientsForRole(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchClientsForTenant()

```ts
searchClientsForTenant(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchClusterVariables()

```ts
searchClusterVariables(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchCorrelatedMessageSubscriptions()

```ts
searchCorrelatedMessageSubscriptions(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchDecisionDefinitions()

```ts
searchDecisionDefinitions(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchDecisionInstances()

```ts
searchDecisionInstances(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchDecisionRequirements()

```ts
searchDecisionRequirements(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchElementInstanceIncidents()

```ts
searchElementInstanceIncidents(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchElementInstances()

```ts
searchElementInstances(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchElementInstanceWaitStates()

```ts
searchElementInstanceWaitStates(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchGlobalTaskListeners()

```ts
searchGlobalTaskListeners(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchGroupIdsForTenant()

```ts
searchGroupIdsForTenant(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchGroups()

```ts
searchGroups(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchGroupsForRole()

```ts
searchGroupsForRole(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchIncidents()

```ts
searchIncidents(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchJobs()

```ts
searchJobs(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchMappingRule()

```ts
searchMappingRule(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchMappingRulesForGroup()

```ts
searchMappingRulesForGroup(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchMappingRulesForRole()

```ts
searchMappingRulesForRole(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchMappingRulesForTenant()

```ts
searchMappingRulesForTenant(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchMessageSubscriptions()

```ts
searchMessageSubscriptions(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchProcessDefinitions()

```ts
searchProcessDefinitions(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchProcessInstanceIncidents()

```ts
searchProcessInstanceIncidents(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchProcessInstances()

```ts
searchProcessInstances(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchResources()

```ts
searchResources(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchRoles()

```ts
searchRoles(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchRolesForGroup()

```ts
searchRolesForGroup(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchRolesForTenant()

```ts
searchRolesForTenant(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchTenants()

```ts
searchTenants(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUsers()

```ts
searchUsers(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUsersForGroup()

```ts
searchUsersForGroup(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUsersForRole()

```ts
searchUsersForRole(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUsersForTenant()

```ts
searchUsersForTenant(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUserTaskAuditLogs()

```ts
searchUserTaskAuditLogs(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUserTaskEffectiveVariables()

```ts
searchUserTaskEffectiveVariables(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUserTasks()

```ts
searchUserTasks(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchUserTaskVariables()

```ts
searchUserTaskVariables(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchVariables()

```ts
searchVariables(...a): CancelablePromise<{
  items: object[];
  page: {
     endCursor:   | {
      [key: number]: string;
        __brand: "EndCursor";
      }
        | null;
     hasMoreTotalItems: boolean;
     startCursor:   | {
      [key: number]: string;
        __brand: "StartCursor";
      }
        | null;
     totalItems: number;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`items`: `object`[];
`page`: \{
`endCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"EndCursor"`;
\}
\| `null`;
`hasMoreTotalItems`: `boolean`;
`startCursor`: \| \{
\[`key`: `number`\]: `string`;
`__brand`: `"StartCursor"`;
\}
\| `null`;
`totalItems`: `number`;
\};
\}\>

### searchVariablesAsDto()

```ts
searchVariablesAsDto(...a): CancelablePromise<{
  raw: {
   [key: string]: unknown;
  };
  get: unknown;
  has: boolean;
  validate: {
   [key: string]: unknown;
  };
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`raw`: \{
\[`key`: `string`\]: `unknown`;
\};
`get`: `unknown`;
`has`: `boolean`;
`validate`: \{
\[`key`: `string`\]: `unknown`;
\};
\}\>

### stopAllWorkers()

```ts
stopAllWorkers(...a): void;
```

#### Parameters

##### a

...\[\]

#### Returns

`void`

### suspendBatchOperation()

```ts
suspendBatchOperation(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### throwJobError()

```ts
throwJobError(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignClientFromGroup()

```ts
unassignClientFromGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignClientFromTenant()

```ts
unassignClientFromTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignGroupFromTenant()

```ts
unassignGroupFromTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignMappingRuleFromGroup()

```ts
unassignMappingRuleFromGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignMappingRuleFromTenant()

```ts
unassignMappingRuleFromTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignRoleFromClient()

```ts
unassignRoleFromClient(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignRoleFromGroup()

```ts
unassignRoleFromGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignRoleFromMappingRule()

```ts
unassignRoleFromMappingRule(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignRoleFromTenant()

```ts
unassignRoleFromTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignRoleFromUser()

```ts
unassignRoleFromUser(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignUserFromGroup()

```ts
unassignUserFromGroup(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignUserFromTenant()

```ts
unassignUserFromTenant(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### unassignUserTask()

```ts
unassignUserTask(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### updateAgentInstance()

```ts
updateAgentInstance(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### updateAuthorization()

```ts
updateAuthorization(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[
\| \{
`authorizationKey`: `string`;
`ownerId`: `string`;
`ownerType`: [`OwnerTypeEnum`](../type-aliases/OwnerTypeEnum.md);
`permissionTypes`: [`PermissionTypeEnum`](../type-aliases/PermissionTypeEnum.md)[];
`resourceId`: `string`;
`resourceType`: [`ResourceTypeEnum`](../type-aliases/ResourceTypeEnum.md);
\}
\| \{
`authorizationKey`: `string`;
`ownerId`: `string`;
`ownerType`: [`OwnerTypeEnum`](../type-aliases/OwnerTypeEnum.md);
`permissionTypes`: [`PermissionTypeEnum`](../type-aliases/PermissionTypeEnum.md)[];
`resourcePropertyName`: `string`;
`resourceType`: [`ResourceTypeEnum`](../type-aliases/ResourceTypeEnum.md);
\}, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### updateGlobalClusterVariable()

```ts
updateGlobalClusterVariable(...a): CancelablePromise<{
  name: string;
  scope: ClusterVariableScopeEnum;
  tenantId: string | null;
  value: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`scope`: [`ClusterVariableScopeEnum`](../type-aliases/ClusterVariableScopeEnum.md);
`tenantId`: `string` \| `null`;
`value`: `string`;
\}\>

### updateGlobalTaskListener()

```ts
updateGlobalTaskListener(...a): CancelablePromise<{
  afterNonGlobal?: boolean;
  eventTypes: GlobalTaskListenerEventTypeEnum[];
  id: string;
  priority?: number;
  retries?: number;
  source: GlobalListenerSourceEnum;
  type?: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`afterNonGlobal?`: `boolean`;
`eventTypes`: [`GlobalTaskListenerEventTypeEnum`](../type-aliases/GlobalTaskListenerEventTypeEnum.md)[];
`id`: `string`;
`priority?`: `number`;
`retries?`: `number`;
`source`: [`GlobalListenerSourceEnum`](../type-aliases/GlobalListenerSourceEnum.md);
`type?`: `string`;
\}\>

### updateGroup()

```ts
updateGroup(...a): CancelablePromise<{
  description: string | null;
  groupId: string;
  name: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`groupId`: `string`;
`name`: `string`;
\}\>

### updateJob()

```ts
updateJob(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### updateJobsBatchOperation()

```ts
updateJobsBatchOperation(...a): CancelablePromise<{
  batchOperationKey: string;
  batchOperationType: BatchOperationTypeEnum;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`batchOperationKey`: `string`;
`batchOperationType`: [`BatchOperationTypeEnum`](../type-aliases/BatchOperationTypeEnum.md);
\}\>

### updateMappingRule()

```ts
updateMappingRule(...a): CancelablePromise<{
  claimName: string;
  claimValue: string;
  mappingRuleId: string;
  name: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`claimName`: `string`;
`claimValue`: `string`;
`mappingRuleId`: `string`;
`name`: `string`;
\}\>

### updateRole()

```ts
updateRole(...a): CancelablePromise<{
  description: string | null;
  name: string;
  roleId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`name`: `string`;
`roleId`: `string`;
\}\>

### updateTenant()

```ts
updateTenant(...a): CancelablePromise<{
  description: string | null;
  name: string;
  tenantId: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`description`: `string` \| `null`;
`name`: `string`;
`tenantId`: `string`;
\}\>

### updateTenantClusterVariable()

```ts
updateTenantClusterVariable(...a): CancelablePromise<{
  name: string;
  scope: ClusterVariableScopeEnum;
  tenantId: string | null;
  value: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`name`: `string`;
`scope`: [`ClusterVariableScopeEnum`](../type-aliases/ClusterVariableScopeEnum.md);
`tenantId`: `string` \| `null`;
`value`: `string`;
\}\>

### updateUser()

```ts
updateUser(...a): CancelablePromise<{
  email: string | null;
  name: string | null;
  username: string;
}>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<\{
`email`: `string` \| `null`;
`name`: `string` \| `null`;
`username`: `string`;
\}\>

### updateUserTask()

```ts
updateUserTask(...a): CancelablePromise<void>;
```

#### Parameters

##### a

...\[`object`, `object`\]

#### Returns

[`CancelablePromise`](../interfaces/CancelablePromise.md)\<`void`\>

### withCorrelation()

```ts
withCorrelation(...a): Promise<unknown>;
```

#### Parameters

##### a

...\[`string`, (...`a`) => `unknown`\]

#### Returns

`Promise`\<`unknown`\>

---

## Function: createCamundaFpClient()


```ts
function createCamundaFpClient(options?): CamundaFpClient;
```

**`Experimental`**

This feature under development and is not guaranteed to be fully tested or stable.

## Parameters

### options?

[`CamundaOptions`](../interfaces/CamundaOptions.md)

## Returns

[`CamundaFpClient`](../type-aliases/CamundaFpClient.md)

## Description

Camunda FP Client - a Task-Either compatible client. See the README and [this test](https://github.com/camunda/orchestration-cluster-api-js/blob/main/tests-integration/fp.test.ts) for example usage.

---

## Function: createCamundaResultClient()


```ts
function createCamundaResultClient(options?): CamundaResultClient;
```

**`Experimental`**

This feature is under development and is not guaranteed to be fully tested or stable.

## Parameters

### options?

[`CamundaOptions`](../interfaces/CamundaOptions.md)

## Returns

[`CamundaResultClient`](../type-aliases/CamundaResultClient.md)

## Description

Factory returning a proxy that mirrors the CamundaClient surface but never throws.
All async returning methods (Promise or CancelablePromise) are wrapped into Promise<Result<..>>.
Synchronous utility methods (e.g. logger(), getConfig()) are passed through unchanged.

---

## Function: isErr()


```ts
function isErr<T, E>(r): r is { error: E; ok: false };
```

## Type Parameters

### T

`T`

### E

`E`

## Parameters

### r

[`Result`](../type-aliases/Result.md)\<`T`, `E`\>

## Returns

`r is { error: E; ok: false }`

---

## Function: isLeft()


```ts
function isLeft<E, A>(e): e is Left<E>;
```

## Type Parameters

### E

`E`

### A

`A`

## Parameters

### e

[`Either`](../type-aliases/Either.md)\<`E`, `A`\>

## Returns

`e is Left<E>`

---

## Function: isOk()


```ts
function isOk<T, E>(r): r is { ok: true; value: T };
```

## Type Parameters

### T

`T`

### E

`E`

## Parameters

### r

[`Result`](../type-aliases/Result.md)\<`T`, `E`\>

## Returns

`r is { ok: true; value: T }`

---

## Function: isRight()


```ts
function isRight<E, A>(e): e is Right;
```

## Type Parameters

### E

`E`

### A

`A`

## Parameters

### e

[`Either`](../type-aliases/Either.md)\<`E`, `A`\>

## Returns

`e is Right`

---

## Function: isSdkError()


```ts
function isSdkError(e): e is SdkError;
```

## Parameters

### e

`unknown`

## Returns

`e is SdkError`

---

## Function: variableNamesFromSchema()


```ts
function variableNamesFromSchema(schema): string[];
```

The declared variable names, in declaration order. These key the `name $in [...]` filter.

Guards against non-schema inputs (e.g. a JS caller, or an `any` cast) so the failure is a clear,
actionable error rather than an opaque `Cannot read properties of undefined` deep in paging.

## Parameters

### schema

[`AnyVariableSchema`](../type-aliases/AnyVariableSchema.md)

## Returns

`string`[]

---

## index


## Namespaces

- [AgentHistoryItemKey](namespaces/AgentHistoryItemKey/index.md)
- [AgentInstanceKey](namespaces/AgentInstanceKey/index.md)
- [AuditLogEntityKey](namespaces/AuditLogEntityKey/index.md)
- [AuditLogKey](namespaces/AuditLogKey/index.md)
- [AuthorizationKey](namespaces/AuthorizationKey/index.md)
- [BatchOperationKey](namespaces/BatchOperationKey/index.md)
- [BusinessId](namespaces/BusinessId/index.md)
- [ClientId](namespaces/ClientId/index.md)
- [ClusterVariableName](namespaces/ClusterVariableName/index.md)
- [ConditionalEvaluationKey](namespaces/ConditionalEvaluationKey/index.md)
- [DecisionDefinitionId](namespaces/DecisionDefinitionId/index.md)
- [DecisionDefinitionKey](namespaces/DecisionDefinitionKey/index.md)
- [DecisionEvaluationInstanceKey](namespaces/DecisionEvaluationInstanceKey/index.md)
- [DecisionEvaluationKey](namespaces/DecisionEvaluationKey/index.md)
- [DecisionInstanceKey](namespaces/DecisionInstanceKey/index.md)
- [DecisionRequirementsKey](namespaces/DecisionRequirementsKey/index.md)
- [DeploymentKey](namespaces/DeploymentKey/index.md)
- [DocumentId](namespaces/DocumentId/index.md)
- [ElementId](namespaces/ElementId/index.md)
- [ElementInstanceKey](namespaces/ElementInstanceKey/index.md)
- [EndCursor](namespaces/EndCursor/index.md)
- [FormId](namespaces/FormId/index.md)
- [FormKey](namespaces/FormKey/index.md)
- [GlobalListenerId](namespaces/GlobalListenerId/index.md)
- [GroupId](namespaces/GroupId/index.md)
- [IncidentKey](namespaces/IncidentKey/index.md)
- [JobKey](namespaces/JobKey/index.md)
- [MappingRuleId](namespaces/MappingRuleId/index.md)
- [MessageKey](namespaces/MessageKey/index.md)
- [MessageSubscriptionKey](namespaces/MessageSubscriptionKey/index.md)
- [ProcessDefinitionId](namespaces/ProcessDefinitionId/index.md)
- [ProcessDefinitionKey](namespaces/ProcessDefinitionKey/index.md)
- [ProcessInstanceKey](namespaces/ProcessInstanceKey/index.md)
- [RoleId](namespaces/RoleId/index.md)
- [SignalKey](namespaces/SignalKey/index.md)
- [StartCursor](namespaces/StartCursor/index.md)
- [Tag](namespaces/Tag/index.md)
- [TenantId](namespaces/TenantId/index.md)
- [Username](namespaces/Username/index.md)
- [UserTaskKey](namespaces/UserTaskKey/index.md)
- [VariableKey](namespaces/VariableKey/index.md)

## Classes

- [CamundaClient](classes/CamundaClient.md)
- [CamundaValidationError](classes/CamundaValidationError.md)
- [CancelError](classes/CancelError.md)
- [EventualConsistencyTimeoutError](classes/EventualConsistencyTimeoutError.md)
- [TypedVariablesError](classes/TypedVariablesError.md)
- [VariableCollector](classes/VariableCollector.md)
- [VariableDeserializationError](classes/VariableDeserializationError.md)
- [VariableMap](classes/VariableMap.md)
- [VariableScopeCollisionError](classes/VariableScopeCollisionError.md)

## Interfaces

- [CamundaConfig](interfaces/CamundaConfig.md)
- [CamundaOptions](interfaces/CamundaOptions.md)
- [CancelablePromise](interfaces/CancelablePromise.md)
- [CreateLoggerOptions](interfaces/CreateLoggerOptions.md)
- [EnrichedActivatedJob](interfaces/EnrichedActivatedJob.md)
- [ExtendedDeploymentResult](interfaces/ExtendedDeploymentResult.md)
- [HttpRetryPolicy](interfaces/HttpRetryPolicy.md)
- [JobWorker](interfaces/JobWorker.md)
- [JobWorkerConfig](interfaces/JobWorkerConfig.md)
- [OperationOptions](interfaces/OperationOptions.md)
- [SupportLogger](interfaces/SupportLogger.md)
- [TelemetryHooks](interfaces/TelemetryHooks.md)
- [ThreadedJobWorker](interfaces/ThreadedJobWorker.md)
- [ThreadedJobWorkerConfig](interfaces/ThreadedJobWorkerConfig.md)
- [ThreadPool](interfaces/ThreadPool.md)
- [TypedVariableItem](interfaces/TypedVariableItem.md)
- [TypedVariablePage](interfaces/TypedVariablePage.md)

## Type Aliases

- [ActivateAdHocSubProcessActivitiesData](type-aliases/ActivateAdHocSubProcessActivitiesData.md)
- [ActivateAdHocSubProcessActivitiesError](type-aliases/ActivateAdHocSubProcessActivitiesError.md)
- [ActivateAdHocSubProcessActivitiesErrors](type-aliases/ActivateAdHocSubProcessActivitiesErrors.md)
- [activateAdHocSubProcessActivitiesInput](type-aliases/activateAdHocSubProcessActivitiesInput.md)
- [ActivateAdHocSubProcessActivitiesResponse](type-aliases/ActivateAdHocSubProcessActivitiesResponse.md)
- [ActivateAdHocSubProcessActivitiesResponses](type-aliases/ActivateAdHocSubProcessActivitiesResponses.md)
- [ActivatedJobResult](type-aliases/ActivatedJobResult.md)
- [ActivateJobsData](type-aliases/ActivateJobsData.md)
- [ActivateJobsError](type-aliases/ActivateJobsError.md)
- [ActivateJobsErrors](type-aliases/ActivateJobsErrors.md)
- [activateJobsInput](type-aliases/activateJobsInput.md)
- [ActivateJobsResponse](type-aliases/ActivateJobsResponse.md)
- [ActivateJobsResponses](type-aliases/ActivateJobsResponses.md)
- [AdHocSubProcessActivateActivitiesInstruction](type-aliases/AdHocSubProcessActivateActivitiesInstruction.md)
- [AdHocSubProcessActivateActivityReference](type-aliases/AdHocSubProcessActivateActivityReference.md)
- [AdvancedActorTypeFilter](type-aliases/AdvancedActorTypeFilter.md)
- [AdvancedAgentHistoryItemKeyFilter](type-aliases/AdvancedAgentHistoryItemKeyFilter.md)
- [AdvancedAgentInstanceHistoryCommitStatusFilter](type-aliases/AdvancedAgentInstanceHistoryCommitStatusFilter.md)
- [AdvancedAgentInstanceHistoryRoleFilter](type-aliases/AdvancedAgentInstanceHistoryRoleFilter.md)
- [AdvancedAgentInstanceKeyFilter](type-aliases/AdvancedAgentInstanceKeyFilter.md)
- [AdvancedAgentInstanceStatusFilter](type-aliases/AdvancedAgentInstanceStatusFilter.md)
- [AdvancedAuditLogEntityKeyFilter](type-aliases/AdvancedAuditLogEntityKeyFilter.md)
- [AdvancedAuditLogKeyFilter](type-aliases/AdvancedAuditLogKeyFilter.md)
- [AdvancedBatchOperationItemStateFilter](type-aliases/AdvancedBatchOperationItemStateFilter.md)
- [AdvancedBatchOperationStateFilter](type-aliases/AdvancedBatchOperationStateFilter.md)
- [AdvancedBatchOperationTypeFilter](type-aliases/AdvancedBatchOperationTypeFilter.md)
- [AdvancedCategoryFilter](type-aliases/AdvancedCategoryFilter.md)
- [AdvancedClusterVariableScopeFilter](type-aliases/AdvancedClusterVariableScopeFilter.md)
- [AdvancedDateTimeFilter](type-aliases/AdvancedDateTimeFilter.md)
- [AdvancedDecisionDefinitionKeyFilter](type-aliases/AdvancedDecisionDefinitionKeyFilter.md)
- [AdvancedDecisionEvaluationInstanceKeyFilter](type-aliases/AdvancedDecisionEvaluationInstanceKeyFilter.md)
- [AdvancedDecisionEvaluationKeyFilter](type-aliases/AdvancedDecisionEvaluationKeyFilter.md)
- [AdvancedDecisionInstanceStateFilter](type-aliases/AdvancedDecisionInstanceStateFilter.md)
- [AdvancedDecisionRequirementsKeyFilter](type-aliases/AdvancedDecisionRequirementsKeyFilter.md)
- [AdvancedDeploymentKeyFilter](type-aliases/AdvancedDeploymentKeyFilter.md)
- [AdvancedElementIdFilter](type-aliases/AdvancedElementIdFilter.md)
- [AdvancedElementInstanceKeyFilter](type-aliases/AdvancedElementInstanceKeyFilter.md)
- [AdvancedElementInstanceStateFilter](type-aliases/AdvancedElementInstanceStateFilter.md)
- [AdvancedEntityTypeFilter](type-aliases/AdvancedEntityTypeFilter.md)
- [AdvancedFormKeyFilter](type-aliases/AdvancedFormKeyFilter.md)
- [AdvancedGlobalListenerSourceFilter](type-aliases/AdvancedGlobalListenerSourceFilter.md)
- [AdvancedGlobalTaskListenerEventTypeFilter](type-aliases/AdvancedGlobalTaskListenerEventTypeFilter.md)
- [AdvancedIncidentErrorTypeFilter](type-aliases/AdvancedIncidentErrorTypeFilter.md)
- [AdvancedIncidentStateFilter](type-aliases/AdvancedIncidentStateFilter.md)
- [AdvancedIntegerFilter](type-aliases/AdvancedIntegerFilter.md)
- [AdvancedJobKeyFilter](type-aliases/AdvancedJobKeyFilter.md)
- [AdvancedJobKindFilter](type-aliases/AdvancedJobKindFilter.md)
- [AdvancedJobListenerEventTypeFilter](type-aliases/AdvancedJobListenerEventTypeFilter.md)
- [AdvancedJobStateFilter](type-aliases/AdvancedJobStateFilter.md)
- [AdvancedMessageSubscriptionKeyFilter](type-aliases/AdvancedMessageSubscriptionKeyFilter.md)
- [AdvancedMessageSubscriptionStateFilter](type-aliases/AdvancedMessageSubscriptionStateFilter.md)
- [AdvancedMessageSubscriptionTypeFilter](type-aliases/AdvancedMessageSubscriptionTypeFilter.md)
- [AdvancedOperationTypeFilter](type-aliases/AdvancedOperationTypeFilter.md)
- [AdvancedProcessDefinitionIdFilter](type-aliases/AdvancedProcessDefinitionIdFilter.md)
- [AdvancedProcessDefinitionKeyFilter](type-aliases/AdvancedProcessDefinitionKeyFilter.md)
- [AdvancedProcessInstanceKeyFilter](type-aliases/AdvancedProcessInstanceKeyFilter.md)
- [AdvancedProcessInstanceStateFilter](type-aliases/AdvancedProcessInstanceStateFilter.md)
- [AdvancedResourceKeyFilter](type-aliases/AdvancedResourceKeyFilter.md)
- [AdvancedResultFilter](type-aliases/AdvancedResultFilter.md)
- [AdvancedScopeKeyFilter](type-aliases/AdvancedScopeKeyFilter.md)
- [AdvancedStringFilter](type-aliases/AdvancedStringFilter.md)
- [AdvancedUserTaskStateFilter](type-aliases/AdvancedUserTaskStateFilter.md)
- [AdvancedVariableKeyFilter](type-aliases/AdvancedVariableKeyFilter.md)
- [AdvancedWaitStateElementTypeFilter](type-aliases/AdvancedWaitStateElementTypeFilter.md)
- [AdvancedWaitStateTypeFilter](type-aliases/AdvancedWaitStateTypeFilter.md)
- [AgentHistoryItemKey](type-aliases/AgentHistoryItemKey.md)
- [AgentHistoryItemKeyExactMatch](type-aliases/AgentHistoryItemKeyExactMatch.md)
- [AgentHistoryItemKeyFilterProperty](type-aliases/AgentHistoryItemKeyFilterProperty.md)
- [AgentInstanceCreationRequest](type-aliases/AgentInstanceCreationRequest.md)
- [AgentInstanceCreationResult](type-aliases/AgentInstanceCreationResult.md)
- [AgentInstanceDefinition](type-aliases/AgentInstanceDefinition.md)
- [AgentInstanceDocumentContent](type-aliases/AgentInstanceDocumentContent.md)
- [AgentInstanceFilter](type-aliases/AgentInstanceFilter.md)
- [AgentInstanceHistoryCommitStatusEnum](type-aliases/AgentInstanceHistoryCommitStatusEnum.md)
- [AgentInstanceHistoryCommitStatusExactMatch](type-aliases/AgentInstanceHistoryCommitStatusExactMatch.md)
- [AgentInstanceHistoryCommitStatusFilterProperty](type-aliases/AgentInstanceHistoryCommitStatusFilterProperty.md)
- [AgentInstanceHistoryFilter](type-aliases/AgentInstanceHistoryFilter.md)
- [AgentInstanceHistoryItemCreationResult](type-aliases/AgentInstanceHistoryItemCreationResult.md)
- [AgentInstanceHistoryItemMetrics](type-aliases/AgentInstanceHistoryItemMetrics.md)
- [AgentInstanceHistoryItemRequest](type-aliases/AgentInstanceHistoryItemRequest.md)
- [AgentInstanceHistoryItemResult](type-aliases/AgentInstanceHistoryItemResult.md)
- [AgentInstanceHistoryRoleEnum](type-aliases/AgentInstanceHistoryRoleEnum.md)
- [AgentInstanceHistoryRoleExactMatch](type-aliases/AgentInstanceHistoryRoleExactMatch.md)
- [AgentInstanceHistoryRoleFilterProperty](type-aliases/AgentInstanceHistoryRoleFilterProperty.md)
- [AgentInstanceHistorySearchQuery](type-aliases/AgentInstanceHistorySearchQuery.md)
- [AgentInstanceHistorySearchQueryResult](type-aliases/AgentInstanceHistorySearchQueryResult.md)
- [AgentInstanceHistorySearchQuerySortRequest](type-aliases/AgentInstanceHistorySearchQuerySortRequest.md)
- [AgentInstanceKey](type-aliases/AgentInstanceKey.md)
- [AgentInstanceKeyExactMatch](type-aliases/AgentInstanceKeyExactMatch.md)
- [AgentInstanceKeyFilterProperty](type-aliases/AgentInstanceKeyFilterProperty.md)
- [AgentInstanceLimits](type-aliases/AgentInstanceLimits.md)
- [AgentInstanceMessageContent](type-aliases/AgentInstanceMessageContent.md)
- [AgentInstanceMessageContentTypeEnum](type-aliases/AgentInstanceMessageContentTypeEnum.md)
- [AgentInstanceMetrics](type-aliases/AgentInstanceMetrics.md)
- [AgentInstanceMetricsDelta](type-aliases/AgentInstanceMetricsDelta.md)
- [AgentInstanceObjectContent](type-aliases/AgentInstanceObjectContent.md)
- [AgentInstanceResult](type-aliases/AgentInstanceResult.md)
- [AgentInstanceSearchQuery](type-aliases/AgentInstanceSearchQuery.md)
- [AgentInstanceSearchQueryResult](type-aliases/AgentInstanceSearchQueryResult.md)
- [AgentInstanceSearchQuerySortRequest](type-aliases/AgentInstanceSearchQuerySortRequest.md)
- [AgentInstanceStatusEnum](type-aliases/AgentInstanceStatusEnum.md)
- [AgentInstanceStatusExactMatch](type-aliases/AgentInstanceStatusExactMatch.md)
- [AgentInstanceStatusFilterProperty](type-aliases/AgentInstanceStatusFilterProperty.md)
- [AgentInstanceTextContent](type-aliases/AgentInstanceTextContent.md)
- [AgentInstanceToolCall](type-aliases/AgentInstanceToolCall.md)
- [AgentInstanceUpdateRequest](type-aliases/AgentInstanceUpdateRequest.md)
- [AgentInstanceUpdateStatusEnum](type-aliases/AgentInstanceUpdateStatusEnum.md)
- [AgentTool](type-aliases/AgentTool.md)
- [AncestorScopeInstruction](type-aliases/AncestorScopeInstruction.md)
- [AnyVariableSchema](type-aliases/AnyVariableSchema.md)
- [AssignClientToGroupData](type-aliases/AssignClientToGroupData.md)
- [AssignClientToGroupError](type-aliases/AssignClientToGroupError.md)
- [AssignClientToGroupErrors](type-aliases/AssignClientToGroupErrors.md)
- [assignClientToGroupInput](type-aliases/assignClientToGroupInput.md)
- [AssignClientToGroupResponse](type-aliases/AssignClientToGroupResponse.md)
- [AssignClientToGroupResponses](type-aliases/AssignClientToGroupResponses.md)
- [AssignClientToTenantData](type-aliases/AssignClientToTenantData.md)
- [AssignClientToTenantError](type-aliases/AssignClientToTenantError.md)
- [AssignClientToTenantErrors](type-aliases/AssignClientToTenantErrors.md)
- [assignClientToTenantInput](type-aliases/assignClientToTenantInput.md)
- [AssignClientToTenantResponse](type-aliases/AssignClientToTenantResponse.md)
- [AssignClientToTenantResponses](type-aliases/AssignClientToTenantResponses.md)
- [AssignGroupToTenantData](type-aliases/AssignGroupToTenantData.md)
- [AssignGroupToTenantError](type-aliases/AssignGroupToTenantError.md)
- [AssignGroupToTenantErrors](type-aliases/AssignGroupToTenantErrors.md)
- [assignGroupToTenantInput](type-aliases/assignGroupToTenantInput.md)
- [AssignGroupToTenantResponse](type-aliases/AssignGroupToTenantResponse.md)
- [AssignGroupToTenantResponses](type-aliases/AssignGroupToTenantResponses.md)
- [AssignMappingRuleToGroupData](type-aliases/AssignMappingRuleToGroupData.md)
- [AssignMappingRuleToGroupError](type-aliases/AssignMappingRuleToGroupError.md)
- [AssignMappingRuleToGroupErrors](type-aliases/AssignMappingRuleToGroupErrors.md)
- [assignMappingRuleToGroupInput](type-aliases/assignMappingRuleToGroupInput.md)
- [AssignMappingRuleToGroupResponse](type-aliases/AssignMappingRuleToGroupResponse.md)
- [AssignMappingRuleToGroupResponses](type-aliases/AssignMappingRuleToGroupResponses.md)
- [AssignMappingRuleToTenantData](type-aliases/AssignMappingRuleToTenantData.md)
- [AssignMappingRuleToTenantError](type-aliases/AssignMappingRuleToTenantError.md)
- [AssignMappingRuleToTenantErrors](type-aliases/AssignMappingRuleToTenantErrors.md)
- [assignMappingRuleToTenantInput](type-aliases/assignMappingRuleToTenantInput.md)
- [AssignMappingRuleToTenantResponse](type-aliases/AssignMappingRuleToTenantResponse.md)
- [AssignMappingRuleToTenantResponses](type-aliases/AssignMappingRuleToTenantResponses.md)
- [AssignRoleToClientData](type-aliases/AssignRoleToClientData.md)
- [AssignRoleToClientError](type-aliases/AssignRoleToClientError.md)
- [AssignRoleToClientErrors](type-aliases/AssignRoleToClientErrors.md)
- [assignRoleToClientInput](type-aliases/assignRoleToClientInput.md)
- [AssignRoleToClientResponse](type-aliases/AssignRoleToClientResponse.md)
- [AssignRoleToClientResponses](type-aliases/AssignRoleToClientResponses.md)
- [AssignRoleToGroupData](type-aliases/AssignRoleToGroupData.md)
- [AssignRoleToGroupError](type-aliases/AssignRoleToGroupError.md)
- [AssignRoleToGroupErrors](type-aliases/AssignRoleToGroupErrors.md)
- [assignRoleToGroupInput](type-aliases/assignRoleToGroupInput.md)
- [AssignRoleToGroupResponse](type-aliases/AssignRoleToGroupResponse.md)
- [AssignRoleToGroupResponses](type-aliases/AssignRoleToGroupResponses.md)
- [AssignRoleToMappingRuleData](type-aliases/AssignRoleToMappingRuleData.md)
- [AssignRoleToMappingRuleError](type-aliases/AssignRoleToMappingRuleError.md)
- [AssignRoleToMappingRuleErrors](type-aliases/AssignRoleToMappingRuleErrors.md)
- [assignRoleToMappingRuleInput](type-aliases/assignRoleToMappingRuleInput.md)
- [AssignRoleToMappingRuleResponse](type-aliases/AssignRoleToMappingRuleResponse.md)
- [AssignRoleToMappingRuleResponses](type-aliases/AssignRoleToMappingRuleResponses.md)
- [AssignRoleToTenantData](type-aliases/AssignRoleToTenantData.md)
- [AssignRoleToTenantError](type-aliases/AssignRoleToTenantError.md)
- [AssignRoleToTenantErrors](type-aliases/AssignRoleToTenantErrors.md)
- [assignRoleToTenantInput](type-aliases/assignRoleToTenantInput.md)
- [AssignRoleToTenantResponse](type-aliases/AssignRoleToTenantResponse.md)
- [AssignRoleToTenantResponses](type-aliases/AssignRoleToTenantResponses.md)
- [AssignRoleToUserData](type-aliases/AssignRoleToUserData.md)
- [AssignRoleToUserError](type-aliases/AssignRoleToUserError.md)
- [AssignRoleToUserErrors](type-aliases/AssignRoleToUserErrors.md)
- [assignRoleToUserInput](type-aliases/assignRoleToUserInput.md)
- [AssignRoleToUserResponse](type-aliases/AssignRoleToUserResponse.md)
- [AssignRoleToUserResponses](type-aliases/AssignRoleToUserResponses.md)
- [AssignUserTaskData](type-aliases/AssignUserTaskData.md)
- [AssignUserTaskError](type-aliases/AssignUserTaskError.md)
- [AssignUserTaskErrors](type-aliases/AssignUserTaskErrors.md)
- [assignUserTaskInput](type-aliases/assignUserTaskInput.md)
- [AssignUserTaskResponse](type-aliases/AssignUserTaskResponse.md)
- [AssignUserTaskResponses](type-aliases/AssignUserTaskResponses.md)
- [AssignUserToGroupData](type-aliases/AssignUserToGroupData.md)
- [AssignUserToGroupError](type-aliases/AssignUserToGroupError.md)
- [AssignUserToGroupErrors](type-aliases/AssignUserToGroupErrors.md)
- [assignUserToGroupInput](type-aliases/assignUserToGroupInput.md)
- [AssignUserToGroupResponse](type-aliases/AssignUserToGroupResponse.md)
- [AssignUserToGroupResponses](type-aliases/AssignUserToGroupResponses.md)
- [AssignUserToTenantData](type-aliases/AssignUserToTenantData.md)
- [AssignUserToTenantError](type-aliases/AssignUserToTenantError.md)
- [AssignUserToTenantErrors](type-aliases/AssignUserToTenantErrors.md)
- [assignUserToTenantInput](type-aliases/assignUserToTenantInput.md)
- [AssignUserToTenantResponse](type-aliases/AssignUserToTenantResponse.md)
- [AssignUserToTenantResponses](type-aliases/AssignUserToTenantResponses.md)
- [AuditLogActorTypeEnum](type-aliases/AuditLogActorTypeEnum.md)
- [AuditLogActorTypeExactMatch](type-aliases/AuditLogActorTypeExactMatch.md)
- [AuditLogActorTypeFilterProperty](type-aliases/AuditLogActorTypeFilterProperty.md)
- [AuditLogCategoryEnum](type-aliases/AuditLogCategoryEnum.md)
- [AuditLogEntityKey](type-aliases/AuditLogEntityKey.md)
- [AuditLogEntityKeyExactMatch](type-aliases/AuditLogEntityKeyExactMatch.md)
- [AuditLogEntityKeyFilterProperty](type-aliases/AuditLogEntityKeyFilterProperty.md)
- [AuditLogEntityTypeEnum](type-aliases/AuditLogEntityTypeEnum.md)
- [AuditLogFilter](type-aliases/AuditLogFilter.md)
- [AuditLogKey](type-aliases/AuditLogKey.md)
- [AuditLogKeyExactMatch](type-aliases/AuditLogKeyExactMatch.md)
- [AuditLogKeyFilterProperty](type-aliases/AuditLogKeyFilterProperty.md)
- [AuditLogOperationTypeEnum](type-aliases/AuditLogOperationTypeEnum.md)
- [AuditLogResult](type-aliases/AuditLogResult.md)
- [AuditLogResultEnum](type-aliases/AuditLogResultEnum.md)
- [AuditLogResultExactMatch](type-aliases/AuditLogResultExactMatch.md)
- [AuditLogResultFilterProperty](type-aliases/AuditLogResultFilterProperty.md)
- [AuditLogSearchQueryRequest](type-aliases/AuditLogSearchQueryRequest.md)
- [AuditLogSearchQueryResult](type-aliases/AuditLogSearchQueryResult.md)
- [AuditLogSearchQuerySortRequest](type-aliases/AuditLogSearchQuerySortRequest.md)
- [AuthenticationConfigurationResponse](type-aliases/AuthenticationConfigurationResponse.md)
- [AuthorizationCreateResult](type-aliases/AuthorizationCreateResult.md)
- [AuthorizationFilter](type-aliases/AuthorizationFilter.md)
- [AuthorizationIdBasedRequest](type-aliases/AuthorizationIdBasedRequest.md)
- [AuthorizationKey](type-aliases/AuthorizationKey.md)
- [AuthorizationPropertyBasedRequest](type-aliases/AuthorizationPropertyBasedRequest.md)
- [AuthorizationRequest](type-aliases/AuthorizationRequest.md)
- [AuthorizationResult](type-aliases/AuthorizationResult.md)
- [AuthorizationSearchQuery](type-aliases/AuthorizationSearchQuery.md)
- [AuthorizationSearchQuerySortRequest](type-aliases/AuthorizationSearchQuerySortRequest.md)
- [AuthorizationSearchResult](type-aliases/AuthorizationSearchResult.md)
- [AuthStrategy](type-aliases/AuthStrategy.md)
- [BackpressureSeverity](type-aliases/BackpressureSeverity.md)
- [BaseProcessInstanceFilterFields](type-aliases/BaseProcessInstanceFilterFields.md)
- [BaseWaitStateDetails](type-aliases/BaseWaitStateDetails.md)
- [BasicStringFilter](type-aliases/BasicStringFilter.md)
- [BasicStringFilterProperty](type-aliases/BasicStringFilterProperty.md)
- [BatchOperationCreatedResult](type-aliases/BatchOperationCreatedResult.md)
- [BatchOperationError](type-aliases/BatchOperationError.md)
- [BatchOperationFilter](type-aliases/BatchOperationFilter.md)
- [BatchOperationItemFilter](type-aliases/BatchOperationItemFilter.md)
- [BatchOperationItemResponse](type-aliases/BatchOperationItemResponse.md)
- [BatchOperationItemSearchQuery](type-aliases/BatchOperationItemSearchQuery.md)
- [BatchOperationItemSearchQueryResult](type-aliases/BatchOperationItemSearchQueryResult.md)
- [BatchOperationItemSearchQuerySortRequest](type-aliases/BatchOperationItemSearchQuerySortRequest.md)
- [BatchOperationItemStateEnum](type-aliases/BatchOperationItemStateEnum.md)
- [BatchOperationItemStateExactMatch](type-aliases/BatchOperationItemStateExactMatch.md)
- [BatchOperationItemStateFilterProperty](type-aliases/BatchOperationItemStateFilterProperty.md)
- [BatchOperationKey](type-aliases/BatchOperationKey.md)
- [BatchOperationResponse](type-aliases/BatchOperationResponse.md)
- [BatchOperationSearchQuery](type-aliases/BatchOperationSearchQuery.md)
- [BatchOperationSearchQueryResult](type-aliases/BatchOperationSearchQueryResult.md)
- [BatchOperationSearchQuerySortRequest](type-aliases/BatchOperationSearchQuerySortRequest.md)
- [BatchOperationStateEnum](type-aliases/BatchOperationStateEnum.md)
- [BatchOperationStateExactMatch](type-aliases/BatchOperationStateExactMatch.md)
- [BatchOperationStateFilterProperty](type-aliases/BatchOperationStateFilterProperty.md)
- [BatchOperationTypeEnum](type-aliases/BatchOperationTypeEnum.md)
- [BatchOperationTypeExactMatch](type-aliases/BatchOperationTypeExactMatch.md)
- [BatchOperationTypeFilterProperty](type-aliases/BatchOperationTypeFilterProperty.md)
- [BroadcastSignalData](type-aliases/BroadcastSignalData.md)
- [BroadcastSignalError](type-aliases/BroadcastSignalError.md)
- [BroadcastSignalErrors](type-aliases/BroadcastSignalErrors.md)
- [broadcastSignalInput](type-aliases/broadcastSignalInput.md)
- [BroadcastSignalResponse](type-aliases/BroadcastSignalResponse.md)
- [BroadcastSignalResponses](type-aliases/BroadcastSignalResponses.md)
- [BrokerInfo](type-aliases/BrokerInfo.md)
- [BusinessId](type-aliases/BusinessId.md)
- [CamundaClientLoose](type-aliases/CamundaClientLoose.md)
- [CamundaFpClient](type-aliases/CamundaFpClient.md)
- [CamundaKey](type-aliases/CamundaKey.md)
- [CamundaResultClient](type-aliases/CamundaResultClient.md)
- [CamundaUserResult](type-aliases/CamundaUserResult.md)
- [CancelBatchOperationData](type-aliases/CancelBatchOperationData.md)
- [CancelBatchOperationError](type-aliases/CancelBatchOperationError.md)
- [CancelBatchOperationErrors](type-aliases/CancelBatchOperationErrors.md)
- [cancelBatchOperationInput](type-aliases/cancelBatchOperationInput.md)
- [CancelBatchOperationResponse](type-aliases/CancelBatchOperationResponse.md)
- [CancelBatchOperationResponses](type-aliases/CancelBatchOperationResponses.md)
- [CancelProcessInstanceData](type-aliases/CancelProcessInstanceData.md)
- [CancelProcessInstanceError](type-aliases/CancelProcessInstanceError.md)
- [CancelProcessInstanceErrors](type-aliases/CancelProcessInstanceErrors.md)
- [cancelProcessInstanceInput](type-aliases/cancelProcessInstanceInput.md)
- [CancelProcessInstanceRequest](type-aliases/CancelProcessInstanceRequest.md)
- [CancelProcessInstanceResponse](type-aliases/CancelProcessInstanceResponse.md)
- [CancelProcessInstanceResponses](type-aliases/CancelProcessInstanceResponses.md)
- [CancelProcessInstancesBatchOperationData](type-aliases/CancelProcessInstancesBatchOperationData.md)
- [CancelProcessInstancesBatchOperationError](type-aliases/CancelProcessInstancesBatchOperationError.md)
- [CancelProcessInstancesBatchOperationErrors](type-aliases/CancelProcessInstancesBatchOperationErrors.md)
- [cancelProcessInstancesBatchOperationInput](type-aliases/cancelProcessInstancesBatchOperationInput.md)
- [CancelProcessInstancesBatchOperationResponse](type-aliases/CancelProcessInstancesBatchOperationResponse.md)
- [CancelProcessInstancesBatchOperationResponses](type-aliases/CancelProcessInstancesBatchOperationResponses.md)
- [CategoryExactMatch](type-aliases/CategoryExactMatch.md)
- [CategoryFilterProperty](type-aliases/CategoryFilterProperty.md)
- [Changeset](type-aliases/Changeset.md)
- [ClientId](type-aliases/ClientId.md)
- [ClientOptions](type-aliases/ClientOptions.md)
- [ClockPinRequest](type-aliases/ClockPinRequest.md)
- [CloudConfigurationResponse](type-aliases/CloudConfigurationResponse.md)
- [CloudStage](type-aliases/CloudStage.md)
- [ClusterVariableName](type-aliases/ClusterVariableName.md)
- [ClusterVariableResult](type-aliases/ClusterVariableResult.md)
- [ClusterVariableResultBase](type-aliases/ClusterVariableResultBase.md)
- [ClusterVariableScopeEnum](type-aliases/ClusterVariableScopeEnum.md)
- [ClusterVariableScopeExactMatch](type-aliases/ClusterVariableScopeExactMatch.md)
- [ClusterVariableScopeFilterProperty](type-aliases/ClusterVariableScopeFilterProperty.md)
- [ClusterVariableSearchQueryFilterRequest](type-aliases/ClusterVariableSearchQueryFilterRequest.md)
- [ClusterVariableSearchQueryRequest](type-aliases/ClusterVariableSearchQueryRequest.md)
- [ClusterVariableSearchQueryResult](type-aliases/ClusterVariableSearchQueryResult.md)
- [ClusterVariableSearchQuerySortRequest](type-aliases/ClusterVariableSearchQuerySortRequest.md)
- [ClusterVariableSearchResult](type-aliases/ClusterVariableSearchResult.md)
- [CompleteJobData](type-aliases/CompleteJobData.md)
- [CompleteJobError](type-aliases/CompleteJobError.md)
- [CompleteJobErrors](type-aliases/CompleteJobErrors.md)
- [completeJobInput](type-aliases/completeJobInput.md)
- [CompleteJobResponse](type-aliases/CompleteJobResponse.md)
- [CompleteJobResponses](type-aliases/CompleteJobResponses.md)
- [CompleteUserTaskData](type-aliases/CompleteUserTaskData.md)
- [CompleteUserTaskError](type-aliases/CompleteUserTaskError.md)
- [CompleteUserTaskErrors](type-aliases/CompleteUserTaskErrors.md)
- [completeUserTaskInput](type-aliases/completeUserTaskInput.md)
- [CompleteUserTaskResponse](type-aliases/CompleteUserTaskResponse.md)
- [CompleteUserTaskResponses](type-aliases/CompleteUserTaskResponses.md)
- [ComponentsConfigurationResponse](type-aliases/ComponentsConfigurationResponse.md)
- [ConditionalEvaluationInstruction](type-aliases/ConditionalEvaluationInstruction.md)
- [ConditionalEvaluationKey](type-aliases/ConditionalEvaluationKey.md)
- [ConditionWaitStateDetails](type-aliases/ConditionWaitStateDetails.md)
- [CorrelatedMessageSubscriptionFilter](type-aliases/CorrelatedMessageSubscriptionFilter.md)
- [CorrelatedMessageSubscriptionResult](type-aliases/CorrelatedMessageSubscriptionResult.md)
- [CorrelatedMessageSubscriptionSearchQuery](type-aliases/CorrelatedMessageSubscriptionSearchQuery.md)
- [CorrelatedMessageSubscriptionSearchQueryResult](type-aliases/CorrelatedMessageSubscriptionSearchQueryResult.md)
- [CorrelatedMessageSubscriptionSearchQuerySortRequest](type-aliases/CorrelatedMessageSubscriptionSearchQuerySortRequest.md)
- [CorrelateMessageData](type-aliases/CorrelateMessageData.md)
- [CorrelateMessageError](type-aliases/CorrelateMessageError.md)
- [CorrelateMessageErrors](type-aliases/CorrelateMessageErrors.md)
- [correlateMessageInput](type-aliases/correlateMessageInput.md)
- [CorrelateMessageResponse](type-aliases/CorrelateMessageResponse.md)
- [CorrelateMessageResponses](type-aliases/CorrelateMessageResponses.md)
- [CreateAdminUserData](type-aliases/CreateAdminUserData.md)
- [CreateAdminUserError](type-aliases/CreateAdminUserError.md)
- [CreateAdminUserErrors](type-aliases/CreateAdminUserErrors.md)
- [createAdminUserInput](type-aliases/createAdminUserInput.md)
- [CreateAdminUserResponse](type-aliases/CreateAdminUserResponse.md)
- [CreateAdminUserResponses](type-aliases/CreateAdminUserResponses.md)
- [CreateAgentInstanceData](type-aliases/CreateAgentInstanceData.md)
- [CreateAgentInstanceError](type-aliases/CreateAgentInstanceError.md)
- [CreateAgentInstanceErrors](type-aliases/CreateAgentInstanceErrors.md)
- [CreateAgentInstanceHistoryItemData](type-aliases/CreateAgentInstanceHistoryItemData.md)
- [CreateAgentInstanceHistoryItemError](type-aliases/CreateAgentInstanceHistoryItemError.md)
- [CreateAgentInstanceHistoryItemErrors](type-aliases/CreateAgentInstanceHistoryItemErrors.md)
- [createAgentInstanceHistoryItemInput](type-aliases/createAgentInstanceHistoryItemInput.md)
- [CreateAgentInstanceHistoryItemResponse](type-aliases/CreateAgentInstanceHistoryItemResponse.md)
- [CreateAgentInstanceHistoryItemResponses](type-aliases/CreateAgentInstanceHistoryItemResponses.md)
- [createAgentInstanceInput](type-aliases/createAgentInstanceInput.md)
- [CreateAgentInstanceResponse](type-aliases/CreateAgentInstanceResponse.md)
- [CreateAgentInstanceResponses](type-aliases/CreateAgentInstanceResponses.md)
- [CreateAuthorizationData](type-aliases/CreateAuthorizationData.md)
- [CreateAuthorizationError](type-aliases/CreateAuthorizationError.md)
- [CreateAuthorizationErrors](type-aliases/CreateAuthorizationErrors.md)
- [createAuthorizationInput](type-aliases/createAuthorizationInput.md)
- [CreateAuthorizationResponse](type-aliases/CreateAuthorizationResponse.md)
- [CreateAuthorizationResponses](type-aliases/CreateAuthorizationResponses.md)
- [CreateClusterVariableRequest](type-aliases/CreateClusterVariableRequest.md)
- [CreateDeploymentData](type-aliases/CreateDeploymentData.md)
- [CreateDeploymentError](type-aliases/CreateDeploymentError.md)
- [CreateDeploymentErrors](type-aliases/CreateDeploymentErrors.md)
- [createDeploymentInput](type-aliases/createDeploymentInput.md)
- [CreateDeploymentResponse](type-aliases/CreateDeploymentResponse.md)
- [CreateDeploymentResponses](type-aliases/CreateDeploymentResponses.md)
- [CreateDocumentData](type-aliases/CreateDocumentData.md)
- [CreateDocumentError](type-aliases/CreateDocumentError.md)
- [CreateDocumentErrors](type-aliases/CreateDocumentErrors.md)
- [createDocumentInput](type-aliases/createDocumentInput.md)
- [CreateDocumentLinkData](type-aliases/CreateDocumentLinkData.md)
- [CreateDocumentLinkError](type-aliases/CreateDocumentLinkError.md)
- [CreateDocumentLinkErrors](type-aliases/CreateDocumentLinkErrors.md)
- [createDocumentLinkInput](type-aliases/createDocumentLinkInput.md)
- [CreateDocumentLinkResponse](type-aliases/CreateDocumentLinkResponse.md)
- [CreateDocumentLinkResponses](type-aliases/CreateDocumentLinkResponses.md)
- [CreateDocumentResponse](type-aliases/CreateDocumentResponse.md)
- [CreateDocumentResponses](type-aliases/CreateDocumentResponses.md)
- [CreateDocumentsData](type-aliases/CreateDocumentsData.md)
- [CreateDocumentsError](type-aliases/CreateDocumentsError.md)
- [CreateDocumentsErrors](type-aliases/CreateDocumentsErrors.md)
- [createDocumentsInput](type-aliases/createDocumentsInput.md)
- [CreateDocumentsResponse](type-aliases/CreateDocumentsResponse.md)
- [CreateDocumentsResponses](type-aliases/CreateDocumentsResponses.md)
- [CreateElementInstanceVariablesData](type-aliases/CreateElementInstanceVariablesData.md)
- [CreateElementInstanceVariablesError](type-aliases/CreateElementInstanceVariablesError.md)
- [CreateElementInstanceVariablesErrors](type-aliases/CreateElementInstanceVariablesErrors.md)
- [createElementInstanceVariablesInput](type-aliases/createElementInstanceVariablesInput.md)
- [CreateElementInstanceVariablesResponse](type-aliases/CreateElementInstanceVariablesResponse.md)
- [CreateElementInstanceVariablesResponses](type-aliases/CreateElementInstanceVariablesResponses.md)
- [CreateGlobalClusterVariableData](type-aliases/CreateGlobalClusterVariableData.md)
- [CreateGlobalClusterVariableError](type-aliases/CreateGlobalClusterVariableError.md)
- [CreateGlobalClusterVariableErrors](type-aliases/CreateGlobalClusterVariableErrors.md)
- [createGlobalClusterVariableInput](type-aliases/createGlobalClusterVariableInput.md)
- [CreateGlobalClusterVariableResponse](type-aliases/CreateGlobalClusterVariableResponse.md)
- [CreateGlobalClusterVariableResponses](type-aliases/CreateGlobalClusterVariableResponses.md)
- [CreateGlobalTaskListenerData](type-aliases/CreateGlobalTaskListenerData.md)
- [CreateGlobalTaskListenerError](type-aliases/CreateGlobalTaskListenerError.md)
- [CreateGlobalTaskListenerErrors](type-aliases/CreateGlobalTaskListenerErrors.md)
- [createGlobalTaskListenerInput](type-aliases/createGlobalTaskListenerInput.md)
- [CreateGlobalTaskListenerRequest](type-aliases/CreateGlobalTaskListenerRequest.md)
- [CreateGlobalTaskListenerResponse](type-aliases/CreateGlobalTaskListenerResponse.md)
- [CreateGlobalTaskListenerResponses](type-aliases/CreateGlobalTaskListenerResponses.md)
- [CreateGroupData](type-aliases/CreateGroupData.md)
- [CreateGroupError](type-aliases/CreateGroupError.md)
- [CreateGroupErrors](type-aliases/CreateGroupErrors.md)
- [createGroupInput](type-aliases/createGroupInput.md)
- [CreateGroupResponse](type-aliases/CreateGroupResponse.md)
- [CreateGroupResponses](type-aliases/CreateGroupResponses.md)
- [CreateMappingRuleData](type-aliases/CreateMappingRuleData.md)
- [CreateMappingRuleError](type-aliases/CreateMappingRuleError.md)
- [CreateMappingRuleErrors](type-aliases/CreateMappingRuleErrors.md)
- [createMappingRuleInput](type-aliases/createMappingRuleInput.md)
- [CreateMappingRuleResponse](type-aliases/CreateMappingRuleResponse.md)
- [CreateMappingRuleResponses](type-aliases/CreateMappingRuleResponses.md)
- [CreateProcessInstanceData](type-aliases/CreateProcessInstanceData.md)
- [CreateProcessInstanceError](type-aliases/CreateProcessInstanceError.md)
- [CreateProcessInstanceErrors](type-aliases/CreateProcessInstanceErrors.md)
- [createProcessInstanceInput](type-aliases/createProcessInstanceInput.md)
- [CreateProcessInstanceResponse](type-aliases/CreateProcessInstanceResponse.md)
- [CreateProcessInstanceResponses](type-aliases/CreateProcessInstanceResponses.md)
- [CreateProcessInstanceResult](type-aliases/CreateProcessInstanceResult.md)
- [CreateRoleData](type-aliases/CreateRoleData.md)
- [CreateRoleError](type-aliases/CreateRoleError.md)
- [CreateRoleErrors](type-aliases/CreateRoleErrors.md)
- [createRoleInput](type-aliases/createRoleInput.md)
- [CreateRoleResponse](type-aliases/CreateRoleResponse.md)
- [CreateRoleResponses](type-aliases/CreateRoleResponses.md)
- [CreateTenantClusterVariableData](type-aliases/CreateTenantClusterVariableData.md)
- [CreateTenantClusterVariableError](type-aliases/CreateTenantClusterVariableError.md)
- [CreateTenantClusterVariableErrors](type-aliases/CreateTenantClusterVariableErrors.md)
- [createTenantClusterVariableInput](type-aliases/createTenantClusterVariableInput.md)
- [CreateTenantClusterVariableResponse](type-aliases/CreateTenantClusterVariableResponse.md)
- [CreateTenantClusterVariableResponses](type-aliases/CreateTenantClusterVariableResponses.md)
- [CreateTenantData](type-aliases/CreateTenantData.md)
- [CreateTenantError](type-aliases/CreateTenantError.md)
- [CreateTenantErrors](type-aliases/CreateTenantErrors.md)
- [createTenantInput](type-aliases/createTenantInput.md)
- [CreateTenantResponse](type-aliases/CreateTenantResponse.md)
- [CreateTenantResponses](type-aliases/CreateTenantResponses.md)
- [CreateUserData](type-aliases/CreateUserData.md)
- [CreateUserError](type-aliases/CreateUserError.md)
- [CreateUserErrors](type-aliases/CreateUserErrors.md)
- [createUserInput](type-aliases/createUserInput.md)
- [CreateUserResponse](type-aliases/CreateUserResponse.md)
- [CreateUserResponses](type-aliases/CreateUserResponses.md)
- [CursorBackwardPagination](type-aliases/CursorBackwardPagination.md)
- [CursorForwardPagination](type-aliases/CursorForwardPagination.md)
- [DateTimeFilterProperty](type-aliases/DateTimeFilterProperty.md)
- [DecisionDefinitionFilter](type-aliases/DecisionDefinitionFilter.md)
- [DecisionDefinitionId](type-aliases/DecisionDefinitionId.md)
- [DecisionDefinitionKey](type-aliases/DecisionDefinitionKey.md)
- [DecisionDefinitionKeyExactMatch](type-aliases/DecisionDefinitionKeyExactMatch.md)
- [DecisionDefinitionKeyFilterProperty](type-aliases/DecisionDefinitionKeyFilterProperty.md)
- [DecisionDefinitionResult](type-aliases/DecisionDefinitionResult.md)
- [DecisionDefinitionSearchQuery](type-aliases/DecisionDefinitionSearchQuery.md)
- [DecisionDefinitionSearchQueryResult](type-aliases/DecisionDefinitionSearchQueryResult.md)
- [DecisionDefinitionSearchQuerySortRequest](type-aliases/DecisionDefinitionSearchQuerySortRequest.md)
- [DecisionDefinitionTypeEnum](type-aliases/DecisionDefinitionTypeEnum.md)
- [DecisionEvaluationById](type-aliases/DecisionEvaluationById.md)
- [DecisionEvaluationByKey](type-aliases/DecisionEvaluationByKey.md)
- [DecisionEvaluationInstanceKey](type-aliases/DecisionEvaluationInstanceKey.md)
- [DecisionEvaluationInstanceKeyExactMatch](type-aliases/DecisionEvaluationInstanceKeyExactMatch.md)
- [DecisionEvaluationInstanceKeyFilterProperty](type-aliases/DecisionEvaluationInstanceKeyFilterProperty.md)
- [DecisionEvaluationInstruction](type-aliases/DecisionEvaluationInstruction.md)
- [DecisionEvaluationKey](type-aliases/DecisionEvaluationKey.md)
- [DecisionEvaluationKeyExactMatch](type-aliases/DecisionEvaluationKeyExactMatch.md)
- [DecisionEvaluationKeyFilterProperty](type-aliases/DecisionEvaluationKeyFilterProperty.md)
- [DecisionInstanceDeletionBatchOperationRequest](type-aliases/DecisionInstanceDeletionBatchOperationRequest.md)
- [DecisionInstanceFilter](type-aliases/DecisionInstanceFilter.md)
- [DecisionInstanceGetQueryResult](type-aliases/DecisionInstanceGetQueryResult.md)
- [DecisionInstanceKey](type-aliases/DecisionInstanceKey.md)
- [DecisionInstanceResult](type-aliases/DecisionInstanceResult.md)
- [DecisionInstanceSearchQuery](type-aliases/DecisionInstanceSearchQuery.md)
- [DecisionInstanceSearchQueryResult](type-aliases/DecisionInstanceSearchQueryResult.md)
- [DecisionInstanceSearchQuerySortRequest](type-aliases/DecisionInstanceSearchQuerySortRequest.md)
- [DecisionInstanceStateEnum](type-aliases/DecisionInstanceStateEnum.md)
- [DecisionInstanceStateExactMatch](type-aliases/DecisionInstanceStateExactMatch.md)
- [DecisionInstanceStateFilterProperty](type-aliases/DecisionInstanceStateFilterProperty.md)
- [DecisionRequirementsFilter](type-aliases/DecisionRequirementsFilter.md)
- [DecisionRequirementsKey](type-aliases/DecisionRequirementsKey.md)
- [DecisionRequirementsKeyExactMatch](type-aliases/DecisionRequirementsKeyExactMatch.md)
- [DecisionRequirementsKeyFilterProperty](type-aliases/DecisionRequirementsKeyFilterProperty.md)
- [DecisionRequirementsResult](type-aliases/DecisionRequirementsResult.md)
- [DecisionRequirementsSearchQuery](type-aliases/DecisionRequirementsSearchQuery.md)
- [DecisionRequirementsSearchQueryResult](type-aliases/DecisionRequirementsSearchQueryResult.md)
- [DecisionRequirementsSearchQuerySortRequest](type-aliases/DecisionRequirementsSearchQuerySortRequest.md)
- [DeleteAuthorizationData](type-aliases/DeleteAuthorizationData.md)
- [DeleteAuthorizationError](type-aliases/DeleteAuthorizationError.md)
- [DeleteAuthorizationErrors](type-aliases/DeleteAuthorizationErrors.md)
- [deleteAuthorizationInput](type-aliases/deleteAuthorizationInput.md)
- [DeleteAuthorizationResponse](type-aliases/DeleteAuthorizationResponse.md)
- [DeleteAuthorizationResponses](type-aliases/DeleteAuthorizationResponses.md)
- [DeleteDecisionInstanceData](type-aliases/DeleteDecisionInstanceData.md)
- [DeleteDecisionInstanceError](type-aliases/DeleteDecisionInstanceError.md)
- [DeleteDecisionInstanceErrors](type-aliases/DeleteDecisionInstanceErrors.md)
- [deleteDecisionInstanceInput](type-aliases/deleteDecisionInstanceInput.md)
- [DeleteDecisionInstanceRequest](type-aliases/DeleteDecisionInstanceRequest.md)
- [DeleteDecisionInstanceResponse](type-aliases/DeleteDecisionInstanceResponse.md)
- [DeleteDecisionInstanceResponses](type-aliases/DeleteDecisionInstanceResponses.md)
- [DeleteDecisionInstancesBatchOperationData](type-aliases/DeleteDecisionInstancesBatchOperationData.md)
- [DeleteDecisionInstancesBatchOperationError](type-aliases/DeleteDecisionInstancesBatchOperationError.md)
- [DeleteDecisionInstancesBatchOperationErrors](type-aliases/DeleteDecisionInstancesBatchOperationErrors.md)
- [deleteDecisionInstancesBatchOperationInput](type-aliases/deleteDecisionInstancesBatchOperationInput.md)
- [DeleteDecisionInstancesBatchOperationResponse](type-aliases/DeleteDecisionInstancesBatchOperationResponse.md)
- [DeleteDecisionInstancesBatchOperationResponses](type-aliases/DeleteDecisionInstancesBatchOperationResponses.md)
- [DeleteDocumentData](type-aliases/DeleteDocumentData.md)
- [DeleteDocumentError](type-aliases/DeleteDocumentError.md)
- [DeleteDocumentErrors](type-aliases/DeleteDocumentErrors.md)
- [deleteDocumentInput](type-aliases/deleteDocumentInput.md)
- [DeleteDocumentResponse](type-aliases/DeleteDocumentResponse.md)
- [DeleteDocumentResponses](type-aliases/DeleteDocumentResponses.md)
- [DeleteGlobalClusterVariableData](type-aliases/DeleteGlobalClusterVariableData.md)
- [DeleteGlobalClusterVariableError](type-aliases/DeleteGlobalClusterVariableError.md)
- [DeleteGlobalClusterVariableErrors](type-aliases/DeleteGlobalClusterVariableErrors.md)
- [deleteGlobalClusterVariableInput](type-aliases/deleteGlobalClusterVariableInput.md)
- [DeleteGlobalClusterVariableResponse](type-aliases/DeleteGlobalClusterVariableResponse.md)
- [DeleteGlobalClusterVariableResponses](type-aliases/DeleteGlobalClusterVariableResponses.md)
- [DeleteGlobalTaskListenerData](type-aliases/DeleteGlobalTaskListenerData.md)
- [DeleteGlobalTaskListenerError](type-aliases/DeleteGlobalTaskListenerError.md)
- [DeleteGlobalTaskListenerErrors](type-aliases/DeleteGlobalTaskListenerErrors.md)
- [deleteGlobalTaskListenerInput](type-aliases/deleteGlobalTaskListenerInput.md)
- [DeleteGlobalTaskListenerResponse](type-aliases/DeleteGlobalTaskListenerResponse.md)
- [DeleteGlobalTaskListenerResponses](type-aliases/DeleteGlobalTaskListenerResponses.md)
- [DeleteGroupData](type-aliases/DeleteGroupData.md)
- [DeleteGroupError](type-aliases/DeleteGroupError.md)
- [DeleteGroupErrors](type-aliases/DeleteGroupErrors.md)
- [deleteGroupInput](type-aliases/deleteGroupInput.md)
- [DeleteGroupResponse](type-aliases/DeleteGroupResponse.md)
- [DeleteGroupResponses](type-aliases/DeleteGroupResponses.md)
- [DeleteMappingRuleData](type-aliases/DeleteMappingRuleData.md)
- [DeleteMappingRuleError](type-aliases/DeleteMappingRuleError.md)
- [DeleteMappingRuleErrors](type-aliases/DeleteMappingRuleErrors.md)
- [deleteMappingRuleInput](type-aliases/deleteMappingRuleInput.md)
- [DeleteMappingRuleResponse](type-aliases/DeleteMappingRuleResponse.md)
- [DeleteMappingRuleResponses](type-aliases/DeleteMappingRuleResponses.md)
- [DeleteProcessInstanceData](type-aliases/DeleteProcessInstanceData.md)
- [DeleteProcessInstanceError](type-aliases/DeleteProcessInstanceError.md)
- [DeleteProcessInstanceErrors](type-aliases/DeleteProcessInstanceErrors.md)
- [deleteProcessInstanceInput](type-aliases/deleteProcessInstanceInput.md)
- [DeleteProcessInstanceRequest](type-aliases/DeleteProcessInstanceRequest.md)
- [DeleteProcessInstanceResponse](type-aliases/DeleteProcessInstanceResponse.md)
- [DeleteProcessInstanceResponses](type-aliases/DeleteProcessInstanceResponses.md)
- [DeleteProcessInstancesBatchOperationData](type-aliases/DeleteProcessInstancesBatchOperationData.md)
- [DeleteProcessInstancesBatchOperationError](type-aliases/DeleteProcessInstancesBatchOperationError.md)
- [DeleteProcessInstancesBatchOperationErrors](type-aliases/DeleteProcessInstancesBatchOperationErrors.md)
- [deleteProcessInstancesBatchOperationInput](type-aliases/deleteProcessInstancesBatchOperationInput.md)
- [DeleteProcessInstancesBatchOperationResponse](type-aliases/DeleteProcessInstancesBatchOperationResponse.md)
- [DeleteProcessInstancesBatchOperationResponses](type-aliases/DeleteProcessInstancesBatchOperationResponses.md)
- [DeleteResourceData](type-aliases/DeleteResourceData.md)
- [DeleteResourceError](type-aliases/DeleteResourceError.md)
- [DeleteResourceErrors](type-aliases/DeleteResourceErrors.md)
- [deleteResourceInput](type-aliases/deleteResourceInput.md)
- [DeleteResourceRequest](type-aliases/DeleteResourceRequest.md)
- [DeleteResourceResponse](type-aliases/DeleteResourceResponse.md)
- [DeleteResourceResponse2](type-aliases/DeleteResourceResponse2.md)
- [DeleteResourceResponses](type-aliases/DeleteResourceResponses.md)
- [DeleteRoleData](type-aliases/DeleteRoleData.md)
- [DeleteRoleError](type-aliases/DeleteRoleError.md)
- [DeleteRoleErrors](type-aliases/DeleteRoleErrors.md)
- [deleteRoleInput](type-aliases/deleteRoleInput.md)
- [DeleteRoleResponse](type-aliases/DeleteRoleResponse.md)
- [DeleteRoleResponses](type-aliases/DeleteRoleResponses.md)
- [DeleteTenantClusterVariableData](type-aliases/DeleteTenantClusterVariableData.md)
- [DeleteTenantClusterVariableError](type-aliases/DeleteTenantClusterVariableError.md)
- [DeleteTenantClusterVariableErrors](type-aliases/DeleteTenantClusterVariableErrors.md)
- [deleteTenantClusterVariableInput](type-aliases/deleteTenantClusterVariableInput.md)
- [DeleteTenantClusterVariableResponse](type-aliases/DeleteTenantClusterVariableResponse.md)
- [DeleteTenantClusterVariableResponses](type-aliases/DeleteTenantClusterVariableResponses.md)
- [DeleteTenantData](type-aliases/DeleteTenantData.md)
- [DeleteTenantError](type-aliases/DeleteTenantError.md)
- [DeleteTenantErrors](type-aliases/DeleteTenantErrors.md)
- [deleteTenantInput](type-aliases/deleteTenantInput.md)
- [DeleteTenantResponse](type-aliases/DeleteTenantResponse.md)
- [DeleteTenantResponses](type-aliases/DeleteTenantResponses.md)
- [DeleteUserData](type-aliases/DeleteUserData.md)
- [DeleteUserError](type-aliases/DeleteUserError.md)
- [DeleteUserErrors](type-aliases/DeleteUserErrors.md)
- [deleteUserInput](type-aliases/deleteUserInput.md)
- [DeleteUserResponse](type-aliases/DeleteUserResponse.md)
- [DeleteUserResponses](type-aliases/DeleteUserResponses.md)
- [DeploymentConfigurationResponse](type-aliases/DeploymentConfigurationResponse.md)
- [DeploymentDecisionRequirementsResult](type-aliases/DeploymentDecisionRequirementsResult.md)
- [DeploymentDecisionResult](type-aliases/DeploymentDecisionResult.md)
- [DeploymentFormResult](type-aliases/DeploymentFormResult.md)
- [DeploymentKey](type-aliases/DeploymentKey.md)
- [DeploymentKeyExactMatch](type-aliases/DeploymentKeyExactMatch.md)
- [DeploymentKeyFilterProperty](type-aliases/DeploymentKeyFilterProperty.md)
- [DeploymentMetadataResult](type-aliases/DeploymentMetadataResult.md)
- [DeploymentProcessResult](type-aliases/DeploymentProcessResult.md)
- [DeploymentResourceResult](type-aliases/DeploymentResourceResult.md)
- [DeploymentResult](type-aliases/DeploymentResult.md)
- [DirectAncestorKeyInstruction](type-aliases/DirectAncestorKeyInstruction.md)
- [DocumentCreationBatchResponse](type-aliases/DocumentCreationBatchResponse.md)
- [DocumentCreationFailureDetail](type-aliases/DocumentCreationFailureDetail.md)
- [DocumentId](type-aliases/DocumentId.md)
- [DocumentLink](type-aliases/DocumentLink.md)
- [DocumentLinkRequest](type-aliases/DocumentLinkRequest.md)
- [DocumentMetadata](type-aliases/DocumentMetadata.md)
- [DocumentMetadataResponse](type-aliases/DocumentMetadataResponse.md)
- [DocumentReference](type-aliases/DocumentReference.md)
- [Either](type-aliases/Either.md)
- [ElementId](type-aliases/ElementId.md)
- [ElementIdExactMatch](type-aliases/ElementIdExactMatch.md)
- [ElementIdFilterProperty](type-aliases/ElementIdFilterProperty.md)
- [ElementInstanceFilter](type-aliases/ElementInstanceFilter.md)
- [ElementInstanceFilterFields](type-aliases/ElementInstanceFilterFields.md)
- [ElementInstanceKey](type-aliases/ElementInstanceKey.md)
- [ElementInstanceKeyExactMatch](type-aliases/ElementInstanceKeyExactMatch.md)
- [ElementInstanceKeyFilterProperty](type-aliases/ElementInstanceKeyFilterProperty.md)
- [ElementInstanceResult](type-aliases/ElementInstanceResult.md)
- [ElementInstanceSearchQuery](type-aliases/ElementInstanceSearchQuery.md)
- [ElementInstanceSearchQueryResult](type-aliases/ElementInstanceSearchQueryResult.md)
- [ElementInstanceSearchQuerySortRequest](type-aliases/ElementInstanceSearchQuerySortRequest.md)
- [ElementInstanceStateEnum](type-aliases/ElementInstanceStateEnum.md)
- [ElementInstanceStateExactMatch](type-aliases/ElementInstanceStateExactMatch.md)
- [ElementInstanceStateFilterProperty](type-aliases/ElementInstanceStateFilterProperty.md)
- [ElementInstanceWaitStateFilter](type-aliases/ElementInstanceWaitStateFilter.md)
- [ElementInstanceWaitStateQuery](type-aliases/ElementInstanceWaitStateQuery.md)
- [ElementInstanceWaitStateQueryResult](type-aliases/ElementInstanceWaitStateQueryResult.md)
- [ElementInstanceWaitStateQuerySortRequest](type-aliases/ElementInstanceWaitStateQuerySortRequest.md)
- [ElementInstanceWaitStateResult](type-aliases/ElementInstanceWaitStateResult.md)
- [EndCursor](type-aliases/EndCursor.md)
- [EntityTypeExactMatch](type-aliases/EntityTypeExactMatch.md)
- [EntityTypeFilterProperty](type-aliases/EntityTypeFilterProperty.md)
- [EvaluateConditionalResult](type-aliases/EvaluateConditionalResult.md)
- [EvaluateConditionalsData](type-aliases/EvaluateConditionalsData.md)
- [EvaluateConditionalsError](type-aliases/EvaluateConditionalsError.md)
- [EvaluateConditionalsErrors](type-aliases/EvaluateConditionalsErrors.md)
- [evaluateConditionalsInput](type-aliases/evaluateConditionalsInput.md)
- [EvaluateConditionalsResponse](type-aliases/EvaluateConditionalsResponse.md)
- [EvaluateConditionalsResponses](type-aliases/EvaluateConditionalsResponses.md)
- [EvaluatedDecisionInputItem](type-aliases/EvaluatedDecisionInputItem.md)
- [EvaluatedDecisionOutputItem](type-aliases/EvaluatedDecisionOutputItem.md)
- [EvaluatedDecisionResult](type-aliases/EvaluatedDecisionResult.md)
- [EvaluateDecisionData](type-aliases/EvaluateDecisionData.md)
- [EvaluateDecisionError](type-aliases/EvaluateDecisionError.md)
- [EvaluateDecisionErrors](type-aliases/EvaluateDecisionErrors.md)
- [evaluateDecisionInput](type-aliases/evaluateDecisionInput.md)
- [EvaluateDecisionResponse](type-aliases/EvaluateDecisionResponse.md)
- [EvaluateDecisionResponses](type-aliases/EvaluateDecisionResponses.md)
- [EvaluateDecisionResult](type-aliases/EvaluateDecisionResult.md)
- [EvaluateExpressionData](type-aliases/EvaluateExpressionData.md)
- [EvaluateExpressionError](type-aliases/EvaluateExpressionError.md)
- [EvaluateExpressionErrors](type-aliases/EvaluateExpressionErrors.md)
- [evaluateExpressionInput](type-aliases/evaluateExpressionInput.md)
- [EvaluateExpressionResponse](type-aliases/EvaluateExpressionResponse.md)
- [EvaluateExpressionResponses](type-aliases/EvaluateExpressionResponses.md)
- [ExpressionEvaluationRequest](type-aliases/ExpressionEvaluationRequest.md)
- [ExpressionEvaluationResult](type-aliases/ExpressionEvaluationResult.md)
- [ExpressionEvaluationWarningItem](type-aliases/ExpressionEvaluationWarningItem.md)
- [FailJobData](type-aliases/FailJobData.md)
- [FailJobError](type-aliases/FailJobError.md)
- [FailJobErrors](type-aliases/FailJobErrors.md)
- [failJobInput](type-aliases/failJobInput.md)
- [FailJobResponse](type-aliases/FailJobResponse.md)
- [FailJobResponses](type-aliases/FailJobResponses.md)
- [FormId](type-aliases/FormId.md)
- [FormKey](type-aliases/FormKey.md)
- [FormKeyExactMatch](type-aliases/FormKeyExactMatch.md)
- [FormKeyFilterProperty](type-aliases/FormKeyFilterProperty.md)
- [FormResult](type-aliases/FormResult.md)
- [getAgentInstanceConsistency](type-aliases/getAgentInstanceConsistency.md)
- [GetAgentInstanceData](type-aliases/GetAgentInstanceData.md)
- [GetAgentInstanceError](type-aliases/GetAgentInstanceError.md)
- [GetAgentInstanceErrors](type-aliases/GetAgentInstanceErrors.md)
- [getAgentInstanceInput](type-aliases/getAgentInstanceInput.md)
- [GetAgentInstanceResponse](type-aliases/GetAgentInstanceResponse.md)
- [GetAgentInstanceResponses](type-aliases/GetAgentInstanceResponses.md)
- [getAuditLogConsistency](type-aliases/getAuditLogConsistency.md)
- [GetAuditLogData](type-aliases/GetAuditLogData.md)
- [GetAuditLogError](type-aliases/GetAuditLogError.md)
- [GetAuditLogErrors](type-aliases/GetAuditLogErrors.md)
- [getAuditLogInput](type-aliases/getAuditLogInput.md)
- [GetAuditLogResponse](type-aliases/GetAuditLogResponse.md)
- [GetAuditLogResponses](type-aliases/GetAuditLogResponses.md)
- [GetAuthenticationData](type-aliases/GetAuthenticationData.md)
- [GetAuthenticationError](type-aliases/GetAuthenticationError.md)
- [GetAuthenticationErrors](type-aliases/GetAuthenticationErrors.md)
- [getAuthenticationInput](type-aliases/getAuthenticationInput.md)
- [GetAuthenticationResponse](type-aliases/GetAuthenticationResponse.md)
- [GetAuthenticationResponses](type-aliases/GetAuthenticationResponses.md)
- [getAuthorizationConsistency](type-aliases/getAuthorizationConsistency.md)
- [GetAuthorizationData](type-aliases/GetAuthorizationData.md)
- [GetAuthorizationError](type-aliases/GetAuthorizationError.md)
- [GetAuthorizationErrors](type-aliases/GetAuthorizationErrors.md)
- [getAuthorizationInput](type-aliases/getAuthorizationInput.md)
- [GetAuthorizationResponse](type-aliases/GetAuthorizationResponse.md)
- [GetAuthorizationResponses](type-aliases/GetAuthorizationResponses.md)
- [getBatchOperationConsistency](type-aliases/getBatchOperationConsistency.md)
- [GetBatchOperationData](type-aliases/GetBatchOperationData.md)
- [GetBatchOperationError](type-aliases/GetBatchOperationError.md)
- [GetBatchOperationErrors](type-aliases/GetBatchOperationErrors.md)
- [getBatchOperationInput](type-aliases/getBatchOperationInput.md)
- [GetBatchOperationResponse](type-aliases/GetBatchOperationResponse.md)
- [GetBatchOperationResponses](type-aliases/GetBatchOperationResponses.md)
- [getDecisionDefinitionConsistency](type-aliases/getDecisionDefinitionConsistency.md)
- [GetDecisionDefinitionData](type-aliases/GetDecisionDefinitionData.md)
- [GetDecisionDefinitionError](type-aliases/GetDecisionDefinitionError.md)
- [GetDecisionDefinitionErrors](type-aliases/GetDecisionDefinitionErrors.md)
- [getDecisionDefinitionInput](type-aliases/getDecisionDefinitionInput.md)
- [GetDecisionDefinitionResponse](type-aliases/GetDecisionDefinitionResponse.md)
- [GetDecisionDefinitionResponses](type-aliases/GetDecisionDefinitionResponses.md)
- [getDecisionDefinitionXmlConsistency](type-aliases/getDecisionDefinitionXmlConsistency.md)
- [GetDecisionDefinitionXmlData](type-aliases/GetDecisionDefinitionXmlData.md)
- [GetDecisionDefinitionXmlError](type-aliases/GetDecisionDefinitionXmlError.md)
- [GetDecisionDefinitionXmlErrors](type-aliases/GetDecisionDefinitionXmlErrors.md)
- [getDecisionDefinitionXmlInput](type-aliases/getDecisionDefinitionXmlInput.md)
- [GetDecisionDefinitionXmlResponse](type-aliases/GetDecisionDefinitionXmlResponse.md)
- [GetDecisionDefinitionXmlResponses](type-aliases/GetDecisionDefinitionXmlResponses.md)
- [getDecisionInstanceConsistency](type-aliases/getDecisionInstanceConsistency.md)
- [GetDecisionInstanceData](type-aliases/GetDecisionInstanceData.md)
- [GetDecisionInstanceError](type-aliases/GetDecisionInstanceError.md)
- [GetDecisionInstanceErrors](type-aliases/GetDecisionInstanceErrors.md)
- [getDecisionInstanceInput](type-aliases/getDecisionInstanceInput.md)
- [GetDecisionInstanceResponse](type-aliases/GetDecisionInstanceResponse.md)
- [GetDecisionInstanceResponses](type-aliases/GetDecisionInstanceResponses.md)
- [getDecisionRequirementsConsistency](type-aliases/getDecisionRequirementsConsistency.md)
- [GetDecisionRequirementsData](type-aliases/GetDecisionRequirementsData.md)
- [GetDecisionRequirementsError](type-aliases/GetDecisionRequirementsError.md)
- [GetDecisionRequirementsErrors](type-aliases/GetDecisionRequirementsErrors.md)
- [getDecisionRequirementsInput](type-aliases/getDecisionRequirementsInput.md)
- [GetDecisionRequirementsResponse](type-aliases/GetDecisionRequirementsResponse.md)
- [GetDecisionRequirementsResponses](type-aliases/GetDecisionRequirementsResponses.md)
- [getDecisionRequirementsXmlConsistency](type-aliases/getDecisionRequirementsXmlConsistency.md)
- [GetDecisionRequirementsXmlData](type-aliases/GetDecisionRequirementsXmlData.md)
- [GetDecisionRequirementsXmlError](type-aliases/GetDecisionRequirementsXmlError.md)
- [GetDecisionRequirementsXmlErrors](type-aliases/GetDecisionRequirementsXmlErrors.md)
- [getDecisionRequirementsXmlInput](type-aliases/getDecisionRequirementsXmlInput.md)
- [GetDecisionRequirementsXmlResponse](type-aliases/GetDecisionRequirementsXmlResponse.md)
- [GetDecisionRequirementsXmlResponses](type-aliases/GetDecisionRequirementsXmlResponses.md)
- [GetDocumentData](type-aliases/GetDocumentData.md)
- [GetDocumentError](type-aliases/GetDocumentError.md)
- [GetDocumentErrors](type-aliases/GetDocumentErrors.md)
- [getDocumentInput](type-aliases/getDocumentInput.md)
- [GetDocumentResponse](type-aliases/GetDocumentResponse.md)
- [GetDocumentResponses](type-aliases/GetDocumentResponses.md)
- [getElementInstanceConsistency](type-aliases/getElementInstanceConsistency.md)
- [GetElementInstanceData](type-aliases/GetElementInstanceData.md)
- [GetElementInstanceError](type-aliases/GetElementInstanceError.md)
- [GetElementInstanceErrors](type-aliases/GetElementInstanceErrors.md)
- [getElementInstanceInput](type-aliases/getElementInstanceInput.md)
- [GetElementInstanceResponse](type-aliases/GetElementInstanceResponse.md)
- [GetElementInstanceResponses](type-aliases/GetElementInstanceResponses.md)
- [getFormByKeyConsistency](type-aliases/getFormByKeyConsistency.md)
- [GetFormByKeyData](type-aliases/GetFormByKeyData.md)
- [GetFormByKeyError](type-aliases/GetFormByKeyError.md)
- [GetFormByKeyErrors](type-aliases/GetFormByKeyErrors.md)
- [getFormByKeyInput](type-aliases/getFormByKeyInput.md)
- [GetFormByKeyResponse](type-aliases/GetFormByKeyResponse.md)
- [GetFormByKeyResponses](type-aliases/GetFormByKeyResponses.md)
- [getGlobalClusterVariableConsistency](type-aliases/getGlobalClusterVariableConsistency.md)
- [GetGlobalClusterVariableData](type-aliases/GetGlobalClusterVariableData.md)
- [GetGlobalClusterVariableError](type-aliases/GetGlobalClusterVariableError.md)
- [GetGlobalClusterVariableErrors](type-aliases/GetGlobalClusterVariableErrors.md)
- [getGlobalClusterVariableInput](type-aliases/getGlobalClusterVariableInput.md)
- [GetGlobalClusterVariableResponse](type-aliases/GetGlobalClusterVariableResponse.md)
- [GetGlobalClusterVariableResponses](type-aliases/GetGlobalClusterVariableResponses.md)
- [getGlobalJobStatisticsConsistency](type-aliases/getGlobalJobStatisticsConsistency.md)
- [GetGlobalJobStatisticsData](type-aliases/GetGlobalJobStatisticsData.md)
- [GetGlobalJobStatisticsError](type-aliases/GetGlobalJobStatisticsError.md)
- [GetGlobalJobStatisticsErrors](type-aliases/GetGlobalJobStatisticsErrors.md)
- [getGlobalJobStatisticsInput](type-aliases/getGlobalJobStatisticsInput.md)
- [GetGlobalJobStatisticsResponse](type-aliases/GetGlobalJobStatisticsResponse.md)
- [GetGlobalJobStatisticsResponses](type-aliases/GetGlobalJobStatisticsResponses.md)
- [getGlobalTaskListenerConsistency](type-aliases/getGlobalTaskListenerConsistency.md)
- [GetGlobalTaskListenerData](type-aliases/GetGlobalTaskListenerData.md)
- [GetGlobalTaskListenerError](type-aliases/GetGlobalTaskListenerError.md)
- [GetGlobalTaskListenerErrors](type-aliases/GetGlobalTaskListenerErrors.md)
- [getGlobalTaskListenerInput](type-aliases/getGlobalTaskListenerInput.md)
- [GetGlobalTaskListenerResponse](type-aliases/GetGlobalTaskListenerResponse.md)
- [GetGlobalTaskListenerResponses](type-aliases/GetGlobalTaskListenerResponses.md)
- [getGroupConsistency](type-aliases/getGroupConsistency.md)
- [GetGroupData](type-aliases/GetGroupData.md)
- [GetGroupError](type-aliases/GetGroupError.md)
- [GetGroupErrors](type-aliases/GetGroupErrors.md)
- [getGroupInput](type-aliases/getGroupInput.md)
- [GetGroupResponse](type-aliases/GetGroupResponse.md)
- [GetGroupResponses](type-aliases/GetGroupResponses.md)
- [getIncidentConsistency](type-aliases/getIncidentConsistency.md)
- [GetIncidentData](type-aliases/GetIncidentData.md)
- [GetIncidentError](type-aliases/GetIncidentError.md)
- [GetIncidentErrors](type-aliases/GetIncidentErrors.md)
- [getIncidentInput](type-aliases/getIncidentInput.md)
- [GetIncidentResponse](type-aliases/GetIncidentResponse.md)
- [GetIncidentResponses](type-aliases/GetIncidentResponses.md)
- [getJobErrorStatisticsConsistency](type-aliases/getJobErrorStatisticsConsistency.md)
- [GetJobErrorStatisticsData](type-aliases/GetJobErrorStatisticsData.md)
- [GetJobErrorStatisticsError](type-aliases/GetJobErrorStatisticsError.md)
- [GetJobErrorStatisticsErrors](type-aliases/GetJobErrorStatisticsErrors.md)
- [getJobErrorStatisticsInput](type-aliases/getJobErrorStatisticsInput.md)
- [GetJobErrorStatisticsResponse](type-aliases/GetJobErrorStatisticsResponse.md)
- [GetJobErrorStatisticsResponses](type-aliases/GetJobErrorStatisticsResponses.md)
- [getJobTimeSeriesStatisticsConsistency](type-aliases/getJobTimeSeriesStatisticsConsistency.md)
- [GetJobTimeSeriesStatisticsData](type-aliases/GetJobTimeSeriesStatisticsData.md)
- [GetJobTimeSeriesStatisticsError](type-aliases/GetJobTimeSeriesStatisticsError.md)
- [GetJobTimeSeriesStatisticsErrors](type-aliases/GetJobTimeSeriesStatisticsErrors.md)
- [getJobTimeSeriesStatisticsInput](type-aliases/getJobTimeSeriesStatisticsInput.md)
- [GetJobTimeSeriesStatisticsResponse](type-aliases/GetJobTimeSeriesStatisticsResponse.md)
- [GetJobTimeSeriesStatisticsResponses](type-aliases/GetJobTimeSeriesStatisticsResponses.md)
- [getJobTypeStatisticsConsistency](type-aliases/getJobTypeStatisticsConsistency.md)
- [GetJobTypeStatisticsData](type-aliases/GetJobTypeStatisticsData.md)
- [GetJobTypeStatisticsError](type-aliases/GetJobTypeStatisticsError.md)
- [GetJobTypeStatisticsErrors](type-aliases/GetJobTypeStatisticsErrors.md)
- [getJobTypeStatisticsInput](type-aliases/getJobTypeStatisticsInput.md)
- [GetJobTypeStatisticsResponse](type-aliases/GetJobTypeStatisticsResponse.md)
- [GetJobTypeStatisticsResponses](type-aliases/GetJobTypeStatisticsResponses.md)
- [getJobWorkerStatisticsConsistency](type-aliases/getJobWorkerStatisticsConsistency.md)
- [GetJobWorkerStatisticsData](type-aliases/GetJobWorkerStatisticsData.md)
- [GetJobWorkerStatisticsError](type-aliases/GetJobWorkerStatisticsError.md)
- [GetJobWorkerStatisticsErrors](type-aliases/GetJobWorkerStatisticsErrors.md)
- [getJobWorkerStatisticsInput](type-aliases/getJobWorkerStatisticsInput.md)
- [GetJobWorkerStatisticsResponse](type-aliases/GetJobWorkerStatisticsResponse.md)
- [GetJobWorkerStatisticsResponses](type-aliases/GetJobWorkerStatisticsResponses.md)
- [GetLicenseData](type-aliases/GetLicenseData.md)
- [GetLicenseError](type-aliases/GetLicenseError.md)
- [GetLicenseErrors](type-aliases/GetLicenseErrors.md)
- [getLicenseInput](type-aliases/getLicenseInput.md)
- [GetLicenseResponse](type-aliases/GetLicenseResponse.md)
- [GetLicenseResponses](type-aliases/GetLicenseResponses.md)
- [getMappingRuleConsistency](type-aliases/getMappingRuleConsistency.md)
- [GetMappingRuleData](type-aliases/GetMappingRuleData.md)
- [GetMappingRuleError](type-aliases/GetMappingRuleError.md)
- [GetMappingRuleErrors](type-aliases/GetMappingRuleErrors.md)
- [getMappingRuleInput](type-aliases/getMappingRuleInput.md)
- [GetMappingRuleResponse](type-aliases/GetMappingRuleResponse.md)
- [GetMappingRuleResponses](type-aliases/GetMappingRuleResponses.md)
- [getProcessDefinitionConsistency](type-aliases/getProcessDefinitionConsistency.md)
- [GetProcessDefinitionData](type-aliases/GetProcessDefinitionData.md)
- [GetProcessDefinitionError](type-aliases/GetProcessDefinitionError.md)
- [GetProcessDefinitionErrors](type-aliases/GetProcessDefinitionErrors.md)
- [getProcessDefinitionInput](type-aliases/getProcessDefinitionInput.md)
- [getProcessDefinitionInstanceStatisticsConsistency](type-aliases/getProcessDefinitionInstanceStatisticsConsistency.md)
- [GetProcessDefinitionInstanceStatisticsData](type-aliases/GetProcessDefinitionInstanceStatisticsData.md)
- [GetProcessDefinitionInstanceStatisticsError](type-aliases/GetProcessDefinitionInstanceStatisticsError.md)
- [GetProcessDefinitionInstanceStatisticsErrors](type-aliases/GetProcessDefinitionInstanceStatisticsErrors.md)
- [getProcessDefinitionInstanceStatisticsInput](type-aliases/getProcessDefinitionInstanceStatisticsInput.md)
- [GetProcessDefinitionInstanceStatisticsResponse](type-aliases/GetProcessDefinitionInstanceStatisticsResponse.md)
- [GetProcessDefinitionInstanceStatisticsResponses](type-aliases/GetProcessDefinitionInstanceStatisticsResponses.md)
- [getProcessDefinitionInstanceVersionStatisticsConsistency](type-aliases/getProcessDefinitionInstanceVersionStatisticsConsistency.md)
- [GetProcessDefinitionInstanceVersionStatisticsData](type-aliases/GetProcessDefinitionInstanceVersionStatisticsData.md)
- [GetProcessDefinitionInstanceVersionStatisticsError](type-aliases/GetProcessDefinitionInstanceVersionStatisticsError.md)
- [GetProcessDefinitionInstanceVersionStatisticsErrors](type-aliases/GetProcessDefinitionInstanceVersionStatisticsErrors.md)
- [getProcessDefinitionInstanceVersionStatisticsInput](type-aliases/getProcessDefinitionInstanceVersionStatisticsInput.md)
- [GetProcessDefinitionInstanceVersionStatisticsResponse](type-aliases/GetProcessDefinitionInstanceVersionStatisticsResponse.md)
- [GetProcessDefinitionInstanceVersionStatisticsResponses](type-aliases/GetProcessDefinitionInstanceVersionStatisticsResponses.md)
- [getProcessDefinitionMessageSubscriptionStatisticsConsistency](type-aliases/getProcessDefinitionMessageSubscriptionStatisticsConsistency.md)
- [GetProcessDefinitionMessageSubscriptionStatisticsData](type-aliases/GetProcessDefinitionMessageSubscriptionStatisticsData.md)
- [GetProcessDefinitionMessageSubscriptionStatisticsError](type-aliases/GetProcessDefinitionMessageSubscriptionStatisticsError.md)
- [GetProcessDefinitionMessageSubscriptionStatisticsErrors](type-aliases/GetProcessDefinitionMessageSubscriptionStatisticsErrors.md)
- [getProcessDefinitionMessageSubscriptionStatisticsInput](type-aliases/getProcessDefinitionMessageSubscriptionStatisticsInput.md)
- [GetProcessDefinitionMessageSubscriptionStatisticsResponse](type-aliases/GetProcessDefinitionMessageSubscriptionStatisticsResponse.md)
- [GetProcessDefinitionMessageSubscriptionStatisticsResponses](type-aliases/GetProcessDefinitionMessageSubscriptionStatisticsResponses.md)
- [GetProcessDefinitionResponse](type-aliases/GetProcessDefinitionResponse.md)
- [GetProcessDefinitionResponses](type-aliases/GetProcessDefinitionResponses.md)
- [getProcessDefinitionStatisticsConsistency](type-aliases/getProcessDefinitionStatisticsConsistency.md)
- [GetProcessDefinitionStatisticsData](type-aliases/GetProcessDefinitionStatisticsData.md)
- [GetProcessDefinitionStatisticsError](type-aliases/GetProcessDefinitionStatisticsError.md)
- [GetProcessDefinitionStatisticsErrors](type-aliases/GetProcessDefinitionStatisticsErrors.md)
- [getProcessDefinitionStatisticsInput](type-aliases/getProcessDefinitionStatisticsInput.md)
- [GetProcessDefinitionStatisticsResponse](type-aliases/GetProcessDefinitionStatisticsResponse.md)
- [GetProcessDefinitionStatisticsResponses](type-aliases/GetProcessDefinitionStatisticsResponses.md)
- [getProcessDefinitionXmlConsistency](type-aliases/getProcessDefinitionXmlConsistency.md)
- [GetProcessDefinitionXmlData](type-aliases/GetProcessDefinitionXmlData.md)
- [GetProcessDefinitionXmlError](type-aliases/GetProcessDefinitionXmlError.md)
- [GetProcessDefinitionXmlErrors](type-aliases/GetProcessDefinitionXmlErrors.md)
- [getProcessDefinitionXmlInput](type-aliases/getProcessDefinitionXmlInput.md)
- [GetProcessDefinitionXmlResponse](type-aliases/GetProcessDefinitionXmlResponse.md)
- [GetProcessDefinitionXmlResponses](type-aliases/GetProcessDefinitionXmlResponses.md)
- [getProcessInstanceCallHierarchyConsistency](type-aliases/getProcessInstanceCallHierarchyConsistency.md)
- [GetProcessInstanceCallHierarchyData](type-aliases/GetProcessInstanceCallHierarchyData.md)
- [GetProcessInstanceCallHierarchyError](type-aliases/GetProcessInstanceCallHierarchyError.md)
- [GetProcessInstanceCallHierarchyErrors](type-aliases/GetProcessInstanceCallHierarchyErrors.md)
- [getProcessInstanceCallHierarchyInput](type-aliases/getProcessInstanceCallHierarchyInput.md)
- [GetProcessInstanceCallHierarchyResponse](type-aliases/GetProcessInstanceCallHierarchyResponse.md)
- [GetProcessInstanceCallHierarchyResponses](type-aliases/GetProcessInstanceCallHierarchyResponses.md)
- [getProcessInstanceConsistency](type-aliases/getProcessInstanceConsistency.md)
- [GetProcessInstanceData](type-aliases/GetProcessInstanceData.md)
- [GetProcessInstanceError](type-aliases/GetProcessInstanceError.md)
- [GetProcessInstanceErrors](type-aliases/GetProcessInstanceErrors.md)
- [getProcessInstanceInput](type-aliases/getProcessInstanceInput.md)
- [GetProcessInstanceResponse](type-aliases/GetProcessInstanceResponse.md)
- [GetProcessInstanceResponses](type-aliases/GetProcessInstanceResponses.md)
- [getProcessInstanceSequenceFlowsConsistency](type-aliases/getProcessInstanceSequenceFlowsConsistency.md)
- [GetProcessInstanceSequenceFlowsData](type-aliases/GetProcessInstanceSequenceFlowsData.md)
- [GetProcessInstanceSequenceFlowsError](type-aliases/GetProcessInstanceSequenceFlowsError.md)
- [GetProcessInstanceSequenceFlowsErrors](type-aliases/GetProcessInstanceSequenceFlowsErrors.md)
- [getProcessInstanceSequenceFlowsInput](type-aliases/getProcessInstanceSequenceFlowsInput.md)
- [GetProcessInstanceSequenceFlowsResponse](type-aliases/GetProcessInstanceSequenceFlowsResponse.md)
- [GetProcessInstanceSequenceFlowsResponses](type-aliases/GetProcessInstanceSequenceFlowsResponses.md)
- [getProcessInstanceStatisticsByDefinitionConsistency](type-aliases/getProcessInstanceStatisticsByDefinitionConsistency.md)
- [GetProcessInstanceStatisticsByDefinitionData](type-aliases/GetProcessInstanceStatisticsByDefinitionData.md)
- [GetProcessInstanceStatisticsByDefinitionError](type-aliases/GetProcessInstanceStatisticsByDefinitionError.md)
- [GetProcessInstanceStatisticsByDefinitionErrors](type-aliases/GetProcessInstanceStatisticsByDefinitionErrors.md)
- [getProcessInstanceStatisticsByDefinitionInput](type-aliases/getProcessInstanceStatisticsByDefinitionInput.md)
- [GetProcessInstanceStatisticsByDefinitionResponse](type-aliases/GetProcessInstanceStatisticsByDefinitionResponse.md)
- [GetProcessInstanceStatisticsByDefinitionResponses](type-aliases/GetProcessInstanceStatisticsByDefinitionResponses.md)
- [getProcessInstanceStatisticsByErrorConsistency](type-aliases/getProcessInstanceStatisticsByErrorConsistency.md)
- [GetProcessInstanceStatisticsByErrorData](type-aliases/GetProcessInstanceStatisticsByErrorData.md)
- [GetProcessInstanceStatisticsByErrorError](type-aliases/GetProcessInstanceStatisticsByErrorError.md)
- [GetProcessInstanceStatisticsByErrorErrors](type-aliases/GetProcessInstanceStatisticsByErrorErrors.md)
- [getProcessInstanceStatisticsByErrorInput](type-aliases/getProcessInstanceStatisticsByErrorInput.md)
- [GetProcessInstanceStatisticsByErrorResponse](type-aliases/GetProcessInstanceStatisticsByErrorResponse.md)
- [GetProcessInstanceStatisticsByErrorResponses](type-aliases/GetProcessInstanceStatisticsByErrorResponses.md)
- [getProcessInstanceStatisticsConsistency](type-aliases/getProcessInstanceStatisticsConsistency.md)
- [GetProcessInstanceStatisticsData](type-aliases/GetProcessInstanceStatisticsData.md)
- [GetProcessInstanceStatisticsError](type-aliases/GetProcessInstanceStatisticsError.md)
- [GetProcessInstanceStatisticsErrors](type-aliases/GetProcessInstanceStatisticsErrors.md)
- [getProcessInstanceStatisticsInput](type-aliases/getProcessInstanceStatisticsInput.md)
- [GetProcessInstanceStatisticsResponse](type-aliases/GetProcessInstanceStatisticsResponse.md)
- [GetProcessInstanceStatisticsResponses](type-aliases/GetProcessInstanceStatisticsResponses.md)
- [getProcessInstanceWaitStateStatisticsConsistency](type-aliases/getProcessInstanceWaitStateStatisticsConsistency.md)
- [GetProcessInstanceWaitStateStatisticsData](type-aliases/GetProcessInstanceWaitStateStatisticsData.md)
- [GetProcessInstanceWaitStateStatisticsError](type-aliases/GetProcessInstanceWaitStateStatisticsError.md)
- [GetProcessInstanceWaitStateStatisticsErrors](type-aliases/GetProcessInstanceWaitStateStatisticsErrors.md)
- [getProcessInstanceWaitStateStatisticsInput](type-aliases/getProcessInstanceWaitStateStatisticsInput.md)
- [GetProcessInstanceWaitStateStatisticsResponse](type-aliases/GetProcessInstanceWaitStateStatisticsResponse.md)
- [GetProcessInstanceWaitStateStatisticsResponses](type-aliases/GetProcessInstanceWaitStateStatisticsResponses.md)
- [getResourceConsistency](type-aliases/getResourceConsistency.md)
- [getResourceContentBinaryConsistency](type-aliases/getResourceContentBinaryConsistency.md)
- [GetResourceContentBinaryData](type-aliases/GetResourceContentBinaryData.md)
- [GetResourceContentBinaryError](type-aliases/GetResourceContentBinaryError.md)
- [GetResourceContentBinaryErrors](type-aliases/GetResourceContentBinaryErrors.md)
- [getResourceContentBinaryInput](type-aliases/getResourceContentBinaryInput.md)
- [GetResourceContentBinaryResponse](type-aliases/GetResourceContentBinaryResponse.md)
- [GetResourceContentBinaryResponses](type-aliases/GetResourceContentBinaryResponses.md)
- [getResourceContentConsistency](type-aliases/getResourceContentConsistency.md)
- [GetResourceContentData](type-aliases/GetResourceContentData.md)
- [GetResourceContentError](type-aliases/GetResourceContentError.md)
- [GetResourceContentErrors](type-aliases/GetResourceContentErrors.md)
- [getResourceContentInput](type-aliases/getResourceContentInput.md)
- [GetResourceContentResponse](type-aliases/GetResourceContentResponse.md)
- [GetResourceContentResponses](type-aliases/GetResourceContentResponses.md)
- [GetResourceData](type-aliases/GetResourceData.md)
- [GetResourceError](type-aliases/GetResourceError.md)
- [GetResourceErrors](type-aliases/GetResourceErrors.md)
- [getResourceInput](type-aliases/getResourceInput.md)
- [GetResourceResponse](type-aliases/GetResourceResponse.md)
- [GetResourceResponses](type-aliases/GetResourceResponses.md)
- [getRoleConsistency](type-aliases/getRoleConsistency.md)
- [GetRoleData](type-aliases/GetRoleData.md)
- [GetRoleError](type-aliases/GetRoleError.md)
- [GetRoleErrors](type-aliases/GetRoleErrors.md)
- [getRoleInput](type-aliases/getRoleInput.md)
- [GetRoleResponse](type-aliases/GetRoleResponse.md)
- [GetRoleResponses](type-aliases/GetRoleResponses.md)
- [getStartProcessFormConsistency](type-aliases/getStartProcessFormConsistency.md)
- [GetStartProcessFormData](type-aliases/GetStartProcessFormData.md)
- [GetStartProcessFormError](type-aliases/GetStartProcessFormError.md)
- [GetStartProcessFormErrors](type-aliases/GetStartProcessFormErrors.md)
- [getStartProcessFormInput](type-aliases/getStartProcessFormInput.md)
- [GetStartProcessFormResponse](type-aliases/GetStartProcessFormResponse.md)
- [GetStartProcessFormResponses](type-aliases/GetStartProcessFormResponses.md)
- [GetStatusData](type-aliases/GetStatusData.md)
- [GetStatusErrors](type-aliases/GetStatusErrors.md)
- [getStatusInput](type-aliases/getStatusInput.md)
- [GetStatusResponse](type-aliases/GetStatusResponse.md)
- [GetStatusResponses](type-aliases/GetStatusResponses.md)
- [GetSystemConfigurationData](type-aliases/GetSystemConfigurationData.md)
- [GetSystemConfigurationError](type-aliases/GetSystemConfigurationError.md)
- [GetSystemConfigurationErrors](type-aliases/GetSystemConfigurationErrors.md)
- [getSystemConfigurationInput](type-aliases/getSystemConfigurationInput.md)
- [GetSystemConfigurationResponse](type-aliases/GetSystemConfigurationResponse.md)
- [GetSystemConfigurationResponses](type-aliases/GetSystemConfigurationResponses.md)
- [getTenantClusterVariableConsistency](type-aliases/getTenantClusterVariableConsistency.md)
- [GetTenantClusterVariableData](type-aliases/GetTenantClusterVariableData.md)
- [GetTenantClusterVariableError](type-aliases/GetTenantClusterVariableError.md)
- [GetTenantClusterVariableErrors](type-aliases/GetTenantClusterVariableErrors.md)
- [getTenantClusterVariableInput](type-aliases/getTenantClusterVariableInput.md)
- [GetTenantClusterVariableResponse](type-aliases/GetTenantClusterVariableResponse.md)
- [GetTenantClusterVariableResponses](type-aliases/GetTenantClusterVariableResponses.md)
- [getTenantConsistency](type-aliases/getTenantConsistency.md)
- [GetTenantData](type-aliases/GetTenantData.md)
- [GetTenantError](type-aliases/GetTenantError.md)
- [GetTenantErrors](type-aliases/GetTenantErrors.md)
- [getTenantInput](type-aliases/getTenantInput.md)
- [GetTenantResponse](type-aliases/GetTenantResponse.md)
- [GetTenantResponses](type-aliases/GetTenantResponses.md)
- [GetTopologyData](type-aliases/GetTopologyData.md)
- [GetTopologyError](type-aliases/GetTopologyError.md)
- [GetTopologyErrors](type-aliases/GetTopologyErrors.md)
- [getTopologyInput](type-aliases/getTopologyInput.md)
- [GetTopologyResponse](type-aliases/GetTopologyResponse.md)
- [GetTopologyResponses](type-aliases/GetTopologyResponses.md)
- [getUsageMetricsConsistency](type-aliases/getUsageMetricsConsistency.md)
- [GetUsageMetricsData](type-aliases/GetUsageMetricsData.md)
- [GetUsageMetricsError](type-aliases/GetUsageMetricsError.md)
- [GetUsageMetricsErrors](type-aliases/GetUsageMetricsErrors.md)
- [getUsageMetricsInput](type-aliases/getUsageMetricsInput.md)
- [GetUsageMetricsResponse](type-aliases/GetUsageMetricsResponse.md)
- [GetUsageMetricsResponses](type-aliases/GetUsageMetricsResponses.md)
- [getUserConsistency](type-aliases/getUserConsistency.md)
- [GetUserData](type-aliases/GetUserData.md)
- [GetUserError](type-aliases/GetUserError.md)
- [GetUserErrors](type-aliases/GetUserErrors.md)
- [getUserInput](type-aliases/getUserInput.md)
- [GetUserResponse](type-aliases/GetUserResponse.md)
- [GetUserResponses](type-aliases/GetUserResponses.md)
- [getUserTaskConsistency](type-aliases/getUserTaskConsistency.md)
- [GetUserTaskData](type-aliases/GetUserTaskData.md)
- [GetUserTaskError](type-aliases/GetUserTaskError.md)
- [GetUserTaskErrors](type-aliases/GetUserTaskErrors.md)
- [getUserTaskFormConsistency](type-aliases/getUserTaskFormConsistency.md)
- [GetUserTaskFormData](type-aliases/GetUserTaskFormData.md)
- [GetUserTaskFormError](type-aliases/GetUserTaskFormError.md)
- [GetUserTaskFormErrors](type-aliases/GetUserTaskFormErrors.md)
- [getUserTaskFormInput](type-aliases/getUserTaskFormInput.md)
- [GetUserTaskFormResponse](type-aliases/GetUserTaskFormResponse.md)
- [GetUserTaskFormResponses](type-aliases/GetUserTaskFormResponses.md)
- [getUserTaskInput](type-aliases/getUserTaskInput.md)
- [GetUserTaskResponse](type-aliases/GetUserTaskResponse.md)
- [GetUserTaskResponses](type-aliases/GetUserTaskResponses.md)
- [getVariableConsistency](type-aliases/getVariableConsistency.md)
- [GetVariableData](type-aliases/GetVariableData.md)
- [GetVariableError](type-aliases/GetVariableError.md)
- [GetVariableErrors](type-aliases/GetVariableErrors.md)
- [getVariableInput](type-aliases/getVariableInput.md)
- [GetVariableResponse](type-aliases/GetVariableResponse.md)
- [GetVariableResponses](type-aliases/GetVariableResponses.md)
- [GlobalJobStatisticsQueryResult](type-aliases/GlobalJobStatisticsQueryResult.md)
- [GlobalListenerBase](type-aliases/GlobalListenerBase.md)
- [GlobalListenerId](type-aliases/GlobalListenerId.md)
- [GlobalListenerSourceEnum](type-aliases/GlobalListenerSourceEnum.md)
- [GlobalListenerSourceExactMatch](type-aliases/GlobalListenerSourceExactMatch.md)
- [GlobalListenerSourceFilterProperty](type-aliases/GlobalListenerSourceFilterProperty.md)
- [GlobalTaskListenerBase](type-aliases/GlobalTaskListenerBase.md)
- [GlobalTaskListenerEventTypeEnum](type-aliases/GlobalTaskListenerEventTypeEnum.md)
- [GlobalTaskListenerEventTypeExactMatch](type-aliases/GlobalTaskListenerEventTypeExactMatch.md)
- [GlobalTaskListenerEventTypeFilterProperty](type-aliases/GlobalTaskListenerEventTypeFilterProperty.md)
- [GlobalTaskListenerEventTypes](type-aliases/GlobalTaskListenerEventTypes.md)
- [GlobalTaskListenerResult](type-aliases/GlobalTaskListenerResult.md)
- [GlobalTaskListenerSearchQueryFilterRequest](type-aliases/GlobalTaskListenerSearchQueryFilterRequest.md)
- [GlobalTaskListenerSearchQueryRequest](type-aliases/GlobalTaskListenerSearchQueryRequest.md)
- [GlobalTaskListenerSearchQueryResult](type-aliases/GlobalTaskListenerSearchQueryResult.md)
- [GlobalTaskListenerSearchQuerySortRequest](type-aliases/GlobalTaskListenerSearchQuerySortRequest.md)
- [GroupClientResult](type-aliases/GroupClientResult.md)
- [GroupClientSearchQueryRequest](type-aliases/GroupClientSearchQueryRequest.md)
- [GroupClientSearchQuerySortRequest](type-aliases/GroupClientSearchQuerySortRequest.md)
- [GroupClientSearchResult](type-aliases/GroupClientSearchResult.md)
- [GroupCreateRequest](type-aliases/GroupCreateRequest.md)
- [GroupCreateResult](type-aliases/GroupCreateResult.md)
- [GroupFilter](type-aliases/GroupFilter.md)
- [GroupId](type-aliases/GroupId.md)
- [GroupMappingRuleSearchResult](type-aliases/GroupMappingRuleSearchResult.md)
- [GroupResult](type-aliases/GroupResult.md)
- [GroupRoleSearchResult](type-aliases/GroupRoleSearchResult.md)
- [GroupSearchQueryRequest](type-aliases/GroupSearchQueryRequest.md)
- [GroupSearchQueryResult](type-aliases/GroupSearchQueryResult.md)
- [GroupSearchQuerySortRequest](type-aliases/GroupSearchQuerySortRequest.md)
- [GroupUpdateRequest](type-aliases/GroupUpdateRequest.md)
- [GroupUpdateResult](type-aliases/GroupUpdateResult.md)
- [GroupUserResult](type-aliases/GroupUserResult.md)
- [GroupUserSearchQueryRequest](type-aliases/GroupUserSearchQueryRequest.md)
- [GroupUserSearchQuerySortRequest](type-aliases/GroupUserSearchQuerySortRequest.md)
- [GroupUserSearchResult](type-aliases/GroupUserSearchResult.md)
- [IncidentErrorTypeEnum](type-aliases/IncidentErrorTypeEnum.md)
- [IncidentErrorTypeExactMatch](type-aliases/IncidentErrorTypeExactMatch.md)
- [IncidentErrorTypeFilterProperty](type-aliases/IncidentErrorTypeFilterProperty.md)
- [IncidentFilter](type-aliases/IncidentFilter.md)
- [IncidentKey](type-aliases/IncidentKey.md)
- [IncidentProcessInstanceStatisticsByDefinitionFilter](type-aliases/IncidentProcessInstanceStatisticsByDefinitionFilter.md)
- [IncidentProcessInstanceStatisticsByDefinitionQuery](type-aliases/IncidentProcessInstanceStatisticsByDefinitionQuery.md)
- [IncidentProcessInstanceStatisticsByDefinitionQueryResult](type-aliases/IncidentProcessInstanceStatisticsByDefinitionQueryResult.md)
- [IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest](type-aliases/IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest.md)
- [IncidentProcessInstanceStatisticsByDefinitionResult](type-aliases/IncidentProcessInstanceStatisticsByDefinitionResult.md)
- [IncidentProcessInstanceStatisticsByErrorQuery](type-aliases/IncidentProcessInstanceStatisticsByErrorQuery.md)
- [IncidentProcessInstanceStatisticsByErrorQueryResult](type-aliases/IncidentProcessInstanceStatisticsByErrorQueryResult.md)
- [IncidentProcessInstanceStatisticsByErrorQuerySortRequest](type-aliases/IncidentProcessInstanceStatisticsByErrorQuerySortRequest.md)
- [IncidentProcessInstanceStatisticsByErrorResult](type-aliases/IncidentProcessInstanceStatisticsByErrorResult.md)
- [IncidentResolutionRequest](type-aliases/IncidentResolutionRequest.md)
- [IncidentResult](type-aliases/IncidentResult.md)
- [IncidentSearchQuery](type-aliases/IncidentSearchQuery.md)
- [IncidentSearchQueryResult](type-aliases/IncidentSearchQueryResult.md)
- [IncidentSearchQuerySortRequest](type-aliases/IncidentSearchQuerySortRequest.md)
- [IncidentStateEnum](type-aliases/IncidentStateEnum.md)
- [IncidentStateExactMatch](type-aliases/IncidentStateExactMatch.md)
- [IncidentStateFilterProperty](type-aliases/IncidentStateFilterProperty.md)
- [InferredAncestorKeyInstruction](type-aliases/InferredAncestorKeyInstruction.md)
- [IntegerFilterProperty](type-aliases/IntegerFilterProperty.md)
- [IterationId](type-aliases/IterationId.md)
- [Job](type-aliases/Job.md)
- [JobActionReceipt](type-aliases/JobActionReceipt.md)
- [JobActionReceipt](type-aliases/JobActionReceipt-1.md)
- [JobActivationRequest](type-aliases/JobActivationRequest.md)
- [JobActivationResult](type-aliases/JobActivationResult.md)
- [JobBatchUpdateRequest](type-aliases/JobBatchUpdateRequest.md)
- [JobChangeset](type-aliases/JobChangeset.md)
- [JobCompletionRequest](type-aliases/JobCompletionRequest.md)
- [JobErrorRequest](type-aliases/JobErrorRequest.md)
- [JobErrorStatisticsFilter](type-aliases/JobErrorStatisticsFilter.md)
- [JobErrorStatisticsItem](type-aliases/JobErrorStatisticsItem.md)
- [JobErrorStatisticsQuery](type-aliases/JobErrorStatisticsQuery.md)
- [JobErrorStatisticsQueryResult](type-aliases/JobErrorStatisticsQueryResult.md)
- [JobFailRequest](type-aliases/JobFailRequest.md)
- [JobFilter](type-aliases/JobFilter.md)
- [JobKey](type-aliases/JobKey.md)
- [JobKeyExactMatch](type-aliases/JobKeyExactMatch.md)
- [JobKeyFilterProperty](type-aliases/JobKeyFilterProperty.md)
- [JobKindEnum](type-aliases/JobKindEnum.md)
- [JobKindExactMatch](type-aliases/JobKindExactMatch.md)
- [JobKindFilterProperty](type-aliases/JobKindFilterProperty.md)
- [JobListenerEventTypeEnum](type-aliases/JobListenerEventTypeEnum.md)
- [JobListenerEventTypeExactMatch](type-aliases/JobListenerEventTypeExactMatch.md)
- [JobListenerEventTypeFilterProperty](type-aliases/JobListenerEventTypeFilterProperty.md)
- [JobMetricsConfigurationResponse](type-aliases/JobMetricsConfigurationResponse.md)
- [JobResult](type-aliases/JobResult.md)
- [JobResultActivateElement](type-aliases/JobResultActivateElement.md)
- [JobResultAdHocSubProcess](type-aliases/JobResultAdHocSubProcess.md)
- [JobResultCorrections](type-aliases/JobResultCorrections.md)
- [JobResultUserTask](type-aliases/JobResultUserTask.md)
- [JobSearchQuery](type-aliases/JobSearchQuery.md)
- [JobSearchQueryResult](type-aliases/JobSearchQueryResult.md)
- [JobSearchQuerySortRequest](type-aliases/JobSearchQuerySortRequest.md)
- [JobSearchResult](type-aliases/JobSearchResult.md)
- [JobStateEnum](type-aliases/JobStateEnum.md)
- [JobStateExactMatch](type-aliases/JobStateExactMatch.md)
- [JobStateFilterProperty](type-aliases/JobStateFilterProperty.md)
- [JobTimeSeriesStatisticsFilter](type-aliases/JobTimeSeriesStatisticsFilter.md)
- [JobTimeSeriesStatisticsItem](type-aliases/JobTimeSeriesStatisticsItem.md)
- [JobTimeSeriesStatisticsQuery](type-aliases/JobTimeSeriesStatisticsQuery.md)
- [JobTimeSeriesStatisticsQueryResult](type-aliases/JobTimeSeriesStatisticsQueryResult.md)
- [JobTypeStatisticsFilter](type-aliases/JobTypeStatisticsFilter.md)
- [JobTypeStatisticsItem](type-aliases/JobTypeStatisticsItem.md)
- [JobTypeStatisticsQuery](type-aliases/JobTypeStatisticsQuery.md)
- [JobTypeStatisticsQueryResult](type-aliases/JobTypeStatisticsQueryResult.md)
- [JobUpdateRequest](type-aliases/JobUpdateRequest.md)
- [JobWaitStateDetails](type-aliases/JobWaitStateDetails.md)
- [JobWorkerStatisticsFilter](type-aliases/JobWorkerStatisticsFilter.md)
- [JobWorkerStatisticsItem](type-aliases/JobWorkerStatisticsItem.md)
- [JobWorkerStatisticsQuery](type-aliases/JobWorkerStatisticsQuery.md)
- [JobWorkerStatisticsQueryResult](type-aliases/JobWorkerStatisticsQueryResult.md)
- [LicenseResponse](type-aliases/LicenseResponse.md)
- [LikeFilter](type-aliases/LikeFilter.md)
- [LimitPagination](type-aliases/LimitPagination.md)
- [LongKey](type-aliases/LongKey.md)
- [Loose](type-aliases/Loose.md)
- [MappingRuleCreateRequest](type-aliases/MappingRuleCreateRequest.md)
- [MappingRuleCreateResult](type-aliases/MappingRuleCreateResult.md)
- [MappingRuleCreateUpdateRequest](type-aliases/MappingRuleCreateUpdateRequest.md)
- [MappingRuleCreateUpdateResult](type-aliases/MappingRuleCreateUpdateResult.md)
- [MappingRuleFilter](type-aliases/MappingRuleFilter.md)
- [MappingRuleId](type-aliases/MappingRuleId.md)
- [MappingRuleResult](type-aliases/MappingRuleResult.md)
- [MappingRuleSearchQueryRequest](type-aliases/MappingRuleSearchQueryRequest.md)
- [MappingRuleSearchQueryResult](type-aliases/MappingRuleSearchQueryResult.md)
- [MappingRuleSearchQuerySortRequest](type-aliases/MappingRuleSearchQuerySortRequest.md)
- [MappingRuleUpdateRequest](type-aliases/MappingRuleUpdateRequest.md)
- [MappingRuleUpdateResult](type-aliases/MappingRuleUpdateResult.md)
- [MatchedDecisionRuleItem](type-aliases/MatchedDecisionRuleItem.md)
- [MessageCorrelationRequest](type-aliases/MessageCorrelationRequest.md)
- [MessageCorrelationResult](type-aliases/MessageCorrelationResult.md)
- [MessageKey](type-aliases/MessageKey.md)
- [MessagePublicationRequest](type-aliases/MessagePublicationRequest.md)
- [MessagePublicationResult](type-aliases/MessagePublicationResult.md)
- [MessageSubscriptionFilter](type-aliases/MessageSubscriptionFilter.md)
- [MessageSubscriptionKey](type-aliases/MessageSubscriptionKey.md)
- [MessageSubscriptionKeyExactMatch](type-aliases/MessageSubscriptionKeyExactMatch.md)
- [MessageSubscriptionKeyFilterProperty](type-aliases/MessageSubscriptionKeyFilterProperty.md)
- [MessageSubscriptionResult](type-aliases/MessageSubscriptionResult.md)
- [MessageSubscriptionSearchQuery](type-aliases/MessageSubscriptionSearchQuery.md)
- [MessageSubscriptionSearchQueryResult](type-aliases/MessageSubscriptionSearchQueryResult.md)
- [MessageSubscriptionSearchQuerySortRequest](type-aliases/MessageSubscriptionSearchQuerySortRequest.md)
- [MessageSubscriptionStateEnum](type-aliases/MessageSubscriptionStateEnum.md)
- [MessageSubscriptionStateExactMatch](type-aliases/MessageSubscriptionStateExactMatch.md)
- [MessageSubscriptionStateFilterProperty](type-aliases/MessageSubscriptionStateFilterProperty.md)
- [MessageSubscriptionTypeEnum](type-aliases/MessageSubscriptionTypeEnum.md)
- [MessageSubscriptionTypeExactMatch](type-aliases/MessageSubscriptionTypeExactMatch.md)
- [MessageSubscriptionTypeFilterProperty](type-aliases/MessageSubscriptionTypeFilterProperty.md)
- [MessageWaitStateDetails](type-aliases/MessageWaitStateDetails.md)
- [MigrateProcessInstanceData](type-aliases/MigrateProcessInstanceData.md)
- [MigrateProcessInstanceError](type-aliases/MigrateProcessInstanceError.md)
- [MigrateProcessInstanceErrors](type-aliases/MigrateProcessInstanceErrors.md)
- [migrateProcessInstanceInput](type-aliases/migrateProcessInstanceInput.md)
- [MigrateProcessInstanceMappingInstruction](type-aliases/MigrateProcessInstanceMappingInstruction.md)
- [MigrateProcessInstanceResponse](type-aliases/MigrateProcessInstanceResponse.md)
- [MigrateProcessInstanceResponses](type-aliases/MigrateProcessInstanceResponses.md)
- [MigrateProcessInstancesBatchOperationData](type-aliases/MigrateProcessInstancesBatchOperationData.md)
- [MigrateProcessInstancesBatchOperationError](type-aliases/MigrateProcessInstancesBatchOperationError.md)
- [MigrateProcessInstancesBatchOperationErrors](type-aliases/MigrateProcessInstancesBatchOperationErrors.md)
- [migrateProcessInstancesBatchOperationInput](type-aliases/migrateProcessInstancesBatchOperationInput.md)
- [MigrateProcessInstancesBatchOperationResponse](type-aliases/MigrateProcessInstancesBatchOperationResponse.md)
- [MigrateProcessInstancesBatchOperationResponses](type-aliases/MigrateProcessInstancesBatchOperationResponses.md)
- [ModifyProcessInstanceData](type-aliases/ModifyProcessInstanceData.md)
- [ModifyProcessInstanceError](type-aliases/ModifyProcessInstanceError.md)
- [ModifyProcessInstanceErrors](type-aliases/ModifyProcessInstanceErrors.md)
- [modifyProcessInstanceInput](type-aliases/modifyProcessInstanceInput.md)
- [ModifyProcessInstanceResponse](type-aliases/ModifyProcessInstanceResponse.md)
- [ModifyProcessInstanceResponses](type-aliases/ModifyProcessInstanceResponses.md)
- [ModifyProcessInstancesBatchOperationData](type-aliases/ModifyProcessInstancesBatchOperationData.md)
- [ModifyProcessInstancesBatchOperationError](type-aliases/ModifyProcessInstancesBatchOperationError.md)
- [ModifyProcessInstancesBatchOperationErrors](type-aliases/ModifyProcessInstancesBatchOperationErrors.md)
- [modifyProcessInstancesBatchOperationInput](type-aliases/modifyProcessInstancesBatchOperationInput.md)
- [ModifyProcessInstancesBatchOperationResponse](type-aliases/ModifyProcessInstancesBatchOperationResponse.md)
- [ModifyProcessInstancesBatchOperationResponses](type-aliases/ModifyProcessInstancesBatchOperationResponses.md)
- [ModifyProcessInstanceVariableInstruction](type-aliases/ModifyProcessInstanceVariableInstruction.md)
- [OffsetPagination](type-aliases/OffsetPagination.md)
- [OperationReference](type-aliases/OperationReference.md)
- [OperationTypeExactMatch](type-aliases/OperationTypeExactMatch.md)
- [OperationTypeFilterProperty](type-aliases/OperationTypeFilterProperty.md)
- [OwnerTypeEnum](type-aliases/OwnerTypeEnum.md)
- [Partition](type-aliases/Partition.md)
- [PermissionTypeEnum](type-aliases/PermissionTypeEnum.md)
- [PinClockData](type-aliases/PinClockData.md)
- [PinClockError](type-aliases/PinClockError.md)
- [PinClockErrors](type-aliases/PinClockErrors.md)
- [pinClockInput](type-aliases/pinClockInput.md)
- [PinClockResponse](type-aliases/PinClockResponse.md)
- [PinClockResponses](type-aliases/PinClockResponses.md)
- [ProblemDetail](type-aliases/ProblemDetail.md)
- [ProcessDefinitionElementStatisticsQuery](type-aliases/ProcessDefinitionElementStatisticsQuery.md)
- [ProcessDefinitionElementStatisticsQueryResult](type-aliases/ProcessDefinitionElementStatisticsQueryResult.md)
- [ProcessDefinitionFilter](type-aliases/ProcessDefinitionFilter.md)
- [ProcessDefinitionId](type-aliases/ProcessDefinitionId.md)
- [ProcessDefinitionIdExactMatch](type-aliases/ProcessDefinitionIdExactMatch.md)
- [ProcessDefinitionIdFilterProperty](type-aliases/ProcessDefinitionIdFilterProperty.md)
- [ProcessDefinitionInstanceStatisticsQuery](type-aliases/ProcessDefinitionInstanceStatisticsQuery.md)
- [ProcessDefinitionInstanceStatisticsQueryResult](type-aliases/ProcessDefinitionInstanceStatisticsQueryResult.md)
- [ProcessDefinitionInstanceStatisticsQuerySortRequest](type-aliases/ProcessDefinitionInstanceStatisticsQuerySortRequest.md)
- [ProcessDefinitionInstanceStatisticsResult](type-aliases/ProcessDefinitionInstanceStatisticsResult.md)
- [ProcessDefinitionInstanceVersionStatisticsFilter](type-aliases/ProcessDefinitionInstanceVersionStatisticsFilter.md)
- [ProcessDefinitionInstanceVersionStatisticsQuery](type-aliases/ProcessDefinitionInstanceVersionStatisticsQuery.md)
- [ProcessDefinitionInstanceVersionStatisticsQueryResult](type-aliases/ProcessDefinitionInstanceVersionStatisticsQueryResult.md)
- [ProcessDefinitionInstanceVersionStatisticsQuerySortRequest](type-aliases/ProcessDefinitionInstanceVersionStatisticsQuerySortRequest.md)
- [ProcessDefinitionInstanceVersionStatisticsResult](type-aliases/ProcessDefinitionInstanceVersionStatisticsResult.md)
- [ProcessDefinitionKey](type-aliases/ProcessDefinitionKey.md)
- [ProcessDefinitionKeyExactMatch](type-aliases/ProcessDefinitionKeyExactMatch.md)
- [ProcessDefinitionKeyFilterProperty](type-aliases/ProcessDefinitionKeyFilterProperty.md)
- [ProcessDefinitionMessageSubscriptionStatisticsQuery](type-aliases/ProcessDefinitionMessageSubscriptionStatisticsQuery.md)
- [ProcessDefinitionMessageSubscriptionStatisticsQueryResult](type-aliases/ProcessDefinitionMessageSubscriptionStatisticsQueryResult.md)
- [ProcessDefinitionMessageSubscriptionStatisticsResult](type-aliases/ProcessDefinitionMessageSubscriptionStatisticsResult.md)
- [ProcessDefinitionResult](type-aliases/ProcessDefinitionResult.md)
- [ProcessDefinitionSearchQuery](type-aliases/ProcessDefinitionSearchQuery.md)
- [ProcessDefinitionSearchQueryResult](type-aliases/ProcessDefinitionSearchQueryResult.md)
- [ProcessDefinitionSearchQuerySortRequest](type-aliases/ProcessDefinitionSearchQuerySortRequest.md)
- [ProcessDefinitionStatisticsFilter](type-aliases/ProcessDefinitionStatisticsFilter.md)
- [ProcessElementStatisticsResult](type-aliases/ProcessElementStatisticsResult.md)
- [ProcessInstanceCallHierarchyEntry](type-aliases/ProcessInstanceCallHierarchyEntry.md)
- [ProcessInstanceCancellationBatchOperationRequest](type-aliases/ProcessInstanceCancellationBatchOperationRequest.md)
- [ProcessInstanceCreationInstruction](type-aliases/ProcessInstanceCreationInstruction.md)
- [ProcessInstanceCreationInstructionById](type-aliases/ProcessInstanceCreationInstructionById.md)
- [ProcessInstanceCreationInstructionByKey](type-aliases/ProcessInstanceCreationInstructionByKey.md)
- [ProcessInstanceCreationRuntimeInstruction](type-aliases/ProcessInstanceCreationRuntimeInstruction.md)
- [ProcessInstanceCreationStartInstruction](type-aliases/ProcessInstanceCreationStartInstruction.md)
- [ProcessInstanceCreationTerminateInstruction](type-aliases/ProcessInstanceCreationTerminateInstruction.md)
- [ProcessInstanceDeletionBatchOperationRequest](type-aliases/ProcessInstanceDeletionBatchOperationRequest.md)
- [ProcessInstanceElementStatisticsQueryResult](type-aliases/ProcessInstanceElementStatisticsQueryResult.md)
- [ProcessInstanceFilter](type-aliases/ProcessInstanceFilter.md)
- [ProcessInstanceFilterFields](type-aliases/ProcessInstanceFilterFields.md)
- [ProcessInstanceIncidentResolutionBatchOperationRequest](type-aliases/ProcessInstanceIncidentResolutionBatchOperationRequest.md)
- [ProcessInstanceKey](type-aliases/ProcessInstanceKey.md)
- [ProcessInstanceKeyExactMatch](type-aliases/ProcessInstanceKeyExactMatch.md)
- [ProcessInstanceKeyFilterProperty](type-aliases/ProcessInstanceKeyFilterProperty.md)
- [ProcessInstanceMigrationBatchOperationPlan](type-aliases/ProcessInstanceMigrationBatchOperationPlan.md)
- [ProcessInstanceMigrationBatchOperationRequest](type-aliases/ProcessInstanceMigrationBatchOperationRequest.md)
- [ProcessInstanceMigrationInstruction](type-aliases/ProcessInstanceMigrationInstruction.md)
- [ProcessInstanceModificationActivateInstruction](type-aliases/ProcessInstanceModificationActivateInstruction.md)
- [ProcessInstanceModificationBatchOperationRequest](type-aliases/ProcessInstanceModificationBatchOperationRequest.md)
- [ProcessInstanceModificationInstruction](type-aliases/ProcessInstanceModificationInstruction.md)
- [ProcessInstanceModificationMoveBatchOperationInstruction](type-aliases/ProcessInstanceModificationMoveBatchOperationInstruction.md)
- [ProcessInstanceModificationMoveInstruction](type-aliases/ProcessInstanceModificationMoveInstruction.md)
- [ProcessInstanceModificationTerminateByIdInstruction](type-aliases/ProcessInstanceModificationTerminateByIdInstruction.md)
- [ProcessInstanceModificationTerminateByKeyInstruction](type-aliases/ProcessInstanceModificationTerminateByKeyInstruction.md)
- [ProcessInstanceModificationTerminateInstruction](type-aliases/ProcessInstanceModificationTerminateInstruction.md)
- [ProcessInstanceReference](type-aliases/ProcessInstanceReference.md)
- [ProcessInstanceResult](type-aliases/ProcessInstanceResult.md)
- [ProcessInstanceSearchQuery](type-aliases/ProcessInstanceSearchQuery.md)
- [ProcessInstanceSearchQueryResult](type-aliases/ProcessInstanceSearchQueryResult.md)
- [ProcessInstanceSearchQuerySortRequest](type-aliases/ProcessInstanceSearchQuerySortRequest.md)
- [ProcessInstanceSequenceFlowResult](type-aliases/ProcessInstanceSequenceFlowResult.md)
- [ProcessInstanceSequenceFlowsQueryResult](type-aliases/ProcessInstanceSequenceFlowsQueryResult.md)
- [ProcessInstanceStateEnum](type-aliases/ProcessInstanceStateEnum.md)
- [ProcessInstanceStateExactMatch](type-aliases/ProcessInstanceStateExactMatch.md)
- [ProcessInstanceStateFilterProperty](type-aliases/ProcessInstanceStateFilterProperty.md)
- [ProcessInstanceWaitStateStatisticsQueryResult](type-aliases/ProcessInstanceWaitStateStatisticsQueryResult.md)
- [ProcessInstanceWaitStateStatisticsResult](type-aliases/ProcessInstanceWaitStateStatisticsResult.md)
- [PublishMessageData](type-aliases/PublishMessageData.md)
- [PublishMessageError](type-aliases/PublishMessageError.md)
- [PublishMessageErrors](type-aliases/PublishMessageErrors.md)
- [publishMessageInput](type-aliases/publishMessageInput.md)
- [PublishMessageResponse](type-aliases/PublishMessageResponse.md)
- [PublishMessageResponses](type-aliases/PublishMessageResponses.md)
- [ResetClockData](type-aliases/ResetClockData.md)
- [ResetClockError](type-aliases/ResetClockError.md)
- [ResetClockErrors](type-aliases/ResetClockErrors.md)
- [resetClockInput](type-aliases/resetClockInput.md)
- [ResetClockResponse](type-aliases/ResetClockResponse.md)
- [ResetClockResponses](type-aliases/ResetClockResponses.md)
- [ResolveIncidentData](type-aliases/ResolveIncidentData.md)
- [ResolveIncidentError](type-aliases/ResolveIncidentError.md)
- [ResolveIncidentErrors](type-aliases/ResolveIncidentErrors.md)
- [resolveIncidentInput](type-aliases/resolveIncidentInput.md)
- [ResolveIncidentResponse](type-aliases/ResolveIncidentResponse.md)
- [ResolveIncidentResponses](type-aliases/ResolveIncidentResponses.md)
- [ResolveIncidentsBatchOperationData](type-aliases/ResolveIncidentsBatchOperationData.md)
- [ResolveIncidentsBatchOperationError](type-aliases/ResolveIncidentsBatchOperationError.md)
- [ResolveIncidentsBatchOperationErrors](type-aliases/ResolveIncidentsBatchOperationErrors.md)
- [resolveIncidentsBatchOperationInput](type-aliases/resolveIncidentsBatchOperationInput.md)
- [ResolveIncidentsBatchOperationResponse](type-aliases/ResolveIncidentsBatchOperationResponse.md)
- [ResolveIncidentsBatchOperationResponses](type-aliases/ResolveIncidentsBatchOperationResponses.md)
- [ResolveProcessInstanceIncidentsData](type-aliases/ResolveProcessInstanceIncidentsData.md)
- [ResolveProcessInstanceIncidentsError](type-aliases/ResolveProcessInstanceIncidentsError.md)
- [ResolveProcessInstanceIncidentsErrors](type-aliases/ResolveProcessInstanceIncidentsErrors.md)
- [resolveProcessInstanceIncidentsInput](type-aliases/resolveProcessInstanceIncidentsInput.md)
- [ResolveProcessInstanceIncidentsResponse](type-aliases/ResolveProcessInstanceIncidentsResponse.md)
- [ResolveProcessInstanceIncidentsResponses](type-aliases/ResolveProcessInstanceIncidentsResponses.md)
- [ResourceFilter](type-aliases/ResourceFilter.md)
- [ResourceKey](type-aliases/ResourceKey.md)
- [ResourceKeyExactMatch](type-aliases/ResourceKeyExactMatch.md)
- [ResourceKeyFilterProperty](type-aliases/ResourceKeyFilterProperty.md)
- [ResourceResult](type-aliases/ResourceResult.md)
- [ResourceSearchQuery](type-aliases/ResourceSearchQuery.md)
- [ResourceSearchQueryResult](type-aliases/ResourceSearchQueryResult.md)
- [ResourceSearchQuerySortRequest](type-aliases/ResourceSearchQuerySortRequest.md)
- [ResourceTypeEnum](type-aliases/ResourceTypeEnum.md)
- [Result](type-aliases/Result.md)
- [ResumeBatchOperationData](type-aliases/ResumeBatchOperationData.md)
- [ResumeBatchOperationError](type-aliases/ResumeBatchOperationError.md)
- [ResumeBatchOperationErrors](type-aliases/ResumeBatchOperationErrors.md)
- [resumeBatchOperationInput](type-aliases/resumeBatchOperationInput.md)
- [ResumeBatchOperationResponse](type-aliases/ResumeBatchOperationResponse.md)
- [ResumeBatchOperationResponses](type-aliases/ResumeBatchOperationResponses.md)
- [RoleClientResult](type-aliases/RoleClientResult.md)
- [RoleClientSearchQueryRequest](type-aliases/RoleClientSearchQueryRequest.md)
- [RoleClientSearchQuerySortRequest](type-aliases/RoleClientSearchQuerySortRequest.md)
- [RoleClientSearchResult](type-aliases/RoleClientSearchResult.md)
- [RoleCreateRequest](type-aliases/RoleCreateRequest.md)
- [RoleCreateResult](type-aliases/RoleCreateResult.md)
- [RoleFilter](type-aliases/RoleFilter.md)
- [RoleGroupResult](type-aliases/RoleGroupResult.md)
- [RoleGroupSearchQueryRequest](type-aliases/RoleGroupSearchQueryRequest.md)
- [RoleGroupSearchQuerySortRequest](type-aliases/RoleGroupSearchQuerySortRequest.md)
- [RoleGroupSearchResult](type-aliases/RoleGroupSearchResult.md)
- [RoleId](type-aliases/RoleId.md)
- [RoleMappingRuleSearchResult](type-aliases/RoleMappingRuleSearchResult.md)
- [RoleResult](type-aliases/RoleResult.md)
- [RoleSearchQueryRequest](type-aliases/RoleSearchQueryRequest.md)
- [RoleSearchQueryResult](type-aliases/RoleSearchQueryResult.md)
- [RoleSearchQuerySortRequest](type-aliases/RoleSearchQuerySortRequest.md)
- [RoleUpdateRequest](type-aliases/RoleUpdateRequest.md)
- [RoleUpdateResult](type-aliases/RoleUpdateResult.md)
- [RoleUserResult](type-aliases/RoleUserResult.md)
- [RoleUserSearchQueryRequest](type-aliases/RoleUserSearchQueryRequest.md)
- [RoleUserSearchQuerySortRequest](type-aliases/RoleUserSearchQuerySortRequest.md)
- [RoleUserSearchResult](type-aliases/RoleUserSearchResult.md)
- [ScopeKey](type-aliases/ScopeKey.md)
- [ScopeKeyExactMatch](type-aliases/ScopeKeyExactMatch.md)
- [ScopeKeyFilterProperty](type-aliases/ScopeKeyFilterProperty.md)
- [SdkError](type-aliases/SdkError.md)
- [searchAgentInstanceHistoryConsistency](type-aliases/searchAgentInstanceHistoryConsistency.md)
- [SearchAgentInstanceHistoryData](type-aliases/SearchAgentInstanceHistoryData.md)
- [SearchAgentInstanceHistoryError](type-aliases/SearchAgentInstanceHistoryError.md)
- [SearchAgentInstanceHistoryErrors](type-aliases/SearchAgentInstanceHistoryErrors.md)
- [searchAgentInstanceHistoryInput](type-aliases/searchAgentInstanceHistoryInput.md)
- [SearchAgentInstanceHistoryResponse](type-aliases/SearchAgentInstanceHistoryResponse.md)
- [SearchAgentInstanceHistoryResponses](type-aliases/SearchAgentInstanceHistoryResponses.md)
- [searchAgentInstancesConsistency](type-aliases/searchAgentInstancesConsistency.md)
- [SearchAgentInstancesData](type-aliases/SearchAgentInstancesData.md)
- [SearchAgentInstancesError](type-aliases/SearchAgentInstancesError.md)
- [SearchAgentInstancesErrors](type-aliases/SearchAgentInstancesErrors.md)
- [searchAgentInstancesInput](type-aliases/searchAgentInstancesInput.md)
- [SearchAgentInstancesResponse](type-aliases/SearchAgentInstancesResponse.md)
- [SearchAgentInstancesResponses](type-aliases/SearchAgentInstancesResponses.md)
- [searchAuditLogsConsistency](type-aliases/searchAuditLogsConsistency.md)
- [SearchAuditLogsData](type-aliases/SearchAuditLogsData.md)
- [SearchAuditLogsError](type-aliases/SearchAuditLogsError.md)
- [SearchAuditLogsErrors](type-aliases/SearchAuditLogsErrors.md)
- [searchAuditLogsInput](type-aliases/searchAuditLogsInput.md)
- [SearchAuditLogsResponse](type-aliases/SearchAuditLogsResponse.md)
- [SearchAuditLogsResponses](type-aliases/SearchAuditLogsResponses.md)
- [searchAuthorizationsConsistency](type-aliases/searchAuthorizationsConsistency.md)
- [SearchAuthorizationsData](type-aliases/SearchAuthorizationsData.md)
- [SearchAuthorizationsError](type-aliases/SearchAuthorizationsError.md)
- [SearchAuthorizationsErrors](type-aliases/SearchAuthorizationsErrors.md)
- [searchAuthorizationsInput](type-aliases/searchAuthorizationsInput.md)
- [SearchAuthorizationsResponse](type-aliases/SearchAuthorizationsResponse.md)
- [SearchAuthorizationsResponses](type-aliases/SearchAuthorizationsResponses.md)
- [searchBatchOperationItemsConsistency](type-aliases/searchBatchOperationItemsConsistency.md)
- [SearchBatchOperationItemsData](type-aliases/SearchBatchOperationItemsData.md)
- [SearchBatchOperationItemsError](type-aliases/SearchBatchOperationItemsError.md)
- [SearchBatchOperationItemsErrors](type-aliases/SearchBatchOperationItemsErrors.md)
- [searchBatchOperationItemsInput](type-aliases/searchBatchOperationItemsInput.md)
- [SearchBatchOperationItemsResponse](type-aliases/SearchBatchOperationItemsResponse.md)
- [SearchBatchOperationItemsResponses](type-aliases/SearchBatchOperationItemsResponses.md)
- [searchBatchOperationsConsistency](type-aliases/searchBatchOperationsConsistency.md)
- [SearchBatchOperationsData](type-aliases/SearchBatchOperationsData.md)
- [SearchBatchOperationsError](type-aliases/SearchBatchOperationsError.md)
- [SearchBatchOperationsErrors](type-aliases/SearchBatchOperationsErrors.md)
- [searchBatchOperationsInput](type-aliases/searchBatchOperationsInput.md)
- [SearchBatchOperationsResponse](type-aliases/SearchBatchOperationsResponse.md)
- [SearchBatchOperationsResponses](type-aliases/SearchBatchOperationsResponses.md)
- [searchClientsForGroupConsistency](type-aliases/searchClientsForGroupConsistency.md)
- [SearchClientsForGroupData](type-aliases/SearchClientsForGroupData.md)
- [SearchClientsForGroupError](type-aliases/SearchClientsForGroupError.md)
- [SearchClientsForGroupErrors](type-aliases/SearchClientsForGroupErrors.md)
- [searchClientsForGroupInput](type-aliases/searchClientsForGroupInput.md)
- [SearchClientsForGroupResponse](type-aliases/SearchClientsForGroupResponse.md)
- [SearchClientsForGroupResponses](type-aliases/SearchClientsForGroupResponses.md)
- [searchClientsForRoleConsistency](type-aliases/searchClientsForRoleConsistency.md)
- [SearchClientsForRoleData](type-aliases/SearchClientsForRoleData.md)
- [SearchClientsForRoleError](type-aliases/SearchClientsForRoleError.md)
- [SearchClientsForRoleErrors](type-aliases/SearchClientsForRoleErrors.md)
- [searchClientsForRoleInput](type-aliases/searchClientsForRoleInput.md)
- [SearchClientsForRoleResponse](type-aliases/SearchClientsForRoleResponse.md)
- [SearchClientsForRoleResponses](type-aliases/SearchClientsForRoleResponses.md)
- [searchClientsForTenantConsistency](type-aliases/searchClientsForTenantConsistency.md)
- [SearchClientsForTenantData](type-aliases/SearchClientsForTenantData.md)
- [searchClientsForTenantInput](type-aliases/searchClientsForTenantInput.md)
- [SearchClientsForTenantResponse](type-aliases/SearchClientsForTenantResponse.md)
- [SearchClientsForTenantResponses](type-aliases/SearchClientsForTenantResponses.md)
- [searchClusterVariablesConsistency](type-aliases/searchClusterVariablesConsistency.md)
- [SearchClusterVariablesData](type-aliases/SearchClusterVariablesData.md)
- [SearchClusterVariablesError](type-aliases/SearchClusterVariablesError.md)
- [SearchClusterVariablesErrors](type-aliases/SearchClusterVariablesErrors.md)
- [searchClusterVariablesInput](type-aliases/searchClusterVariablesInput.md)
- [SearchClusterVariablesResponse](type-aliases/SearchClusterVariablesResponse.md)
- [SearchClusterVariablesResponses](type-aliases/SearchClusterVariablesResponses.md)
- [searchCorrelatedMessageSubscriptionsConsistency](type-aliases/searchCorrelatedMessageSubscriptionsConsistency.md)
- [SearchCorrelatedMessageSubscriptionsData](type-aliases/SearchCorrelatedMessageSubscriptionsData.md)
- [SearchCorrelatedMessageSubscriptionsError](type-aliases/SearchCorrelatedMessageSubscriptionsError.md)
- [SearchCorrelatedMessageSubscriptionsErrors](type-aliases/SearchCorrelatedMessageSubscriptionsErrors.md)
- [searchCorrelatedMessageSubscriptionsInput](type-aliases/searchCorrelatedMessageSubscriptionsInput.md)
- [SearchCorrelatedMessageSubscriptionsResponse](type-aliases/SearchCorrelatedMessageSubscriptionsResponse.md)
- [SearchCorrelatedMessageSubscriptionsResponses](type-aliases/SearchCorrelatedMessageSubscriptionsResponses.md)
- [searchDecisionDefinitionsConsistency](type-aliases/searchDecisionDefinitionsConsistency.md)
- [SearchDecisionDefinitionsData](type-aliases/SearchDecisionDefinitionsData.md)
- [SearchDecisionDefinitionsError](type-aliases/SearchDecisionDefinitionsError.md)
- [SearchDecisionDefinitionsErrors](type-aliases/SearchDecisionDefinitionsErrors.md)
- [searchDecisionDefinitionsInput](type-aliases/searchDecisionDefinitionsInput.md)
- [SearchDecisionDefinitionsResponse](type-aliases/SearchDecisionDefinitionsResponse.md)
- [SearchDecisionDefinitionsResponses](type-aliases/SearchDecisionDefinitionsResponses.md)
- [searchDecisionInstancesConsistency](type-aliases/searchDecisionInstancesConsistency.md)
- [SearchDecisionInstancesData](type-aliases/SearchDecisionInstancesData.md)
- [SearchDecisionInstancesError](type-aliases/SearchDecisionInstancesError.md)
- [SearchDecisionInstancesErrors](type-aliases/SearchDecisionInstancesErrors.md)
- [searchDecisionInstancesInput](type-aliases/searchDecisionInstancesInput.md)
- [SearchDecisionInstancesResponse](type-aliases/SearchDecisionInstancesResponse.md)
- [SearchDecisionInstancesResponses](type-aliases/SearchDecisionInstancesResponses.md)
- [searchDecisionRequirementsConsistency](type-aliases/searchDecisionRequirementsConsistency.md)
- [SearchDecisionRequirementsData](type-aliases/SearchDecisionRequirementsData.md)
- [SearchDecisionRequirementsError](type-aliases/SearchDecisionRequirementsError.md)
- [SearchDecisionRequirementsErrors](type-aliases/SearchDecisionRequirementsErrors.md)
- [searchDecisionRequirementsInput](type-aliases/searchDecisionRequirementsInput.md)
- [SearchDecisionRequirementsResponse](type-aliases/SearchDecisionRequirementsResponse.md)
- [SearchDecisionRequirementsResponses](type-aliases/SearchDecisionRequirementsResponses.md)
- [searchElementInstanceIncidentsConsistency](type-aliases/searchElementInstanceIncidentsConsistency.md)
- [SearchElementInstanceIncidentsData](type-aliases/SearchElementInstanceIncidentsData.md)
- [SearchElementInstanceIncidentsError](type-aliases/SearchElementInstanceIncidentsError.md)
- [SearchElementInstanceIncidentsErrors](type-aliases/SearchElementInstanceIncidentsErrors.md)
- [searchElementInstanceIncidentsInput](type-aliases/searchElementInstanceIncidentsInput.md)
- [SearchElementInstanceIncidentsResponse](type-aliases/SearchElementInstanceIncidentsResponse.md)
- [SearchElementInstanceIncidentsResponses](type-aliases/SearchElementInstanceIncidentsResponses.md)
- [searchElementInstancesConsistency](type-aliases/searchElementInstancesConsistency.md)
- [SearchElementInstancesData](type-aliases/SearchElementInstancesData.md)
- [SearchElementInstancesError](type-aliases/SearchElementInstancesError.md)
- [SearchElementInstancesErrors](type-aliases/SearchElementInstancesErrors.md)
- [searchElementInstancesInput](type-aliases/searchElementInstancesInput.md)
- [SearchElementInstancesResponse](type-aliases/SearchElementInstancesResponse.md)
- [SearchElementInstancesResponses](type-aliases/SearchElementInstancesResponses.md)
- [searchElementInstanceWaitStatesConsistency](type-aliases/searchElementInstanceWaitStatesConsistency.md)
- [SearchElementInstanceWaitStatesData](type-aliases/SearchElementInstanceWaitStatesData.md)
- [SearchElementInstanceWaitStatesError](type-aliases/SearchElementInstanceWaitStatesError.md)
- [SearchElementInstanceWaitStatesErrors](type-aliases/SearchElementInstanceWaitStatesErrors.md)
- [searchElementInstanceWaitStatesInput](type-aliases/searchElementInstanceWaitStatesInput.md)
- [SearchElementInstanceWaitStatesResponse](type-aliases/SearchElementInstanceWaitStatesResponse.md)
- [SearchElementInstanceWaitStatesResponses](type-aliases/SearchElementInstanceWaitStatesResponses.md)
- [searchGlobalTaskListenersConsistency](type-aliases/searchGlobalTaskListenersConsistency.md)
- [SearchGlobalTaskListenersData](type-aliases/SearchGlobalTaskListenersData.md)
- [SearchGlobalTaskListenersError](type-aliases/SearchGlobalTaskListenersError.md)
- [SearchGlobalTaskListenersErrors](type-aliases/SearchGlobalTaskListenersErrors.md)
- [searchGlobalTaskListenersInput](type-aliases/searchGlobalTaskListenersInput.md)
- [SearchGlobalTaskListenersResponse](type-aliases/SearchGlobalTaskListenersResponse.md)
- [SearchGlobalTaskListenersResponses](type-aliases/SearchGlobalTaskListenersResponses.md)
- [searchGroupIdsForTenantConsistency](type-aliases/searchGroupIdsForTenantConsistency.md)
- [SearchGroupIdsForTenantData](type-aliases/SearchGroupIdsForTenantData.md)
- [searchGroupIdsForTenantInput](type-aliases/searchGroupIdsForTenantInput.md)
- [SearchGroupIdsForTenantResponse](type-aliases/SearchGroupIdsForTenantResponse.md)
- [SearchGroupIdsForTenantResponses](type-aliases/SearchGroupIdsForTenantResponses.md)
- [searchGroupsConsistency](type-aliases/searchGroupsConsistency.md)
- [SearchGroupsData](type-aliases/SearchGroupsData.md)
- [SearchGroupsError](type-aliases/SearchGroupsError.md)
- [SearchGroupsErrors](type-aliases/SearchGroupsErrors.md)
- [searchGroupsForRoleConsistency](type-aliases/searchGroupsForRoleConsistency.md)
- [SearchGroupsForRoleData](type-aliases/SearchGroupsForRoleData.md)
- [SearchGroupsForRoleError](type-aliases/SearchGroupsForRoleError.md)
- [SearchGroupsForRoleErrors](type-aliases/SearchGroupsForRoleErrors.md)
- [searchGroupsForRoleInput](type-aliases/searchGroupsForRoleInput.md)
- [SearchGroupsForRoleResponse](type-aliases/SearchGroupsForRoleResponse.md)
- [SearchGroupsForRoleResponses](type-aliases/SearchGroupsForRoleResponses.md)
- [searchGroupsInput](type-aliases/searchGroupsInput.md)
- [SearchGroupsResponse](type-aliases/SearchGroupsResponse.md)
- [SearchGroupsResponses](type-aliases/SearchGroupsResponses.md)
- [searchIncidentsConsistency](type-aliases/searchIncidentsConsistency.md)
- [SearchIncidentsData](type-aliases/SearchIncidentsData.md)
- [SearchIncidentsError](type-aliases/SearchIncidentsError.md)
- [SearchIncidentsErrors](type-aliases/SearchIncidentsErrors.md)
- [searchIncidentsInput](type-aliases/searchIncidentsInput.md)
- [SearchIncidentsResponse](type-aliases/SearchIncidentsResponse.md)
- [SearchIncidentsResponses](type-aliases/SearchIncidentsResponses.md)
- [searchJobsConsistency](type-aliases/searchJobsConsistency.md)
- [SearchJobsData](type-aliases/SearchJobsData.md)
- [SearchJobsError](type-aliases/SearchJobsError.md)
- [SearchJobsErrors](type-aliases/SearchJobsErrors.md)
- [searchJobsInput](type-aliases/searchJobsInput.md)
- [SearchJobsResponse](type-aliases/SearchJobsResponse.md)
- [SearchJobsResponses](type-aliases/SearchJobsResponses.md)
- [searchMappingRuleConsistency](type-aliases/searchMappingRuleConsistency.md)
- [SearchMappingRuleData](type-aliases/SearchMappingRuleData.md)
- [SearchMappingRuleError](type-aliases/SearchMappingRuleError.md)
- [SearchMappingRuleErrors](type-aliases/SearchMappingRuleErrors.md)
- [searchMappingRuleInput](type-aliases/searchMappingRuleInput.md)
- [SearchMappingRuleResponse](type-aliases/SearchMappingRuleResponse.md)
- [SearchMappingRuleResponses](type-aliases/SearchMappingRuleResponses.md)
- [searchMappingRulesForGroupConsistency](type-aliases/searchMappingRulesForGroupConsistency.md)
- [SearchMappingRulesForGroupData](type-aliases/SearchMappingRulesForGroupData.md)
- [SearchMappingRulesForGroupError](type-aliases/SearchMappingRulesForGroupError.md)
- [SearchMappingRulesForGroupErrors](type-aliases/SearchMappingRulesForGroupErrors.md)
- [searchMappingRulesForGroupInput](type-aliases/searchMappingRulesForGroupInput.md)
- [SearchMappingRulesForGroupResponse](type-aliases/SearchMappingRulesForGroupResponse.md)
- [SearchMappingRulesForGroupResponses](type-aliases/SearchMappingRulesForGroupResponses.md)
- [searchMappingRulesForRoleConsistency](type-aliases/searchMappingRulesForRoleConsistency.md)
- [SearchMappingRulesForRoleData](type-aliases/SearchMappingRulesForRoleData.md)
- [SearchMappingRulesForRoleError](type-aliases/SearchMappingRulesForRoleError.md)
- [SearchMappingRulesForRoleErrors](type-aliases/SearchMappingRulesForRoleErrors.md)
- [searchMappingRulesForRoleInput](type-aliases/searchMappingRulesForRoleInput.md)
- [SearchMappingRulesForRoleResponse](type-aliases/SearchMappingRulesForRoleResponse.md)
- [SearchMappingRulesForRoleResponses](type-aliases/SearchMappingRulesForRoleResponses.md)
- [searchMappingRulesForTenantConsistency](type-aliases/searchMappingRulesForTenantConsistency.md)
- [SearchMappingRulesForTenantData](type-aliases/SearchMappingRulesForTenantData.md)
- [searchMappingRulesForTenantInput](type-aliases/searchMappingRulesForTenantInput.md)
- [SearchMappingRulesForTenantResponse](type-aliases/SearchMappingRulesForTenantResponse.md)
- [SearchMappingRulesForTenantResponses](type-aliases/SearchMappingRulesForTenantResponses.md)
- [searchMessageSubscriptionsConsistency](type-aliases/searchMessageSubscriptionsConsistency.md)
- [SearchMessageSubscriptionsData](type-aliases/SearchMessageSubscriptionsData.md)
- [SearchMessageSubscriptionsError](type-aliases/SearchMessageSubscriptionsError.md)
- [SearchMessageSubscriptionsErrors](type-aliases/SearchMessageSubscriptionsErrors.md)
- [searchMessageSubscriptionsInput](type-aliases/searchMessageSubscriptionsInput.md)
- [SearchMessageSubscriptionsResponse](type-aliases/SearchMessageSubscriptionsResponse.md)
- [SearchMessageSubscriptionsResponses](type-aliases/SearchMessageSubscriptionsResponses.md)
- [searchProcessDefinitionsConsistency](type-aliases/searchProcessDefinitionsConsistency.md)
- [SearchProcessDefinitionsData](type-aliases/SearchProcessDefinitionsData.md)
- [SearchProcessDefinitionsError](type-aliases/SearchProcessDefinitionsError.md)
- [SearchProcessDefinitionsErrors](type-aliases/SearchProcessDefinitionsErrors.md)
- [searchProcessDefinitionsInput](type-aliases/searchProcessDefinitionsInput.md)
- [SearchProcessDefinitionsResponse](type-aliases/SearchProcessDefinitionsResponse.md)
- [SearchProcessDefinitionsResponses](type-aliases/SearchProcessDefinitionsResponses.md)
- [searchProcessInstanceIncidentsConsistency](type-aliases/searchProcessInstanceIncidentsConsistency.md)
- [SearchProcessInstanceIncidentsData](type-aliases/SearchProcessInstanceIncidentsData.md)
- [SearchProcessInstanceIncidentsError](type-aliases/SearchProcessInstanceIncidentsError.md)
- [SearchProcessInstanceIncidentsErrors](type-aliases/SearchProcessInstanceIncidentsErrors.md)
- [searchProcessInstanceIncidentsInput](type-aliases/searchProcessInstanceIncidentsInput.md)
- [SearchProcessInstanceIncidentsResponse](type-aliases/SearchProcessInstanceIncidentsResponse.md)
- [SearchProcessInstanceIncidentsResponses](type-aliases/SearchProcessInstanceIncidentsResponses.md)
- [searchProcessInstancesConsistency](type-aliases/searchProcessInstancesConsistency.md)
- [SearchProcessInstancesData](type-aliases/SearchProcessInstancesData.md)
- [SearchProcessInstancesError](type-aliases/SearchProcessInstancesError.md)
- [SearchProcessInstancesErrors](type-aliases/SearchProcessInstancesErrors.md)
- [searchProcessInstancesInput](type-aliases/searchProcessInstancesInput.md)
- [SearchProcessInstancesResponse](type-aliases/SearchProcessInstancesResponse.md)
- [SearchProcessInstancesResponses](type-aliases/SearchProcessInstancesResponses.md)
- [SearchQueryPageRequest](type-aliases/SearchQueryPageRequest.md)
- [SearchQueryPageResponse](type-aliases/SearchQueryPageResponse.md)
- [SearchQueryRequest](type-aliases/SearchQueryRequest.md)
- [SearchQueryResponse](type-aliases/SearchQueryResponse.md)
- [searchResourcesConsistency](type-aliases/searchResourcesConsistency.md)
- [SearchResourcesData](type-aliases/SearchResourcesData.md)
- [SearchResourcesError](type-aliases/SearchResourcesError.md)
- [SearchResourcesErrors](type-aliases/SearchResourcesErrors.md)
- [searchResourcesInput](type-aliases/searchResourcesInput.md)
- [SearchResourcesResponse](type-aliases/SearchResourcesResponse.md)
- [SearchResourcesResponses](type-aliases/SearchResourcesResponses.md)
- [searchRolesConsistency](type-aliases/searchRolesConsistency.md)
- [SearchRolesData](type-aliases/SearchRolesData.md)
- [SearchRolesError](type-aliases/SearchRolesError.md)
- [SearchRolesErrors](type-aliases/SearchRolesErrors.md)
- [searchRolesForGroupConsistency](type-aliases/searchRolesForGroupConsistency.md)
- [SearchRolesForGroupData](type-aliases/SearchRolesForGroupData.md)
- [SearchRolesForGroupError](type-aliases/SearchRolesForGroupError.md)
- [SearchRolesForGroupErrors](type-aliases/SearchRolesForGroupErrors.md)
- [searchRolesForGroupInput](type-aliases/searchRolesForGroupInput.md)
- [SearchRolesForGroupResponse](type-aliases/SearchRolesForGroupResponse.md)
- [SearchRolesForGroupResponses](type-aliases/SearchRolesForGroupResponses.md)
- [searchRolesForTenantConsistency](type-aliases/searchRolesForTenantConsistency.md)
- [SearchRolesForTenantData](type-aliases/SearchRolesForTenantData.md)
- [searchRolesForTenantInput](type-aliases/searchRolesForTenantInput.md)
- [SearchRolesForTenantResponse](type-aliases/SearchRolesForTenantResponse.md)
- [SearchRolesForTenantResponses](type-aliases/SearchRolesForTenantResponses.md)
- [searchRolesInput](type-aliases/searchRolesInput.md)
- [SearchRolesResponse](type-aliases/SearchRolesResponse.md)
- [SearchRolesResponses](type-aliases/SearchRolesResponses.md)
- [searchTenantsConsistency](type-aliases/searchTenantsConsistency.md)
- [SearchTenantsData](type-aliases/SearchTenantsData.md)
- [SearchTenantsError](type-aliases/SearchTenantsError.md)
- [SearchTenantsErrors](type-aliases/SearchTenantsErrors.md)
- [searchTenantsInput](type-aliases/searchTenantsInput.md)
- [SearchTenantsResponse](type-aliases/SearchTenantsResponse.md)
- [SearchTenantsResponses](type-aliases/SearchTenantsResponses.md)
- [searchUsersConsistency](type-aliases/searchUsersConsistency.md)
- [SearchUsersData](type-aliases/SearchUsersData.md)
- [SearchUsersError](type-aliases/SearchUsersError.md)
- [SearchUsersErrors](type-aliases/SearchUsersErrors.md)
- [searchUsersForGroupConsistency](type-aliases/searchUsersForGroupConsistency.md)
- [SearchUsersForGroupData](type-aliases/SearchUsersForGroupData.md)
- [SearchUsersForGroupError](type-aliases/SearchUsersForGroupError.md)
- [SearchUsersForGroupErrors](type-aliases/SearchUsersForGroupErrors.md)
- [searchUsersForGroupInput](type-aliases/searchUsersForGroupInput.md)
- [SearchUsersForGroupResponse](type-aliases/SearchUsersForGroupResponse.md)
- [SearchUsersForGroupResponses](type-aliases/SearchUsersForGroupResponses.md)
- [searchUsersForRoleConsistency](type-aliases/searchUsersForRoleConsistency.md)
- [SearchUsersForRoleData](type-aliases/SearchUsersForRoleData.md)
- [SearchUsersForRoleError](type-aliases/SearchUsersForRoleError.md)
- [SearchUsersForRoleErrors](type-aliases/SearchUsersForRoleErrors.md)
- [searchUsersForRoleInput](type-aliases/searchUsersForRoleInput.md)
- [SearchUsersForRoleResponse](type-aliases/SearchUsersForRoleResponse.md)
- [SearchUsersForRoleResponses](type-aliases/SearchUsersForRoleResponses.md)
- [searchUsersForTenantConsistency](type-aliases/searchUsersForTenantConsistency.md)
- [SearchUsersForTenantData](type-aliases/SearchUsersForTenantData.md)
- [searchUsersForTenantInput](type-aliases/searchUsersForTenantInput.md)
- [SearchUsersForTenantResponse](type-aliases/SearchUsersForTenantResponse.md)
- [SearchUsersForTenantResponses](type-aliases/SearchUsersForTenantResponses.md)
- [searchUsersInput](type-aliases/searchUsersInput.md)
- [SearchUsersResponse](type-aliases/SearchUsersResponse.md)
- [SearchUsersResponses](type-aliases/SearchUsersResponses.md)
- [searchUserTaskAuditLogsConsistency](type-aliases/searchUserTaskAuditLogsConsistency.md)
- [SearchUserTaskAuditLogsData](type-aliases/SearchUserTaskAuditLogsData.md)
- [SearchUserTaskAuditLogsError](type-aliases/SearchUserTaskAuditLogsError.md)
- [SearchUserTaskAuditLogsErrors](type-aliases/SearchUserTaskAuditLogsErrors.md)
- [searchUserTaskAuditLogsInput](type-aliases/searchUserTaskAuditLogsInput.md)
- [SearchUserTaskAuditLogsResponse](type-aliases/SearchUserTaskAuditLogsResponse.md)
- [SearchUserTaskAuditLogsResponses](type-aliases/SearchUserTaskAuditLogsResponses.md)
- [searchUserTaskEffectiveVariablesConsistency](type-aliases/searchUserTaskEffectiveVariablesConsistency.md)
- [SearchUserTaskEffectiveVariablesData](type-aliases/SearchUserTaskEffectiveVariablesData.md)
- [SearchUserTaskEffectiveVariablesError](type-aliases/SearchUserTaskEffectiveVariablesError.md)
- [SearchUserTaskEffectiveVariablesErrors](type-aliases/SearchUserTaskEffectiveVariablesErrors.md)
- [searchUserTaskEffectiveVariablesInput](type-aliases/searchUserTaskEffectiveVariablesInput.md)
- [SearchUserTaskEffectiveVariablesResponse](type-aliases/SearchUserTaskEffectiveVariablesResponse.md)
- [SearchUserTaskEffectiveVariablesResponses](type-aliases/SearchUserTaskEffectiveVariablesResponses.md)
- [searchUserTasksConsistency](type-aliases/searchUserTasksConsistency.md)
- [SearchUserTasksData](type-aliases/SearchUserTasksData.md)
- [SearchUserTasksError](type-aliases/SearchUserTasksError.md)
- [SearchUserTasksErrors](type-aliases/SearchUserTasksErrors.md)
- [searchUserTasksInput](type-aliases/searchUserTasksInput.md)
- [SearchUserTasksResponse](type-aliases/SearchUserTasksResponse.md)
- [SearchUserTasksResponses](type-aliases/SearchUserTasksResponses.md)
- [searchUserTaskVariablesConsistency](type-aliases/searchUserTaskVariablesConsistency.md)
- [SearchUserTaskVariablesData](type-aliases/SearchUserTaskVariablesData.md)
- [SearchUserTaskVariablesError](type-aliases/SearchUserTaskVariablesError.md)
- [SearchUserTaskVariablesErrors](type-aliases/SearchUserTaskVariablesErrors.md)
- [searchUserTaskVariablesInput](type-aliases/searchUserTaskVariablesInput.md)
- [SearchUserTaskVariablesResponse](type-aliases/SearchUserTaskVariablesResponse.md)
- [SearchUserTaskVariablesResponses](type-aliases/SearchUserTaskVariablesResponses.md)
- [searchVariablesConsistency](type-aliases/searchVariablesConsistency.md)
- [SearchVariablesData](type-aliases/SearchVariablesData.md)
- [SearchVariablesError](type-aliases/SearchVariablesError.md)
- [SearchVariablesErrors](type-aliases/SearchVariablesErrors.md)
- [searchVariablesInput](type-aliases/searchVariablesInput.md)
- [SearchVariablesResponse](type-aliases/SearchVariablesResponse.md)
- [SearchVariablesResponses](type-aliases/SearchVariablesResponses.md)
- [SetVariableRequest](type-aliases/SetVariableRequest.md)
- [SignalBroadcastRequest](type-aliases/SignalBroadcastRequest.md)
- [SignalBroadcastResult](type-aliases/SignalBroadcastResult.md)
- [SignalKey](type-aliases/SignalKey.md)
- [SignalWaitStateDetails](type-aliases/SignalWaitStateDetails.md)
- [SortOrderEnum](type-aliases/SortOrderEnum.md)
- [SourceElementIdInstruction](type-aliases/SourceElementIdInstruction.md)
- [SourceElementInstanceKeyInstruction](type-aliases/SourceElementInstanceKeyInstruction.md)
- [SourceElementInstruction](type-aliases/SourceElementInstruction.md)
- [StartCursor](type-aliases/StartCursor.md)
- [StatusMetric](type-aliases/StatusMetric.md)
- [StringFilterProperty](type-aliases/StringFilterProperty.md)
- [SuspendBatchOperationData](type-aliases/SuspendBatchOperationData.md)
- [SuspendBatchOperationError](type-aliases/SuspendBatchOperationError.md)
- [SuspendBatchOperationErrors](type-aliases/SuspendBatchOperationErrors.md)
- [suspendBatchOperationInput](type-aliases/suspendBatchOperationInput.md)
- [SuspendBatchOperationResponse](type-aliases/SuspendBatchOperationResponse.md)
- [SuspendBatchOperationResponses](type-aliases/SuspendBatchOperationResponses.md)
- [SystemConfigurationResponse](type-aliases/SystemConfigurationResponse.md)
- [Tag](type-aliases/Tag.md)
- [TagSet](type-aliases/TagSet.md)
- [TenantClientResult](type-aliases/TenantClientResult.md)
- [TenantClientSearchQueryRequest](type-aliases/TenantClientSearchQueryRequest.md)
- [TenantClientSearchQuerySortRequest](type-aliases/TenantClientSearchQuerySortRequest.md)
- [TenantClientSearchResult](type-aliases/TenantClientSearchResult.md)
- [TenantCreateRequest](type-aliases/TenantCreateRequest.md)
- [TenantCreateResult](type-aliases/TenantCreateResult.md)
- [TenantFilter](type-aliases/TenantFilter.md)
- [TenantFilterEnum](type-aliases/TenantFilterEnum.md)
- [TenantGroupResult](type-aliases/TenantGroupResult.md)
- [TenantGroupSearchQueryRequest](type-aliases/TenantGroupSearchQueryRequest.md)
- [TenantGroupSearchQuerySortRequest](type-aliases/TenantGroupSearchQuerySortRequest.md)
- [TenantGroupSearchResult](type-aliases/TenantGroupSearchResult.md)
- [TenantId](type-aliases/TenantId.md)
- [TenantMappingRuleSearchResult](type-aliases/TenantMappingRuleSearchResult.md)
- [TenantResult](type-aliases/TenantResult.md)
- [TenantRoleSearchResult](type-aliases/TenantRoleSearchResult.md)
- [TenantSearchQueryRequest](type-aliases/TenantSearchQueryRequest.md)
- [TenantSearchQueryResult](type-aliases/TenantSearchQueryResult.md)
- [TenantSearchQuerySortRequest](type-aliases/TenantSearchQuerySortRequest.md)
- [TenantUpdateRequest](type-aliases/TenantUpdateRequest.md)
- [TenantUpdateResult](type-aliases/TenantUpdateResult.md)
- [TenantUserResult](type-aliases/TenantUserResult.md)
- [TenantUserSearchQueryRequest](type-aliases/TenantUserSearchQueryRequest.md)
- [TenantUserSearchQuerySortRequest](type-aliases/TenantUserSearchQuerySortRequest.md)
- [TenantUserSearchResult](type-aliases/TenantUserSearchResult.md)
- [ThreadedJob](type-aliases/ThreadedJob.md)
- [ThreadedJobHandler](type-aliases/ThreadedJobHandler.md)
- [ThrowJobErrorData](type-aliases/ThrowJobErrorData.md)
- [ThrowJobErrorError](type-aliases/ThrowJobErrorError.md)
- [ThrowJobErrorErrors](type-aliases/ThrowJobErrorErrors.md)
- [throwJobErrorInput](type-aliases/throwJobErrorInput.md)
- [ThrowJobErrorResponse](type-aliases/ThrowJobErrorResponse.md)
- [ThrowJobErrorResponses](type-aliases/ThrowJobErrorResponses.md)
- [TimerWaitStateDetails](type-aliases/TimerWaitStateDetails.md)
- [TopologyResponse](type-aliases/TopologyResponse.md)
- [UnassignClientFromGroupData](type-aliases/UnassignClientFromGroupData.md)
- [UnassignClientFromGroupError](type-aliases/UnassignClientFromGroupError.md)
- [UnassignClientFromGroupErrors](type-aliases/UnassignClientFromGroupErrors.md)
- [unassignClientFromGroupInput](type-aliases/unassignClientFromGroupInput.md)
- [UnassignClientFromGroupResponse](type-aliases/UnassignClientFromGroupResponse.md)
- [UnassignClientFromGroupResponses](type-aliases/UnassignClientFromGroupResponses.md)
- [UnassignClientFromTenantData](type-aliases/UnassignClientFromTenantData.md)
- [UnassignClientFromTenantError](type-aliases/UnassignClientFromTenantError.md)
- [UnassignClientFromTenantErrors](type-aliases/UnassignClientFromTenantErrors.md)
- [unassignClientFromTenantInput](type-aliases/unassignClientFromTenantInput.md)
- [UnassignClientFromTenantResponse](type-aliases/UnassignClientFromTenantResponse.md)
- [UnassignClientFromTenantResponses](type-aliases/UnassignClientFromTenantResponses.md)
- [UnassignGroupFromTenantData](type-aliases/UnassignGroupFromTenantData.md)
- [UnassignGroupFromTenantError](type-aliases/UnassignGroupFromTenantError.md)
- [UnassignGroupFromTenantErrors](type-aliases/UnassignGroupFromTenantErrors.md)
- [unassignGroupFromTenantInput](type-aliases/unassignGroupFromTenantInput.md)
- [UnassignGroupFromTenantResponse](type-aliases/UnassignGroupFromTenantResponse.md)
- [UnassignGroupFromTenantResponses](type-aliases/UnassignGroupFromTenantResponses.md)
- [UnassignMappingRuleFromGroupData](type-aliases/UnassignMappingRuleFromGroupData.md)
- [UnassignMappingRuleFromGroupError](type-aliases/UnassignMappingRuleFromGroupError.md)
- [UnassignMappingRuleFromGroupErrors](type-aliases/UnassignMappingRuleFromGroupErrors.md)
- [unassignMappingRuleFromGroupInput](type-aliases/unassignMappingRuleFromGroupInput.md)
- [UnassignMappingRuleFromGroupResponse](type-aliases/UnassignMappingRuleFromGroupResponse.md)
- [UnassignMappingRuleFromGroupResponses](type-aliases/UnassignMappingRuleFromGroupResponses.md)
- [UnassignMappingRuleFromTenantData](type-aliases/UnassignMappingRuleFromTenantData.md)
- [UnassignMappingRuleFromTenantError](type-aliases/UnassignMappingRuleFromTenantError.md)
- [UnassignMappingRuleFromTenantErrors](type-aliases/UnassignMappingRuleFromTenantErrors.md)
- [unassignMappingRuleFromTenantInput](type-aliases/unassignMappingRuleFromTenantInput.md)
- [UnassignMappingRuleFromTenantResponse](type-aliases/UnassignMappingRuleFromTenantResponse.md)
- [UnassignMappingRuleFromTenantResponses](type-aliases/UnassignMappingRuleFromTenantResponses.md)
- [UnassignRoleFromClientData](type-aliases/UnassignRoleFromClientData.md)
- [UnassignRoleFromClientError](type-aliases/UnassignRoleFromClientError.md)
- [UnassignRoleFromClientErrors](type-aliases/UnassignRoleFromClientErrors.md)
- [unassignRoleFromClientInput](type-aliases/unassignRoleFromClientInput.md)
- [UnassignRoleFromClientResponse](type-aliases/UnassignRoleFromClientResponse.md)
- [UnassignRoleFromClientResponses](type-aliases/UnassignRoleFromClientResponses.md)
- [UnassignRoleFromGroupData](type-aliases/UnassignRoleFromGroupData.md)
- [UnassignRoleFromGroupError](type-aliases/UnassignRoleFromGroupError.md)
- [UnassignRoleFromGroupErrors](type-aliases/UnassignRoleFromGroupErrors.md)
- [unassignRoleFromGroupInput](type-aliases/unassignRoleFromGroupInput.md)
- [UnassignRoleFromGroupResponse](type-aliases/UnassignRoleFromGroupResponse.md)
- [UnassignRoleFromGroupResponses](type-aliases/UnassignRoleFromGroupResponses.md)
- [UnassignRoleFromMappingRuleData](type-aliases/UnassignRoleFromMappingRuleData.md)
- [UnassignRoleFromMappingRuleError](type-aliases/UnassignRoleFromMappingRuleError.md)
- [UnassignRoleFromMappingRuleErrors](type-aliases/UnassignRoleFromMappingRuleErrors.md)
- [unassignRoleFromMappingRuleInput](type-aliases/unassignRoleFromMappingRuleInput.md)
- [UnassignRoleFromMappingRuleResponse](type-aliases/UnassignRoleFromMappingRuleResponse.md)
- [UnassignRoleFromMappingRuleResponses](type-aliases/UnassignRoleFromMappingRuleResponses.md)
- [UnassignRoleFromTenantData](type-aliases/UnassignRoleFromTenantData.md)
- [UnassignRoleFromTenantError](type-aliases/UnassignRoleFromTenantError.md)
- [UnassignRoleFromTenantErrors](type-aliases/UnassignRoleFromTenantErrors.md)
- [unassignRoleFromTenantInput](type-aliases/unassignRoleFromTenantInput.md)
- [UnassignRoleFromTenantResponse](type-aliases/UnassignRoleFromTenantResponse.md)
- [UnassignRoleFromTenantResponses](type-aliases/UnassignRoleFromTenantResponses.md)
- [UnassignRoleFromUserData](type-aliases/UnassignRoleFromUserData.md)
- [UnassignRoleFromUserError](type-aliases/UnassignRoleFromUserError.md)
- [UnassignRoleFromUserErrors](type-aliases/UnassignRoleFromUserErrors.md)
- [unassignRoleFromUserInput](type-aliases/unassignRoleFromUserInput.md)
- [UnassignRoleFromUserResponse](type-aliases/UnassignRoleFromUserResponse.md)
- [UnassignRoleFromUserResponses](type-aliases/UnassignRoleFromUserResponses.md)
- [UnassignUserFromGroupData](type-aliases/UnassignUserFromGroupData.md)
- [UnassignUserFromGroupError](type-aliases/UnassignUserFromGroupError.md)
- [UnassignUserFromGroupErrors](type-aliases/UnassignUserFromGroupErrors.md)
- [unassignUserFromGroupInput](type-aliases/unassignUserFromGroupInput.md)
- [UnassignUserFromGroupResponse](type-aliases/UnassignUserFromGroupResponse.md)
- [UnassignUserFromGroupResponses](type-aliases/UnassignUserFromGroupResponses.md)
- [UnassignUserFromTenantData](type-aliases/UnassignUserFromTenantData.md)
- [UnassignUserFromTenantError](type-aliases/UnassignUserFromTenantError.md)
- [UnassignUserFromTenantErrors](type-aliases/UnassignUserFromTenantErrors.md)
- [unassignUserFromTenantInput](type-aliases/unassignUserFromTenantInput.md)
- [UnassignUserFromTenantResponse](type-aliases/UnassignUserFromTenantResponse.md)
- [UnassignUserFromTenantResponses](type-aliases/UnassignUserFromTenantResponses.md)
- [UnassignUserTaskData](type-aliases/UnassignUserTaskData.md)
- [UnassignUserTaskError](type-aliases/UnassignUserTaskError.md)
- [UnassignUserTaskErrors](type-aliases/UnassignUserTaskErrors.md)
- [unassignUserTaskInput](type-aliases/unassignUserTaskInput.md)
- [UnassignUserTaskResponse](type-aliases/UnassignUserTaskResponse.md)
- [UnassignUserTaskResponses](type-aliases/UnassignUserTaskResponses.md)
- [UpdateAgentInstanceData](type-aliases/UpdateAgentInstanceData.md)
- [UpdateAgentInstanceError](type-aliases/UpdateAgentInstanceError.md)
- [UpdateAgentInstanceErrors](type-aliases/UpdateAgentInstanceErrors.md)
- [updateAgentInstanceInput](type-aliases/updateAgentInstanceInput.md)
- [UpdateAgentInstanceResponse](type-aliases/UpdateAgentInstanceResponse.md)
- [UpdateAgentInstanceResponses](type-aliases/UpdateAgentInstanceResponses.md)
- [UpdateAuthorizationData](type-aliases/UpdateAuthorizationData.md)
- [UpdateAuthorizationError](type-aliases/UpdateAuthorizationError.md)
- [UpdateAuthorizationErrors](type-aliases/UpdateAuthorizationErrors.md)
- [updateAuthorizationInput](type-aliases/updateAuthorizationInput.md)
- [UpdateAuthorizationResponse](type-aliases/UpdateAuthorizationResponse.md)
- [UpdateAuthorizationResponses](type-aliases/UpdateAuthorizationResponses.md)
- [UpdateClusterVariableRequest](type-aliases/UpdateClusterVariableRequest.md)
- [UpdateGlobalClusterVariableData](type-aliases/UpdateGlobalClusterVariableData.md)
- [UpdateGlobalClusterVariableError](type-aliases/UpdateGlobalClusterVariableError.md)
- [UpdateGlobalClusterVariableErrors](type-aliases/UpdateGlobalClusterVariableErrors.md)
- [updateGlobalClusterVariableInput](type-aliases/updateGlobalClusterVariableInput.md)
- [UpdateGlobalClusterVariableResponse](type-aliases/UpdateGlobalClusterVariableResponse.md)
- [UpdateGlobalClusterVariableResponses](type-aliases/UpdateGlobalClusterVariableResponses.md)
- [UpdateGlobalTaskListenerData](type-aliases/UpdateGlobalTaskListenerData.md)
- [UpdateGlobalTaskListenerError](type-aliases/UpdateGlobalTaskListenerError.md)
- [UpdateGlobalTaskListenerErrors](type-aliases/UpdateGlobalTaskListenerErrors.md)
- [updateGlobalTaskListenerInput](type-aliases/updateGlobalTaskListenerInput.md)
- [UpdateGlobalTaskListenerRequest](type-aliases/UpdateGlobalTaskListenerRequest.md)
- [UpdateGlobalTaskListenerResponse](type-aliases/UpdateGlobalTaskListenerResponse.md)
- [UpdateGlobalTaskListenerResponses](type-aliases/UpdateGlobalTaskListenerResponses.md)
- [UpdateGroupData](type-aliases/UpdateGroupData.md)
- [UpdateGroupError](type-aliases/UpdateGroupError.md)
- [UpdateGroupErrors](type-aliases/UpdateGroupErrors.md)
- [updateGroupInput](type-aliases/updateGroupInput.md)
- [UpdateGroupResponse](type-aliases/UpdateGroupResponse.md)
- [UpdateGroupResponses](type-aliases/UpdateGroupResponses.md)
- [UpdateJobData](type-aliases/UpdateJobData.md)
- [UpdateJobError](type-aliases/UpdateJobError.md)
- [UpdateJobErrors](type-aliases/UpdateJobErrors.md)
- [updateJobInput](type-aliases/updateJobInput.md)
- [UpdateJobResponse](type-aliases/UpdateJobResponse.md)
- [UpdateJobResponses](type-aliases/UpdateJobResponses.md)
- [UpdateJobsBatchOperationData](type-aliases/UpdateJobsBatchOperationData.md)
- [UpdateJobsBatchOperationError](type-aliases/UpdateJobsBatchOperationError.md)
- [UpdateJobsBatchOperationErrors](type-aliases/UpdateJobsBatchOperationErrors.md)
- [updateJobsBatchOperationInput](type-aliases/updateJobsBatchOperationInput.md)
- [UpdateJobsBatchOperationResponse](type-aliases/UpdateJobsBatchOperationResponse.md)
- [UpdateJobsBatchOperationResponses](type-aliases/UpdateJobsBatchOperationResponses.md)
- [UpdateMappingRuleData](type-aliases/UpdateMappingRuleData.md)
- [UpdateMappingRuleError](type-aliases/UpdateMappingRuleError.md)
- [UpdateMappingRuleErrors](type-aliases/UpdateMappingRuleErrors.md)
- [updateMappingRuleInput](type-aliases/updateMappingRuleInput.md)
- [UpdateMappingRuleResponse](type-aliases/UpdateMappingRuleResponse.md)
- [UpdateMappingRuleResponses](type-aliases/UpdateMappingRuleResponses.md)
- [UpdateRoleData](type-aliases/UpdateRoleData.md)
- [UpdateRoleError](type-aliases/UpdateRoleError.md)
- [UpdateRoleErrors](type-aliases/UpdateRoleErrors.md)
- [updateRoleInput](type-aliases/updateRoleInput.md)
- [UpdateRoleResponse](type-aliases/UpdateRoleResponse.md)
- [UpdateRoleResponses](type-aliases/UpdateRoleResponses.md)
- [UpdateTenantClusterVariableData](type-aliases/UpdateTenantClusterVariableData.md)
- [UpdateTenantClusterVariableError](type-aliases/UpdateTenantClusterVariableError.md)
- [UpdateTenantClusterVariableErrors](type-aliases/UpdateTenantClusterVariableErrors.md)
- [updateTenantClusterVariableInput](type-aliases/updateTenantClusterVariableInput.md)
- [UpdateTenantClusterVariableResponse](type-aliases/UpdateTenantClusterVariableResponse.md)
- [UpdateTenantClusterVariableResponses](type-aliases/UpdateTenantClusterVariableResponses.md)
- [UpdateTenantData](type-aliases/UpdateTenantData.md)
- [UpdateTenantError](type-aliases/UpdateTenantError.md)
- [UpdateTenantErrors](type-aliases/UpdateTenantErrors.md)
- [updateTenantInput](type-aliases/updateTenantInput.md)
- [UpdateTenantResponse](type-aliases/UpdateTenantResponse.md)
- [UpdateTenantResponses](type-aliases/UpdateTenantResponses.md)
- [UpdateUserData](type-aliases/UpdateUserData.md)
- [UpdateUserError](type-aliases/UpdateUserError.md)
- [UpdateUserErrors](type-aliases/UpdateUserErrors.md)
- [updateUserInput](type-aliases/updateUserInput.md)
- [UpdateUserResponse](type-aliases/UpdateUserResponse.md)
- [UpdateUserResponses](type-aliases/UpdateUserResponses.md)
- [UpdateUserTaskData](type-aliases/UpdateUserTaskData.md)
- [UpdateUserTaskError](type-aliases/UpdateUserTaskError.md)
- [UpdateUserTaskErrors](type-aliases/UpdateUserTaskErrors.md)
- [updateUserTaskInput](type-aliases/updateUserTaskInput.md)
- [UpdateUserTaskResponse](type-aliases/UpdateUserTaskResponse.md)
- [UpdateUserTaskResponses](type-aliases/UpdateUserTaskResponses.md)
- [UsageMetricsResponse](type-aliases/UsageMetricsResponse.md)
- [UsageMetricsResponseItem](type-aliases/UsageMetricsResponseItem.md)
- [UserCreateResult](type-aliases/UserCreateResult.md)
- [UserFilter](type-aliases/UserFilter.md)
- [Username](type-aliases/Username.md)
- [UserRequest](type-aliases/UserRequest.md)
- [UserResult](type-aliases/UserResult.md)
- [UserSearchQueryRequest](type-aliases/UserSearchQueryRequest.md)
- [UserSearchQuerySortRequest](type-aliases/UserSearchQuerySortRequest.md)
- [UserSearchResult](type-aliases/UserSearchResult.md)
- [UserTaskAssignmentRequest](type-aliases/UserTaskAssignmentRequest.md)
- [UserTaskAuditLogFilter](type-aliases/UserTaskAuditLogFilter.md)
- [UserTaskAuditLogSearchQueryRequest](type-aliases/UserTaskAuditLogSearchQueryRequest.md)
- [UserTaskCompletionRequest](type-aliases/UserTaskCompletionRequest.md)
- [UserTaskEffectiveVariableSearchQueryRequest](type-aliases/UserTaskEffectiveVariableSearchQueryRequest.md)
- [UserTaskFilter](type-aliases/UserTaskFilter.md)
- [UserTaskKey](type-aliases/UserTaskKey.md)
- [UserTaskProperties](type-aliases/UserTaskProperties.md)
- [UserTaskResult](type-aliases/UserTaskResult.md)
- [UserTaskSearchQuery](type-aliases/UserTaskSearchQuery.md)
- [UserTaskSearchQueryResult](type-aliases/UserTaskSearchQueryResult.md)
- [UserTaskSearchQuerySortRequest](type-aliases/UserTaskSearchQuerySortRequest.md)
- [UserTaskStateEnum](type-aliases/UserTaskStateEnum.md)
- [UserTaskStateExactMatch](type-aliases/UserTaskStateExactMatch.md)
- [UserTaskStateFilterProperty](type-aliases/UserTaskStateFilterProperty.md)
- [UserTaskUpdateRequest](type-aliases/UserTaskUpdateRequest.md)
- [UserTaskVariableFilter](type-aliases/UserTaskVariableFilter.md)
- [UserTaskVariableSearchQueryRequest](type-aliases/UserTaskVariableSearchQueryRequest.md)
- [UserTaskVariableSearchQuerySortRequest](type-aliases/UserTaskVariableSearchQuerySortRequest.md)
- [UserTaskWaitStateDetails](type-aliases/UserTaskWaitStateDetails.md)
- [UserUpdateRequest](type-aliases/UserUpdateRequest.md)
- [UserUpdateResult](type-aliases/UserUpdateResult.md)
- [UseSourceParentKeyInstruction](type-aliases/UseSourceParentKeyInstruction.md)
- [ValidationMode](type-aliases/ValidationMode.md)
- [VariableFilter](type-aliases/VariableFilter.md)
- [VariableKey](type-aliases/VariableKey.md)
- [VariableKeyExactMatch](type-aliases/VariableKeyExactMatch.md)
- [VariableKeyFilterProperty](type-aliases/VariableKeyFilterProperty.md)
- [VariableResult](type-aliases/VariableResult.md)
- [VariableResultBase](type-aliases/VariableResultBase.md)
- [VariableSearchQuery](type-aliases/VariableSearchQuery.md)
- [VariableSearchQueryResult](type-aliases/VariableSearchQueryResult.md)
- [VariableSearchQuerySortRequest](type-aliases/VariableSearchQuerySortRequest.md)
- [VariableSearchResult](type-aliases/VariableSearchResult.md)
- [VariableValueFilterProperty](type-aliases/VariableValueFilterProperty.md)
- [WaitStateDetails](type-aliases/WaitStateDetails.md)
- [WaitStateElementTypeEnum](type-aliases/WaitStateElementTypeEnum.md)
- [WaitStateElementTypeExactMatch](type-aliases/WaitStateElementTypeExactMatch.md)
- [WaitStateElementTypeFilterProperty](type-aliases/WaitStateElementTypeFilterProperty.md)
- [WaitStateTypeEnum](type-aliases/WaitStateTypeEnum.md)
- [WaitStateTypeExactMatch](type-aliases/WaitStateTypeExactMatch.md)
- [WaitStateTypeFilterProperty](type-aliases/WaitStateTypeFilterProperty.md)
- [WebappComponent](type-aliases/WebappComponent.md)

## Variables

- [AgentInstanceHistoryCommitStatusEnum](variables/AgentInstanceHistoryCommitStatusEnum.md)
- [AgentInstanceHistoryRoleEnum](variables/AgentInstanceHistoryRoleEnum.md)
- [AgentInstanceMessageContentTypeEnum](variables/AgentInstanceMessageContentTypeEnum.md)
- [AgentInstanceStatusEnum](variables/AgentInstanceStatusEnum.md)
- [AgentInstanceUpdateStatusEnum](variables/AgentInstanceUpdateStatusEnum.md)
- [AuditLogActorTypeEnum](variables/AuditLogActorTypeEnum.md)
- [AuditLogCategoryEnum](variables/AuditLogCategoryEnum.md)
- [AuditLogEntityTypeEnum](variables/AuditLogEntityTypeEnum.md)
- [AuditLogOperationTypeEnum](variables/AuditLogOperationTypeEnum.md)
- [AuditLogResultEnum](variables/AuditLogResultEnum.md)
- [BatchOperationItemStateEnum](variables/BatchOperationItemStateEnum.md)
- [BatchOperationStateEnum](variables/BatchOperationStateEnum.md)
- [BatchOperationTypeEnum](variables/BatchOperationTypeEnum.md)
- [ClusterVariableScopeEnum](variables/ClusterVariableScopeEnum.md)
- [DecisionDefinitionTypeEnum](variables/DecisionDefinitionTypeEnum.md)
- [DecisionInstanceStateEnum](variables/DecisionInstanceStateEnum.md)
- [ElementInstanceStateEnum](variables/ElementInstanceStateEnum.md)
- [GlobalListenerSourceEnum](variables/GlobalListenerSourceEnum.md)
- [GlobalTaskListenerEventTypeEnum](variables/GlobalTaskListenerEventTypeEnum.md)
- [IncidentErrorTypeEnum](variables/IncidentErrorTypeEnum.md)
- [IncidentStateEnum](variables/IncidentStateEnum.md)
- [JobKindEnum](variables/JobKindEnum.md)
- [JobListenerEventTypeEnum](variables/JobListenerEventTypeEnum.md)
- [JobStateEnum](variables/JobStateEnum.md)
- [MessageSubscriptionStateEnum](variables/MessageSubscriptionStateEnum.md)
- [MessageSubscriptionTypeEnum](variables/MessageSubscriptionTypeEnum.md)
- [OwnerTypeEnum](variables/OwnerTypeEnum.md)
- [PermissionTypeEnum](variables/PermissionTypeEnum.md)
- [ProcessInstanceStateEnum](variables/ProcessInstanceStateEnum.md)
- [ResourceTypeEnum](variables/ResourceTypeEnum.md)
- [SortOrderEnum](variables/SortOrderEnum.md)
- [SPEC\_HASH](variables/SPEC_HASH.md)
- [TenantFilterEnum](variables/TenantFilterEnum.md)
- [UserTaskStateEnum](variables/UserTaskStateEnum.md)
- [WaitStateElementTypeEnum](variables/WaitStateElementTypeEnum.md)
- [WaitStateTypeEnum](variables/WaitStateTypeEnum.md)

## Functions

- [assertConstraint](functions/assertConstraint.md)
- [collectTypedVariables](functions/collectTypedVariables.md)
- [createCamundaClient](functions/createCamundaClient.md)
- [createCamundaClientLoose](functions/createCamundaClientLoose.md)
- [createCamundaFpClient](functions/createCamundaFpClient.md)
- [createCamundaResultClient](functions/createCamundaResultClient.md)
- [isErr](functions/isErr.md)
- [isLeft](functions/isLeft.md)
- [isOk](functions/isOk.md)
- [isRight](functions/isRight.md)
- [isSdkError](functions/isSdkError.md)
- [variableNamesFromSchema](functions/variableNamesFromSchema.md)

## References

### default

Renames and re-exports [createCamundaClient](functions/createCamundaClient.md)

---

### JobActionReceiptSymbol

Renames and re-exports [JobActionReceipt](type-aliases/JobActionReceipt.md)

---

## Interface: CamundaConfig


## Properties

### \_\_raw

```ts
__raw: Record<string, string | undefined>;
```

---

### auth

```ts
auth: object;
```

#### basic?

```ts
optional basic?: object;
```

##### basic.password?

```ts
optional password?: string;
```

##### basic.username?

```ts
optional username?: string;
```

#### strategy

```ts
strategy: AuthStrategy;
```

---

### backpressure

```ts
backpressure: object;
```

#### decayQuietMs

```ts
decayQuietMs: number;
```

#### enabled

```ts
enabled: boolean;
```

#### floor

```ts
floor: number;
```

#### healthyRecoveryMultiplier

```ts
healthyRecoveryMultiplier: number;
```

#### initialMax

```ts
initialMax: number;
```

#### maxWaiters

```ts
maxWaiters: number;
```

#### observeOnly

```ts
observeOnly: boolean;
```

#### profile

```ts
profile: string;
```

#### recoveryIntervalMs

```ts
recoveryIntervalMs: number;
```

#### recoveryStep

```ts
recoveryStep: number;
```

#### severeFactor

```ts
severeFactor: number;
```

#### severeThreshold

```ts
severeThreshold: number;
```

#### softFactor

```ts
softFactor: number;
```

#### unlimitedAfterHealthyMs

```ts
unlimitedAfterHealthyMs: number;
```

---

### defaultTenantId

```ts
defaultTenantId: string;
```

---

### eventual?

```ts
optional eventual?: object;
```

#### pollDefaultMs

```ts
pollDefaultMs: number;
```

---

### httpRetry

```ts
httpRetry: object;
```

#### baseDelayMs

```ts
baseDelayMs: number;
```

#### maxAttempts

```ts
maxAttempts: number;
```

#### maxDelayMs

```ts
maxDelayMs: number;
```

---

### logLevel

```ts
logLevel: "trace" | "error" | "silent" | "warn" | "info" | "debug";
```

---

### mtls?

```ts
optional mtls?: object;
```

#### ca?

```ts
optional ca?: string;
```

#### caPath?

```ts
optional caPath?: string;
```

#### cert?

```ts
optional cert?: string;
```

#### certPath?

```ts
optional certPath?: string;
```

#### key?

```ts
optional key?: string;
```

#### keyPassphrase?

```ts
optional keyPassphrase?: string;
```

#### keyPath?

```ts
optional keyPath?: string;
```

---

### oauth

```ts
oauth: object;
```

#### cacheDir?

```ts
optional cacheDir?: string;
```

#### clientId?

```ts
optional clientId?: string;
```

#### clientSecret?

```ts
optional clientSecret?: string;
```

#### grantType

```ts
grantType: string;
```

#### oauthUrl

```ts
oauthUrl: string;
```

#### retry

```ts
retry: object;
```

##### retry.baseDelayMs

```ts
baseDelayMs: number;
```

##### retry.max

```ts
max: number;
```

#### scope?

```ts
optional scope?: string;
```

#### timeoutMs

```ts
timeoutMs: number;
```

---

### restAddress

```ts
restAddress: string;
```

---

### supportLog?

```ts
optional supportLog?: object;
```

#### enabled

```ts
enabled: boolean;
```

#### filePath

```ts
filePath: string;
```

---

### telemetry?

```ts
optional telemetry?: object;
```

#### correlation

```ts
correlation: boolean;
```

#### log

```ts
log: boolean;
```

---

### tokenAudience

```ts
tokenAudience: string;
```

---

### validation

```ts
validation: object;
```

#### raw

```ts
raw: string;
```

#### req

```ts
req: ValidationMode;
```

#### res

```ts
res: ValidationMode;
```

---

### workerDefaults?

```ts
optional workerDefaults?: object;
```

#### jobTimeoutMs?

```ts
optional jobTimeoutMs?: number;
```

#### maxParallelJobs?

```ts
optional maxParallelJobs?: number;
```

#### pollTimeoutMs?

```ts
optional pollTimeoutMs?: number;
```

#### startupJitterMaxSeconds?

```ts
optional startupJitterMaxSeconds?: number;
```

#### workerName?

```ts
optional workerName?: string;
```

---

## Interface: CamundaOptions


## Properties

### config?

```ts
optional config?: Partial<{
  CAMUNDA_AUTH_STRATEGY: "OAUTH" | "NONE" | "BASIC";
  CAMUNDA_BASIC_AUTH_PASSWORD: string;
  CAMUNDA_BASIC_AUTH_USERNAME: string;
  CAMUNDA_CLIENT_ID: string;
  CAMUNDA_CLIENT_SECRET: string;
  CAMUNDA_DEFAULT_TENANT_ID: string;
  CAMUNDA_MTLS_CA: string;
  CAMUNDA_MTLS_CA_PATH: string;
  CAMUNDA_MTLS_CERT: string;
  CAMUNDA_MTLS_CERT_PATH: string;
  CAMUNDA_MTLS_KEY: string;
  CAMUNDA_MTLS_KEY_PASSPHRASE: string;
  CAMUNDA_MTLS_KEY_PATH: string;
  CAMUNDA_OAUTH_CACHE_DIR: string;
  CAMUNDA_OAUTH_GRANT_TYPE: string;
  CAMUNDA_OAUTH_RETRY_BASE_DELAY_MS: number;
  CAMUNDA_OAUTH_RETRY_MAX: number;
  CAMUNDA_OAUTH_SCOPE: string;
  CAMUNDA_OAUTH_TIMEOUT_MS: number;
  CAMUNDA_OAUTH_URL: string;
  CAMUNDA_REST_ADDRESS: string;
  CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS: number;
  CAMUNDA_SDK_BACKPRESSURE_FLOOR: number;
  CAMUNDA_SDK_BACKPRESSURE_HEALTHY_RECOVERY_MULTIPLIER: number;
  CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX: number;
  CAMUNDA_SDK_BACKPRESSURE_MAX_WAITERS: number;
  CAMUNDA_SDK_BACKPRESSURE_PROFILE: "BALANCED" | "CONSERVATIVE" | "AGGRESSIVE" | "LEGACY";
  CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS: number;
  CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP: number;
  CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR: number;
  CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD: number;
  CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR: number;
  CAMUNDA_SDK_BACKPRESSURE_UNLIMITED_AFTER_HEALTHY_MS: number;
  CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS: number;
  CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS: number;
  CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS: number;
  CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS: number;
  CAMUNDA_SDK_LOG_LEVEL: "trace" | "error" | "silent" | "warn" | "info" | "debug" | "silly";
  CAMUNDA_SDK_TELEMETRY_CORRELATION: boolean;
  CAMUNDA_SDK_TELEMETRY_LOG: boolean;
  CAMUNDA_SDK_VALIDATION: string;
  CAMUNDA_SUPPORT_LOG_ENABLED: boolean;
  CAMUNDA_SUPPORT_LOG_FILE_PATH: string;
  CAMUNDA_SUPPORT_LOGGER: boolean;
  CAMUNDA_TOKEN_AUDIENCE: string;
  CAMUNDA_WORKER_MAX_CONCURRENT_JOBS: number;
  CAMUNDA_WORKER_NAME: string;
  CAMUNDA_WORKER_REQUEST_TIMEOUT: number;
  CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS: number;
  CAMUNDA_WORKER_TIMEOUT: number;
}>;
```

---

### env?

```ts
optional env?: Record<string, string | undefined>;
```

---

### fetch?

```ts
optional fetch?: (input, init?) => Promise<Response>;
```

#### Parameters

##### input

`RequestInfo` \| `URL`

##### init?

`RequestInit`

#### Returns

`Promise`\<`Response`\>

---

### log?

```ts
optional log?: object;
```

#### level?

```ts
optional level?: LogLevel;
```

#### transport?

```ts
optional transport?: LogTransport;
```

---

### supportLogger?

```ts
optional supportLogger?: SupportLogger;
```

---

### telemetry?

```ts
optional telemetry?: object;
```

#### correlation?

```ts
optional correlation?: boolean;
```

#### hooks?

```ts
optional hooks?: TelemetryHooks;
```

#### mirrorToLog?

```ts
optional mirrorToLog?: boolean;
```

---

### throwOnError?

```ts
optional throwOnError?: boolean;
```

---

## Interface: CancelablePromise<T>

# Interface: CancelablePromise\<T\>

## Extends

- `Promise`\<`T`\>

## Type Parameters

### T

`T`

## Methods

### cancel()

```ts
cancel(): void;
```

#### Returns

`void`

---

## Interface: CreateLoggerOptions


## Properties

### level?

```ts
optional level?: LogLevel;
```

---

### scope?

```ts
optional scope?: string;
```

---

### transport?

```ts
optional transport?: LogTransport;
```

---

## Interface: EnrichedActivatedJob


Enriched job type with convenience methods.

## Extends

- `ActivatedJobResult`

## Properties

### acknowledged?

```ts
optional acknowledged?: boolean;
```

Set true once any acknowledgement method is invoked.

---

### businessId

```ts
businessId: BusinessId | null;
```

The business ID of the owning process instance, inherited when the job was created.
This is `null` for jobs created before version 8.10 and for jobs whose owning process
instance has no business ID.

#### Inherited from

```ts
ActivatedJobResult.businessId;
```

---

### customHeaders

```ts
customHeaders: object;
```

A set of custom headers defined during modelling; returned as a serialized JSON document.

#### Index Signature

```ts
[key: string]: unknown
```

#### Inherited from

```ts
ActivatedJobResult.customHeaders;
```

---

### deadline

```ts
deadline: number;
```

When the job can be activated again, sent as a UNIX epoch timestamp.

#### Inherited from

```ts
ActivatedJobResult.deadline;
```

---

### elementId

```ts
elementId: ElementId;
```

The associated task element ID.

#### Inherited from

```ts
ActivatedJobResult.elementId;
```

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The element instance key of the task.

#### Inherited from

```ts
ActivatedJobResult.elementInstanceKey;
```

---

### jobKey

```ts
jobKey: JobKey;
```

The key, a unique identifier for the job.

#### Inherited from

```ts
ActivatedJobResult.jobKey;
```

---

### kind

```ts
kind: JobKindEnum;
```

#### Inherited from

```ts
ActivatedJobResult.kind;
```

---

### listenerEventType

```ts
listenerEventType: JobListenerEventTypeEnum;
```

#### Inherited from

```ts
ActivatedJobResult.listenerEventType;
```

---

### log

```ts
log: Logger;
```

---

### modifyJobTimeout

```ts
modifyJobTimeout: (__namedParameters) => Promise<void>;
```

Extend the timeout for the job by setting a new timeout

#### Parameters

##### \_\_namedParameters

###### newTimeoutMs

`number`

#### Returns

`Promise`\<`void`\>

---

### modifyRetries

```ts
modifyRetries: (__namedParameters) => Promise<void>;
```

#### Parameters

##### \_\_namedParameters

###### retries

`number`

#### Returns

`Promise`\<`void`\>

---

### priority

```ts
priority: number;
```

The priority of the job. Higher values indicate higher priority. Jobs created before 8.10 have no stored priority; the API returns 0 for such jobs.

#### Inherited from

```ts
ActivatedJobResult.priority;
```

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The bpmn process ID of the job's process definition.

#### Inherited from

```ts
ActivatedJobResult.processDefinitionId;
```

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the job's process definition.

#### Inherited from

```ts
ActivatedJobResult.processDefinitionKey;
```

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version of the job's process definition.

#### Inherited from

```ts
ActivatedJobResult.processDefinitionVersion;
```

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The job's process instance key.

#### Inherited from

```ts
ActivatedJobResult.processInstanceKey;
```

---

### retries

```ts
retries: number;
```

The amount of retries left to this job (should always be positive).

#### Inherited from

```ts
ActivatedJobResult.retries;
```

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

#### Inherited from

```ts
ActivatedJobResult.rootProcessInstanceKey;
```

---

### tags

```ts
tags: TagSet;
```

#### Inherited from

```ts
ActivatedJobResult.tags;
```

---

### tenantId

```ts
tenantId: TenantId;
```

The ID of the tenant that owns the job.

#### Inherited from

```ts
ActivatedJobResult.tenantId;
```

---

### type

```ts
type: string;
```

The type of the job (should match what was requested).

#### Inherited from

```ts
ActivatedJobResult.type;
```

---

### userTask

```ts
userTask: UserTaskProperties | null;
```

User task properties, if the job is a user task.
This is `null` if the job is not a user task.

#### Inherited from

```ts
ActivatedJobResult.userTask;
```

---

### variables

```ts
variables: object;
```

All variables visible to the task scope, computed at activation time.

#### Index Signature

```ts
[key: string]: unknown
```

#### Inherited from

```ts
ActivatedJobResult.variables;
```

---

### worker

```ts
worker: string;
```

The name of the worker which activated this job.

#### Inherited from

```ts
ActivatedJobResult.worker;
```

## Methods

### cancelWorkflow()

```ts
cancelWorkflow(): Promise<"JOB_ACTION_RECEIPT">;
```

#### Returns

`Promise`\<`"JOB_ACTION_RECEIPT"`\>

---

### complete()

```ts
complete(variables?, result?): Promise<"JOB_ACTION_RECEIPT">;
```

#### Parameters

##### variables?

##### result?

[`JobResult`](../type-aliases/JobResult.md)

#### Returns

`Promise`\<`"JOB_ACTION_RECEIPT"`\>

---

### error()

```ts
error(error): Promise<"JOB_ACTION_RECEIPT">;
```

#### Parameters

##### error

[`JobErrorRequest`](../type-aliases/JobErrorRequest.md)

#### Returns

`Promise`\<`"JOB_ACTION_RECEIPT"`\>

---

### fail()

```ts
fail(body): Promise<"JOB_ACTION_RECEIPT">;
```

#### Parameters

##### body

`any`

#### Returns

`Promise`\<`"JOB_ACTION_RECEIPT"`\>

---

### ignore()

```ts
ignore(): Promise<"JOB_ACTION_RECEIPT">;
```

#### Returns

`Promise`\<`"JOB_ACTION_RECEIPT"`\>

---

## Interface: ExtendedDeploymentResult


Extended deployment result with typed buckets for direct access to deployed artifacts.

## Extends

- `_DataOf`\<_typeof_ `Sdk.createDeployment`\>

## Properties

### decisionRequirements

```ts
decisionRequirements: DeploymentDecisionRequirementsResult[];
```

---

### decisions

```ts
decisions: DeploymentDecisionResult[];
```

---

### deploymentKey

```ts
deploymentKey: DeploymentKey;
```

The unique key identifying the deployment.

#### Inherited from

```ts
_DataOf.deploymentKey;
```

---

### deployments

```ts
deployments: DeploymentMetadataResult[];
```

Items deployed by the request.

#### Inherited from

```ts
_DataOf.deployments;
```

---

### forms

```ts
forms: DeploymentFormResult[];
```

---

### processes

```ts
processes: DeploymentProcessResult[];
```

---

### resources

```ts
resources: DeploymentResourceResult[];
```

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID associated with the deployment.

#### Inherited from

```ts
_DataOf.tenantId;
```

---

## Interface: HttpRetryPolicy


## Properties

### baseDelayMs

```ts
baseDelayMs: number;
```

---

### maxAttempts

```ts
maxAttempts: number;
```

---

### maxDelayMs

```ts
maxDelayMs: number;
```

---

## Interface: JobWorker


## Accessors

### activeJobs

#### Get Signature

```ts
get activeJobs(): number;
```

##### Returns

`number`

---

### name

#### Get Signature

```ts
get name(): string;
```

##### Returns

`string`

---

### stopped

#### Get Signature

```ts
get stopped(): boolean;
```

##### Returns

`boolean`

## Methods

### start()

```ts
start(): void;
```

#### Returns

`void`

---

### stop()

```ts
stop(): void;
```

#### Returns

`void`

---

### stopGracefully()

```ts
stopGracefully(opts?): Promise<{
  remainingJobs: number;
  timedOut: boolean;
}>;
```

Gracefully stop the worker: prevent new polls, allow any in-flight activation to finish
without cancellation, and wait for currently active jobs to drain (be acknowledged) up to waitUpToMs.
If timeout is reached, falls back to hard stop logic (cancels activation if still pending).

#### Parameters

##### opts?

###### checkIntervalMs?

`number`

###### waitUpToMs?

`number`

#### Returns

`Promise`\<\{
`remainingJobs`: `number`;
`timedOut`: `boolean`;
\}\>

---

## Interface: JobWorkerConfig<In, Out, Headers>

# Interface: JobWorkerConfig\<In, Out, Headers\>

## Type Parameters

### In

`In` _extends_ `z.ZodTypeAny` = `any`

### Out

`Out` _extends_ `z.ZodTypeAny` = `any`

### Headers

`Headers` _extends_ `z.ZodTypeAny` = `any`

## Properties

### autoStart?

```ts
optional autoStart?: boolean;
```

Immediately start polling for work - default `true`

---

### customHeadersSchema?

```ts
optional customHeadersSchema?: Headers;
```

Zod schema for custom headers in the activated job

---

### fetchVariables?

```ts
optional fetchVariables?: In extends ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> ? Extract<keyof output<In>, string>[] : string[];
```

Optional list of variable names to fetch during activation

---

### inputSchema?

```ts
optional inputSchema?: In;
```

Zod schema for variables in the activated job

---

### jobHandler

```ts
jobHandler: (job) => "JOB_ACTION_RECEIPT" | Promise<"JOB_ACTION_RECEIPT">;
```

#### Parameters

##### job

[`Job`](../type-aliases/Job.md)\<`In`, `Headers`\>

#### Returns

`"JOB_ACTION_RECEIPT"` \| `Promise`\<`"JOB_ACTION_RECEIPT"`\>

---

### jobTimeoutMs?

```ts
optional jobTimeoutMs?: number;
```

Job activation timeout in ms — default `60000`. Overridden by CAMUNDA_WORKER_TIMEOUT env var.

---

### jobType

```ts
jobType: string;
```

Zeebe job type

---

### ~~maxBackoffTimeMs?~~

```ts
optional maxBackoffTimeMs?: number;
```

#### Deprecated

Not used; pacing handled by long polling + client backpressure. Present only for migration compatibility.

---

### maxParallelJobs?

```ts
optional maxParallelJobs?: number;
```

Concurrency limit — default `10`. Overridden by CAMUNDA_WORKER_MAX_CONCURRENT_JOBS env var.

---

### outputSchema?

```ts
optional outputSchema?: Out;
```

Zod schema for variables in the complete command

---

### pollIntervalMs?

```ts
optional pollIntervalMs?: number;
```

Backoff between polls - default 1ms

---

### pollTimeoutMs?

```ts
optional pollTimeoutMs?: number;
```

The request will be completed when at least one job is activated or after the requestTimeout.
If the requestTimeout = 0, the request will be completed after a default configured timeout in the broker.
To immediately complete the request when no job is activated set the requestTimeout to a negative value

---

### startupJitterMaxSeconds?

```ts
optional startupJitterMaxSeconds?: number;
```

Maximum random delay (in seconds) before the worker starts polling.
When multiple application instances restart simultaneously, this spreads out
initial activation requests to avoid saturating the server.
`0` (the default) means no delay.

---

### validateSchemas?

```ts
optional validateSchemas?: boolean;
```

Validate any provided input, output, customheader schema
default: false

---

### workerName?

```ts
optional workerName?: string;
```

Optional explicit name

---

## Interface: OperationOptions


Per-call options for individual SDK method invocations.

## Properties

### retry?

```ts
optional retry?: false | Partial<HttpRetryPolicy>;
```

Override retry behaviour for this call.

- Pass `false` to disable retry entirely (single attempt).
- Pass a partial policy to override specific fields (merged with global config).

---

## Interface: SupportLogger


## Methods

### log()

```ts
log(message, addTimestamp?): void;
```

#### Parameters

##### message

`string` \| `number` \| `boolean` \| `object`

##### addTimestamp?

`boolean`

#### Returns

`void`

---

## Interface: TelemetryHooks


## Methods

### afterResponse()?

```ts
optional afterResponse(e): void;
```

#### Parameters

##### e

`TelemetryHttpEndEvent`

#### Returns

`void`

---

### authError()?

```ts
optional authError(e): void;
```

#### Parameters

##### e

`TelemetryAuthErrorEvent`

#### Returns

`void`

---

### authStart()?

```ts
optional authStart(e): void;
```

#### Parameters

##### e

`TelemetryAuthStartEvent`

#### Returns

`void`

---

### authSuccess()?

```ts
optional authSuccess(e): void;
```

#### Parameters

##### e

`TelemetryAuthSuccessEvent`

#### Returns

`void`

---

### beforeRequest()?

```ts
optional beforeRequest(e): void;
```

#### Parameters

##### e

`TelemetryHttpStartEvent`

#### Returns

`void`

---

### requestError()?

```ts
optional requestError(e): void;
```

#### Parameters

##### e

`TelemetryHttpErrorEvent`

#### Returns

`void`

---

### retry()?

```ts
optional retry(e): void;
```

#### Parameters

##### e

`TelemetryRetryEvent`

#### Returns

`void`

---

## Interface: ThreadPool


## Accessors

### busyCount

#### Get Signature

```ts
get busyCount(): number;
```

Number of threads currently processing a job.

##### Returns

`number`

---

### idleCount

#### Get Signature

```ts
get idleCount(): number;
```

Number of threads that are ready and idle.

##### Returns

`number`

---

### onThreadReady

#### Set Signature

```ts
set onThreadReady(cb): void;
```

Register a callback invoked whenever a thread becomes ready or idle.

##### Parameters

###### cb

(() => `void`) \| `undefined`

##### Returns

`void`

---

### ready

#### Get Signature

```ts
get ready(): Promise<void>;
```

Resolves when all threads have been spawned and signalled ready.

##### Returns

`Promise`\<`void`\>

---

### size

#### Get Signature

```ts
get size(): number;
```

Total number of threads in the pool.

##### Returns

`number`

## Methods

### dispatch()

```ts
dispatch(
   pw,
   jobData,
   handlerModule,
callbacks): Promise<void>;
```

Dispatch a serialized job to a specific idle worker.
The caller is responsible for checking idleness first.

#### Parameters

##### pw

`PoolWorker`

##### jobData

`Record`\<`string`, `unknown`\>

##### handlerModule

`string`

##### callbacks

###### onComplete

(`completionAction?`) => `void`

###### onError

(`err`) => `void`

#### Returns

`Promise`\<`void`\>

---

### getIdleWorker()

```ts
getIdleWorker(): PoolWorker | undefined;
```

Find the first ready & idle thread.

#### Returns

`PoolWorker` \| `undefined`

---

### terminate()

```ts
terminate(): void;
```

Terminate all threads and reject any in-flight tasks.

#### Returns

`void`

---

## Interface: ThreadedJobWorker


A job worker that runs handler logic in a shared pool of worker_threads,
keeping the main Node.js event loop free for polling and I/O.

The thread pool is owned by CamundaClient and shared across all threaded workers.
Each thread is generic — the handler module path is sent with each job,
and threads cache loaded handlers by module path.

## Accessors

### activeJobs

#### Get Signature

```ts
get activeJobs(): number;
```

##### Returns

`number`

---

### busyThreads

#### Get Signature

```ts
get busyThreads(): number;
```

Number of threads currently processing a job (across all workers).

##### Returns

`number`

---

### name

#### Get Signature

```ts
get name(): string;
```

##### Returns

`string`

---

### poolSize

#### Get Signature

```ts
get poolSize(): number;
```

Number of threads in the shared pool.

##### Returns

`number`

---

### ready

#### Get Signature

```ts
get ready(): Promise<void>;
```

Resolves when the shared thread pool has finished initialising.

##### Returns

`Promise`\<`void`\>

---

### stopped

#### Get Signature

```ts
get stopped(): boolean;
```

##### Returns

`boolean`

## Methods

### start()

```ts
start(): void;
```

#### Returns

`void`

---

### stop()

```ts
stop(): void;
```

#### Returns

`void`

---

### stopGracefully()

```ts
stopGracefully(opts?): Promise<{
  remainingJobs: number;
  timedOut: boolean;
}>;
```

#### Parameters

##### opts?

###### checkIntervalMs?

`number`

###### waitUpToMs?

`number`

#### Returns

`Promise`\<\{
`remainingJobs`: `number`;
`timedOut`: `boolean`;
\}\>

---

## Interface: ThreadedJobWorkerConfig<In, Out, Headers>

# Interface: ThreadedJobWorkerConfig\<In, Out, Headers\>

Configuration for a threaded job worker.
Same as JobWorkerConfig but replaces `jobHandler` with `handlerModule`.

## Type Parameters

### In

`In` _extends_ `z.ZodTypeAny` = `any`

### Out

`Out` _extends_ `z.ZodTypeAny` = `any`

### Headers

`Headers` _extends_ `z.ZodTypeAny` = `any`

## Properties

### autoStart?

```ts
optional autoStart?: boolean;
```

Immediately start polling for work - default `true`

---

### customHeadersSchema?

```ts
optional customHeadersSchema?: Headers;
```

Zod schema for custom headers in the activated job

---

### fetchVariables?

```ts
optional fetchVariables?: In extends ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> ? Extract<keyof output<In>, string>[] : string[];
```

Optional list of variable names to fetch during activation

---

### handlerModule

```ts
handlerModule: string;
```

Absolute or relative path to a JS/TS module that exports a default handler function.
The function signature must be: `(job, client) => Promise<JobActionReceipt>`

---

### inputSchema?

```ts
optional inputSchema?: In;
```

Zod schema for variables in the activated job

---

### jobTimeoutMs?

```ts
optional jobTimeoutMs?: number;
```

Job activation timeout in ms — default `60000`. Overridden by CAMUNDA_WORKER_TIMEOUT env var.

---

### jobType

```ts
jobType: string;
```

Zeebe job type

---

### maxParallelJobs?

```ts
optional maxParallelJobs?: number;
```

Concurrency limit — default `10`. Overridden by CAMUNDA_WORKER_MAX_CONCURRENT_JOBS env var.

---

### outputSchema?

```ts
optional outputSchema?: Out;
```

Zod schema for variables in the complete command

---

### pollIntervalMs?

```ts
optional pollIntervalMs?: number;
```

Backoff between polls - default 1ms

---

### pollTimeoutMs?

```ts
optional pollTimeoutMs?: number;
```

The request will be completed when at least one job is activated or after the requestTimeout.
If the requestTimeout = 0, the request will be completed after a default configured timeout in the broker.
To immediately complete the request when no job is activated set the requestTimeout to a negative value

---

### startupJitterMaxSeconds?

```ts
optional startupJitterMaxSeconds?: number;
```

Maximum random delay (in seconds) before the worker starts polling.
When multiple application instances restart simultaneously, this spreads out
initial activation requests to avoid saturating the server.
`0` (the default) means no delay.

---

### threadPoolSize?

```ts
optional threadPoolSize?: number;
```

Number of threads in the shared pool (used only when the pool is first created;
subsequent workers share the existing pool).
Default: number of CPU cores available to the process.

---

### validateSchemas?

```ts
optional validateSchemas?: boolean;
```

Validate any provided input, output, customheader schema
default: false

---

### workerName?

```ts
optional workerName?: string;
```

Optional explicit name

---

## Interface: TypedVariableItem


A single variable item from a search page (the subset the collector needs).

## Properties

### name

```ts
name: string;
```

---

### scopeKey

```ts
scopeKey: string;
```

The scope key the variable is directly defined in.

---

### value

```ts
value: string;
```

The variable value, serialized as JSON (the wire representation).

---

## Interface: TypedVariablePage


One page of variable search results.

## Properties

### endCursor

```ts
endCursor: string | null;
```

Cursor for the next page, or `null` when there are no more pages.

---

### items

```ts
items: readonly TypedVariableItem[];
```

---

## Function: assumeExists()


```ts
function assumeExists(value): AgentHistoryItemKey;
```

## Parameters

### value

`string`

## Returns

[`AgentHistoryItemKey`](../../../type-aliases/AgentHistoryItemKey.md)

---

## Function: getValue()


```ts
function getValue(key): string;
```

## Parameters

### key

[`AgentHistoryItemKey`](../../../type-aliases/AgentHistoryItemKey.md)

## Returns

`string`

---

## Function: isValid()


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## AgentHistoryItemKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(Functions)


```ts
function assumeExists(value): AgentInstanceKey;
```

## Parameters

### value

`string`

## Returns

[`AgentInstanceKey`](../../../type-aliases/AgentInstanceKey.md)

---

## Function: getValue()(Functions)


```ts
function getValue(key): string;
```

## Parameters

### key

[`AgentInstanceKey`](../../../type-aliases/AgentInstanceKey.md)

## Returns

`string`

---

## Function: isValid()(Functions)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## AgentInstanceKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(3)


```ts
function assumeExists(value): AuditLogEntityKey;
```

## Parameters

### value

`string`

## Returns

[`AuditLogEntityKey`](../../../type-aliases/AuditLogEntityKey.md)

---

## Function: getValue()(3)


```ts
function getValue(key): string;
```

## Parameters

### key

[`AuditLogEntityKey`](../../../type-aliases/AuditLogEntityKey.md)

## Returns

`string`

---

## Function: isValid()(3)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## AuditLogEntityKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(4)


```ts
function assumeExists(value): AuditLogKey;
```

## Parameters

### value

`string`

## Returns

[`AuditLogKey`](../../../type-aliases/AuditLogKey.md)

---

## Function: getValue()(4)


```ts
function getValue(key): string;
```

## Parameters

### key

[`AuditLogKey`](../../../type-aliases/AuditLogKey.md)

## Returns

`string`

---

## Function: isValid()(4)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## AuditLogKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(5)


```ts
function assumeExists(value): AuthorizationKey;
```

## Parameters

### value

`string`

## Returns

[`AuthorizationKey`](../../../type-aliases/AuthorizationKey.md)

---

## Function: getValue()(5)


```ts
function getValue(key): string;
```

## Parameters

### key

[`AuthorizationKey`](../../../type-aliases/AuthorizationKey.md)

## Returns

`string`

---

## Function: isValid()(5)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## AuthorizationKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(6)


```ts
function assumeExists(value): BatchOperationKey;
```

## Parameters

### value

`string`

## Returns

[`BatchOperationKey`](../../../type-aliases/BatchOperationKey.md)

---

## Function: getValue()(6)


```ts
function getValue(key): string;
```

## Parameters

### key

[`BatchOperationKey`](../../../type-aliases/BatchOperationKey.md)

## Returns

`string`

---

## Function: isValid()(6)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## BatchOperationKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(7)


```ts
function assumeExists(value): BusinessId;
```

## Parameters

### value

`string`

## Returns

[`BusinessId`](../../../type-aliases/BusinessId.md)

---

## Function: getValue()(7)


```ts
function getValue(key): string;
```

## Parameters

### key

[`BusinessId`](../../../type-aliases/BusinessId.md)

## Returns

`string`

---

## Function: isValid()(7)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## BusinessId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(8)


```ts
function assumeExists(value): ClientId;
```

## Parameters

### value

`string`

## Returns

[`ClientId`](../../../type-aliases/ClientId.md)

---

## Function: getValue()(8)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ClientId`](../../../type-aliases/ClientId.md)

## Returns

`string`

---

## Function: isValid()(8)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ClientId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(9)


```ts
function assumeExists(value): ClusterVariableName;
```

## Parameters

### value

`string`

## Returns

[`ClusterVariableName`](../../../type-aliases/ClusterVariableName.md)

---

## Function: getValue()(9)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ClusterVariableName`](../../../type-aliases/ClusterVariableName.md)

## Returns

`string`

---

## Function: isValid()(9)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ClusterVariableName


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(10)


```ts
function assumeExists(value): ConditionalEvaluationKey;
```

## Parameters

### value

`string`

## Returns

[`ConditionalEvaluationKey`](../../../type-aliases/ConditionalEvaluationKey.md)

---

## Function: getValue()(10)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ConditionalEvaluationKey`](../../../type-aliases/ConditionalEvaluationKey.md)

## Returns

`string`

---

## Function: isValid()(10)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ConditionalEvaluationKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(11)


```ts
function assumeExists(value): DecisionDefinitionId;
```

## Parameters

### value

`string`

## Returns

[`DecisionDefinitionId`](../../../type-aliases/DecisionDefinitionId.md)

---

## Function: getValue()(11)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DecisionDefinitionId`](../../../type-aliases/DecisionDefinitionId.md)

## Returns

`string`

---

## Function: isValid()(11)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DecisionDefinitionId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(12)


```ts
function assumeExists(value): DecisionDefinitionKey;
```

## Parameters

### value

`string`

## Returns

[`DecisionDefinitionKey`](../../../type-aliases/DecisionDefinitionKey.md)

---

## Function: getValue()(12)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DecisionDefinitionKey`](../../../type-aliases/DecisionDefinitionKey.md)

## Returns

`string`

---

## Function: isValid()(12)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DecisionDefinitionKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(13)


```ts
function assumeExists(value): DecisionEvaluationInstanceKey;
```

## Parameters

### value

`string`

## Returns

[`DecisionEvaluationInstanceKey`](../../../type-aliases/DecisionEvaluationInstanceKey.md)

---

## Function: getValue()(13)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DecisionEvaluationInstanceKey`](../../../type-aliases/DecisionEvaluationInstanceKey.md)

## Returns

`string`

---

## Function: isValid()(13)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DecisionEvaluationInstanceKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(14)


```ts
function assumeExists(value): DecisionEvaluationKey;
```

## Parameters

### value

`string`

## Returns

[`DecisionEvaluationKey`](../../../type-aliases/DecisionEvaluationKey.md)

---

## Function: getValue()(14)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DecisionEvaluationKey`](../../../type-aliases/DecisionEvaluationKey.md)

## Returns

`string`

---

## Function: isValid()(14)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DecisionEvaluationKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(15)


```ts
function assumeExists(value): DecisionInstanceKey;
```

## Parameters

### value

`string`

## Returns

[`DecisionInstanceKey`](../../../type-aliases/DecisionInstanceKey.md)

---

## Function: getValue()(15)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DecisionInstanceKey`](../../../type-aliases/DecisionInstanceKey.md)

## Returns

`string`

---

## Function: isValid()(15)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DecisionInstanceKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(16)


```ts
function assumeExists(value): DecisionRequirementsKey;
```

## Parameters

### value

`string`

## Returns

[`DecisionRequirementsKey`](../../../type-aliases/DecisionRequirementsKey.md)

---

## Function: getValue()(16)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DecisionRequirementsKey`](../../../type-aliases/DecisionRequirementsKey.md)

## Returns

`string`

---

## Function: isValid()(16)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DecisionRequirementsKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(17)


```ts
function assumeExists(value): DeploymentKey;
```

## Parameters

### value

`string`

## Returns

[`DeploymentKey`](../../../type-aliases/DeploymentKey.md)

---

## Function: getValue()(17)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DeploymentKey`](../../../type-aliases/DeploymentKey.md)

## Returns

`string`

---

## Function: isValid()(17)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DeploymentKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(18)


```ts
function assumeExists(value): DocumentId;
```

## Parameters

### value

`string`

## Returns

[`DocumentId`](../../../type-aliases/DocumentId.md)

---

## Function: getValue()(18)


```ts
function getValue(key): string;
```

## Parameters

### key

[`DocumentId`](../../../type-aliases/DocumentId.md)

## Returns

`string`

---

## Function: isValid()(18)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## DocumentId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(19)


```ts
function assumeExists(value): ElementId;
```

## Parameters

### value

`string`

## Returns

[`ElementId`](../../../type-aliases/ElementId.md)

---

## Function: getValue()(19)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ElementId`](../../../type-aliases/ElementId.md)

## Returns

`string`

---

## Function: isValid()(19)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ElementId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(20)


```ts
function assumeExists(value): ElementInstanceKey;
```

## Parameters

### value

`string`

## Returns

[`ElementInstanceKey`](../../../type-aliases/ElementInstanceKey.md)

---

## Function: getValue()(20)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ElementInstanceKey`](../../../type-aliases/ElementInstanceKey.md)

## Returns

`string`

---

## Function: isValid()(20)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ElementInstanceKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(21)


```ts
function assumeExists(value): EndCursor;
```

## Parameters

### value

`string`

## Returns

[`EndCursor`](../../../type-aliases/EndCursor.md)

---

## Function: getValue()(21)


```ts
function getValue(key): string;
```

## Parameters

### key

[`EndCursor`](../../../type-aliases/EndCursor.md)

## Returns

`string`

---

## Function: isValid()(21)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## EndCursor


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(22)


```ts
function assumeExists(value): FormId;
```

## Parameters

### value

`string`

## Returns

[`FormId`](../../../type-aliases/FormId.md)

---

## Function: getValue()(22)


```ts
function getValue(key): string;
```

## Parameters

### key

[`FormId`](../../../type-aliases/FormId.md)

## Returns

`string`

---

## Function: isValid()(22)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## FormId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(23)


```ts
function assumeExists(value): FormKey;
```

## Parameters

### value

`string`

## Returns

[`FormKey`](../../../type-aliases/FormKey.md)

---

## Function: getValue()(23)


```ts
function getValue(key): string;
```

## Parameters

### key

[`FormKey`](../../../type-aliases/FormKey.md)

## Returns

`string`

---

## Function: isValid()(23)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## FormKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(24)


```ts
function assumeExists(value): GlobalListenerId;
```

## Parameters

### value

`string`

## Returns

[`GlobalListenerId`](../../../type-aliases/GlobalListenerId.md)

---

## Function: getValue()(24)


```ts
function getValue(key): string;
```

## Parameters

### key

[`GlobalListenerId`](../../../type-aliases/GlobalListenerId.md)

## Returns

`string`

---

## Function: isValid()(24)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## GlobalListenerId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(25)


```ts
function assumeExists(value): GroupId;
```

## Parameters

### value

`string`

## Returns

[`GroupId`](../../../type-aliases/GroupId.md)

---

## Function: getValue()(25)


```ts
function getValue(key): string;
```

## Parameters

### key

[`GroupId`](../../../type-aliases/GroupId.md)

## Returns

`string`

---

## Function: isValid()(25)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## GroupId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(26)


```ts
function assumeExists(value): IncidentKey;
```

## Parameters

### value

`string`

## Returns

[`IncidentKey`](../../../type-aliases/IncidentKey.md)

---

## Function: getValue()(26)


```ts
function getValue(key): string;
```

## Parameters

### key

[`IncidentKey`](../../../type-aliases/IncidentKey.md)

## Returns

`string`

---

## Function: isValid()(26)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## IncidentKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(27)


```ts
function assumeExists(value): JobKey;
```

## Parameters

### value

`string`

## Returns

[`JobKey`](../../../type-aliases/JobKey.md)

---

## Function: getValue()(27)


```ts
function getValue(key): string;
```

## Parameters

### key

[`JobKey`](../../../type-aliases/JobKey.md)

## Returns

`string`

---

## Function: isValid()(27)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## JobKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(28)


```ts
function assumeExists(value): MappingRuleId;
```

## Parameters

### value

`string`

## Returns

[`MappingRuleId`](../../../type-aliases/MappingRuleId.md)

---

## Function: getValue()(28)


```ts
function getValue(key): string;
```

## Parameters

### key

[`MappingRuleId`](../../../type-aliases/MappingRuleId.md)

## Returns

`string`

---

## Function: isValid()(28)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## MappingRuleId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(29)


```ts
function assumeExists(value): MessageKey;
```

## Parameters

### value

`string`

## Returns

[`MessageKey`](../../../type-aliases/MessageKey.md)

---

## Function: getValue()(29)


```ts
function getValue(key): string;
```

## Parameters

### key

[`MessageKey`](../../../type-aliases/MessageKey.md)

## Returns

`string`

---

## Function: isValid()(29)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## MessageKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(30)


```ts
function assumeExists(value): MessageSubscriptionKey;
```

## Parameters

### value

`string`

## Returns

[`MessageSubscriptionKey`](../../../type-aliases/MessageSubscriptionKey.md)

---

## Function: getValue()(30)


```ts
function getValue(key): string;
```

## Parameters

### key

[`MessageSubscriptionKey`](../../../type-aliases/MessageSubscriptionKey.md)

## Returns

`string`

---

## Function: isValid()(30)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## MessageSubscriptionKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(31)


```ts
function assumeExists(value): ProcessDefinitionId;
```

## Parameters

### value

`string`

## Returns

[`ProcessDefinitionId`](../../../type-aliases/ProcessDefinitionId.md)

---

## Function: getValue()(31)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ProcessDefinitionId`](../../../type-aliases/ProcessDefinitionId.md)

## Returns

`string`

---

## Function: isValid()(31)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ProcessDefinitionId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(32)


```ts
function assumeExists(value): ProcessDefinitionKey;
```

## Parameters

### value

`string`

## Returns

[`ProcessDefinitionKey`](../../../type-aliases/ProcessDefinitionKey.md)

---

## Function: getValue()(32)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ProcessDefinitionKey`](../../../type-aliases/ProcessDefinitionKey.md)

## Returns

`string`

---

## Function: isValid()(32)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ProcessDefinitionKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(33)


```ts
function assumeExists(value): ProcessInstanceKey;
```

## Parameters

### value

`string`

## Returns

[`ProcessInstanceKey`](../../../type-aliases/ProcessInstanceKey.md)

---

## Function: getValue()(33)


```ts
function getValue(key): string;
```

## Parameters

### key

[`ProcessInstanceKey`](../../../type-aliases/ProcessInstanceKey.md)

## Returns

`string`

---

## Function: isValid()(33)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## ProcessInstanceKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(34)


```ts
function assumeExists(value): RoleId;
```

## Parameters

### value

`string`

## Returns

[`RoleId`](../../../type-aliases/RoleId.md)

---

## Function: getValue()(34)


```ts
function getValue(key): string;
```

## Parameters

### key

[`RoleId`](../../../type-aliases/RoleId.md)

## Returns

`string`

---

## Function: isValid()(34)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## RoleId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(35)


```ts
function assumeExists(value): SignalKey;
```

## Parameters

### value

`string`

## Returns

[`SignalKey`](../../../type-aliases/SignalKey.md)

---

## Function: getValue()(35)


```ts
function getValue(key): string;
```

## Parameters

### key

[`SignalKey`](../../../type-aliases/SignalKey.md)

## Returns

`string`

---

## Function: isValid()(35)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## SignalKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(36)


```ts
function assumeExists(value): StartCursor;
```

## Parameters

### value

`string`

## Returns

[`StartCursor`](../../../type-aliases/StartCursor.md)

---

## Function: getValue()(36)


```ts
function getValue(key): string;
```

## Parameters

### key

[`StartCursor`](../../../type-aliases/StartCursor.md)

## Returns

`string`

---

## Function: isValid()(36)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## StartCursor


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: fromString()


```ts
function fromString(value): Tag;
```

## Parameters

### value

`string`

## Returns

[`Tag`](../../../type-aliases/Tag.md)

---

## Function: getValue()(37)


```ts
function getValue(key): string;
```

## Parameters

### key

[`Tag`](../../../type-aliases/Tag.md)

## Returns

`string`

---

## Function: isValid()(37)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## Tag


## Functions

- [fromString](functions/fromString.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(37)


```ts
function assumeExists(value): TenantId;
```

## Parameters

### value

`string`

## Returns

[`TenantId`](../../../type-aliases/TenantId.md)

---

## Function: getValue()(38)


```ts
function getValue(key): string;
```

## Parameters

### key

[`TenantId`](../../../type-aliases/TenantId.md)

## Returns

`string`

---

## Function: isValid()(38)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## TenantId


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(38)


```ts
function assumeExists(value): UserTaskKey;
```

## Parameters

### value

`string`

## Returns

[`UserTaskKey`](../../../type-aliases/UserTaskKey.md)

---

## Function: getValue()(39)


```ts
function getValue(key): string;
```

## Parameters

### key

[`UserTaskKey`](../../../type-aliases/UserTaskKey.md)

## Returns

`string`

---

## Function: isValid()(39)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## UserTaskKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(39)


```ts
function assumeExists(value): Username;
```

## Parameters

### value

`string`

## Returns

[`Username`](../../../type-aliases/Username.md)

---

## Function: getValue()(40)


```ts
function getValue(key): string;
```

## Parameters

### key

[`Username`](../../../type-aliases/Username.md)

## Returns

`string`

---

## Function: isValid()(40)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## Username


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Function: assumeExists()(40)


```ts
function assumeExists(value): VariableKey;
```

## Parameters

### value

`string`

## Returns

[`VariableKey`](../../../type-aliases/VariableKey.md)

---

## Function: getValue()(41)


```ts
function getValue(key): string;
```

## Parameters

### key

[`VariableKey`](../../../type-aliases/VariableKey.md)

## Returns

`string`

---

## Function: isValid()(41)


```ts
function isValid(value): boolean;
```

## Parameters

### value

`string`

## Returns

`boolean`

---

## VariableKey


## Functions

- [assumeExists](functions/assumeExists.md)
- [getValue](functions/getValue.md)
- [isValid](functions/isValid.md)

---

## Type Alias: ActivateAdHocSubProcessActivitiesData


```ts
type ActivateAdHocSubProcessActivitiesData = object;
```

## Properties

### body

```ts
body: AdHocSubProcessActivateActivitiesInstruction;
```

---

### path

```ts
path: object;
```

#### adHocSubProcessInstanceKey

```ts
adHocSubProcessInstanceKey: ElementInstanceKey;
```

The key of the ad-hoc sub-process instance that contains the activities.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/element-instances/ad-hoc-activities/{adHocSubProcessInstanceKey}/activation";
```

---

## Type Alias: ActivateAdHocSubProcessActivitiesError


```ts
type ActivateAdHocSubProcessActivitiesError =
  ActivateAdHocSubProcessActivitiesErrors[keyof ActivateAdHocSubProcessActivitiesErrors];
```

---

## Type Alias: ActivateAdHocSubProcessActivitiesErrors


```ts
type ActivateAdHocSubProcessActivitiesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The ad-hoc sub-process instance is not found or the provided key does not identify an ad-hoc sub-process.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ActivateAdHocSubProcessActivitiesResponse


```ts
type ActivateAdHocSubProcessActivitiesResponse =
  ActivateAdHocSubProcessActivitiesResponses[keyof ActivateAdHocSubProcessActivitiesResponses];
```

---

## Type Alias: ActivateAdHocSubProcessActivitiesResponses


```ts
type ActivateAdHocSubProcessActivitiesResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The ad-hoc sub-process instance is modified.

---

## Type Alias: ActivateJobsData


```ts
type ActivateJobsData = object;
```

## Properties

### body

```ts
body: JobActivationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/activation";
```

---

## Type Alias: ActivateJobsError


```ts
type ActivateJobsError = ActivateJobsErrors[keyof ActivateJobsErrors];
```

---

## Type Alias: ActivateJobsErrors


```ts
type ActivateJobsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ActivateJobsResponse


```ts
type ActivateJobsResponse = ActivateJobsResponses[keyof ActivateJobsResponses];
```

---

## Type Alias: ActivateJobsResponses


```ts
type ActivateJobsResponses = object;
```

## Properties

### 200

```ts
200: JobActivationResult;
```

The list of activated jobs.

---

## Type Alias: ActivatedJobResult


```ts
type ActivatedJobResult = object;
```

## Properties

### businessId

```ts
businessId: BusinessId | null;
```

The business ID of the owning process instance, inherited when the job was created.
This is `null` for jobs created before version 8.10 and for jobs whose owning process
instance has no business ID.

---

### customHeaders

```ts
customHeaders: object;
```

A set of custom headers defined during modelling; returned as a serialized JSON document.

#### Index Signature

```ts
[key: string]: unknown
```

---

### deadline

```ts
deadline: number;
```

When the job can be activated again, sent as a UNIX epoch timestamp.

---

### elementId

```ts
elementId: ElementId;
```

The associated task element ID.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The element instance key of the task.

---

### jobKey

```ts
jobKey: JobKey;
```

The key, a unique identifier for the job.

---

### kind

```ts
kind: JobKindEnum;
```

---

### listenerEventType

```ts
listenerEventType: JobListenerEventTypeEnum;
```

---

### priority

```ts
priority: number;
```

The priority of the job. Higher values indicate higher priority. Jobs created before 8.10 have no stored priority; the API returns 0 for such jobs.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The bpmn process ID of the job's process definition.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the job's process definition.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version of the job's process definition.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The job's process instance key.

---

### retries

```ts
retries: number;
```

The amount of retries left to this job (should always be positive).

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### tags

```ts
tags: TagSet;
```

---

### tenantId

```ts
tenantId: TenantId;
```

The ID of the tenant that owns the job.

---

### type

```ts
type: string;
```

The type of the job (should match what was requested).

---

### userTask

```ts
userTask: UserTaskProperties | null;
```

User task properties, if the job is a user task.
This is `null` if the job is not a user task.

---

### variables

```ts
variables: object;
```

All variables visible to the task scope, computed at activation time.

#### Index Signature

```ts
[key: string]: unknown
```

---

### worker

```ts
worker: string;
```

The name of the worker which activated this job.

---

## Type Alias: AdHocSubProcessActivateActivitiesInstruction


```ts
type AdHocSubProcessActivateActivitiesInstruction = object;
```

## Properties

### cancelRemainingInstances?

```ts
optional cancelRemainingInstances?: boolean;
```

Whether to cancel remaining instances of the ad-hoc sub-process.

---

### elements

```ts
elements: AdHocSubProcessActivateActivityReference[];
```

Activities to activate.

---

## Type Alias: AdHocSubProcessActivateActivityReference


```ts
type AdHocSubProcessActivateActivityReference = object;
```

## Properties

### elementId

```ts
elementId: ElementId;
```

The ID of the element that should be activated.

---

### variables?

```ts
optional variables?: object;
```

Variables to be set when activating the element.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: AdvancedActorTypeFilter


```ts
type AdvancedActorTypeFilter = object;
```

Advanced filter

Advanced AuditLogActorTypeEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogActorTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogActorTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: AuditLogActorTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedAgentHistoryItemKeyFilter


```ts
type AdvancedAgentHistoryItemKeyFilter = object;
```

Advanced filter

Advanced AgentHistoryItemKey filter.

## Properties

### $eq?

```ts
optional $eq?: AgentHistoryItemKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AgentHistoryItemKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: AgentHistoryItemKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: AgentHistoryItemKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedAgentInstanceHistoryCommitStatusFilter


```ts
type AdvancedAgentInstanceHistoryCommitStatusFilter = object;
```

Advanced filter

Advanced AgentInstanceHistoryCommitStatusEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AgentInstanceHistoryCommitStatusEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AgentInstanceHistoryCommitStatusEnum[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: AgentInstanceHistoryCommitStatusEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedAgentInstanceHistoryRoleFilter


```ts
type AdvancedAgentInstanceHistoryRoleFilter = object;
```

Advanced filter

Advanced AgentInstanceHistoryRoleEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AgentInstanceHistoryRoleEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AgentInstanceHistoryRoleEnum[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: AgentInstanceHistoryRoleEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedAgentInstanceKeyFilter


```ts
type AdvancedAgentInstanceKeyFilter = object;
```

Advanced filter

Advanced AgentInstanceKey filter.

## Properties

### $eq?

```ts
optional $eq?: AgentInstanceKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AgentInstanceKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: AgentInstanceKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: AgentInstanceKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedAgentInstanceStatusFilter


```ts
type AdvancedAgentInstanceStatusFilter = object;
```

Advanced filter

Advanced AgentInstanceStatusEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AgentInstanceStatusEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AgentInstanceStatusEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: AgentInstanceStatusEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedAuditLogEntityKeyFilter


```ts
type AdvancedAuditLogEntityKeyFilter = object;
```

Advanced filter

Advanced entityKey filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogEntityKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogEntityKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: AuditLogEntityKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: AuditLogEntityKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedAuditLogKeyFilter


```ts
type AdvancedAuditLogKeyFilter = object;
```

Advanced filter

Advanced AuditLogKey filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: AuditLogKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: AuditLogKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedBatchOperationItemStateFilter


```ts
type AdvancedBatchOperationItemStateFilter = object;
```

Advanced filter

Advanced BatchOperationItemStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: BatchOperationItemStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: BatchOperationItemStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: BatchOperationItemStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedBatchOperationStateFilter


```ts
type AdvancedBatchOperationStateFilter = object;
```

Advanced filter

Advanced BatchOperationStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: BatchOperationStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: BatchOperationStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: BatchOperationStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedBatchOperationTypeFilter


```ts
type AdvancedBatchOperationTypeFilter = object;
```

Advanced filter

Advanced BatchOperationTypeEnum filter.

## Properties

### $eq?

```ts
optional $eq?: BatchOperationTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: BatchOperationTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: BatchOperationTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedCategoryFilter


```ts
type AdvancedCategoryFilter = object;
```

Advanced filter

Advanced AuditLogCategoryEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogCategoryEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogCategoryEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: AuditLogCategoryEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedClusterVariableScopeFilter


```ts
type AdvancedClusterVariableScopeFilter = object;
```

Advanced filter

Advanced ClusterVariableScopeEnum filter.

## Properties

### $eq?

```ts
optional $eq?: ClusterVariableScopeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ClusterVariableScopeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: ClusterVariableScopeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedDateTimeFilter


```ts
type AdvancedDateTimeFilter = object;
```

Advanced filter

Advanced date-time filter.

## Properties

### $eq?

```ts
optional $eq?: string;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $gt?

```ts
optional $gt?: string;
```

Greater than comparison with the provided value.

---

### $gte?

```ts
optional $gte?: string;
```

Greater than or equal comparison with the provided value.

---

### $in?

```ts
optional $in?: string[];
```

Checks if the property matches any of the provided values.

---

### $lt?

```ts
optional $lt?: string;
```

Lower than comparison with the provided value.

---

### $lte?

```ts
optional $lte?: string;
```

Lower than or equal comparison with the provided value.

---

### $neq?

```ts
optional $neq?: string;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedDecisionDefinitionKeyFilter


```ts
type AdvancedDecisionDefinitionKeyFilter = object;
```

Advanced filter

Advanced DecisionDefinitionKey filter.

## Properties

### $eq?

```ts
optional $eq?: DecisionDefinitionKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: DecisionDefinitionKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: DecisionDefinitionKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: DecisionDefinitionKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedDecisionEvaluationInstanceKeyFilter


```ts
type AdvancedDecisionEvaluationInstanceKeyFilter = object;
```

Advanced filter

Advanced DecisionEvaluationInstanceKey filter.

## Properties

### $eq?

```ts
optional $eq?: DecisionEvaluationInstanceKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: DecisionEvaluationInstanceKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: DecisionEvaluationInstanceKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: DecisionEvaluationInstanceKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedDecisionEvaluationKeyFilter


```ts
type AdvancedDecisionEvaluationKeyFilter = object;
```

Advanced filter

Advanced DecisionEvaluationKey filter.

## Properties

### $eq?

```ts
optional $eq?: DecisionEvaluationKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: DecisionEvaluationKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: DecisionEvaluationKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: DecisionEvaluationKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedDecisionInstanceStateFilter


```ts
type AdvancedDecisionInstanceStateFilter = object;
```

Advanced filter

Advanced DecisionInstanceStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: DecisionInstanceStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: DecisionInstanceStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: DecisionInstanceStateEnum;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: DecisionInstanceStateEnum[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedDecisionRequirementsKeyFilter


```ts
type AdvancedDecisionRequirementsKeyFilter = object;
```

Advanced filter

Advanced DecisionRequirementsKey filter.

## Properties

### $eq?

```ts
optional $eq?: DecisionRequirementsKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: DecisionRequirementsKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: DecisionRequirementsKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: DecisionRequirementsKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedDeploymentKeyFilter


```ts
type AdvancedDeploymentKeyFilter = object;
```

Advanced filter

Advanced DeploymentKey filter.

## Properties

### $eq?

```ts
optional $eq?: DeploymentKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: DeploymentKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: DeploymentKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: DeploymentKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedElementIdFilter


```ts
type AdvancedElementIdFilter = object;
```

Advanced filter

Advanced ElementId filter.

## Properties

### $eq?

```ts
optional $eq?: ElementId;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ElementId[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: ElementId;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ElementId[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedElementInstanceKeyFilter


```ts
type AdvancedElementInstanceKeyFilter = object;
```

Advanced filter

Advanced ElementInstanceKey filter.

## Properties

### $eq?

```ts
optional $eq?: ElementInstanceKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ElementInstanceKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: ElementInstanceKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ElementInstanceKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedElementInstanceStateFilter


```ts
type AdvancedElementInstanceStateFilter = object;
```

Advanced filter

Advanced ElementInstanceStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: ElementInstanceStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ElementInstanceStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: ElementInstanceStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedEntityTypeFilter


```ts
type AdvancedEntityTypeFilter = object;
```

Advanced filter

Advanced AuditLogEntityTypeEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogEntityTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogEntityTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: AuditLogEntityTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedFormKeyFilter


```ts
type AdvancedFormKeyFilter = object;
```

Advanced filter

Advanced FormKey filter.

## Properties

### $eq?

```ts
optional $eq?: FormKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: FormKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: FormKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: FormKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedGlobalListenerSourceFilter


```ts
type AdvancedGlobalListenerSourceFilter = object;
```

Advanced filter

Advanced global listener source filter.

## Properties

### $eq?

```ts
optional $eq?: GlobalListenerSourceEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: GlobalListenerSourceEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: GlobalListenerSourceEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedGlobalTaskListenerEventTypeFilter


```ts
type AdvancedGlobalTaskListenerEventTypeFilter = object;
```

Advanced filter

Advanced global listener event type filter.

## Properties

### $eq?

```ts
optional $eq?: GlobalTaskListenerEventTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: GlobalTaskListenerEventTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: GlobalTaskListenerEventTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedIncidentErrorTypeFilter


```ts
type AdvancedIncidentErrorTypeFilter = object;
```

Advanced filter

Advanced IncidentErrorTypeEnum filter

## Properties

### $eq?

```ts
optional $eq?: IncidentErrorTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: IncidentErrorTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: IncidentErrorTypeEnum;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: IncidentErrorTypeEnum[];
```

Checks if the property does not match any of the provided values.

---

## Type Alias: AdvancedIncidentStateFilter


```ts
type AdvancedIncidentStateFilter = object;
```

Advanced filter

Advanced IncidentStateEnum filter

## Properties

### $eq?

```ts
optional $eq?: IncidentStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: IncidentStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: IncidentStateEnum;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: IncidentStateEnum[];
```

Checks if the property does not match any of the provided values.

---

## Type Alias: AdvancedIntegerFilter


```ts
type AdvancedIntegerFilter = object;
```

Advanced filter

Advanced integer (int32) filter.

## Properties

### $eq?

```ts
optional $eq?: number;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $gt?

```ts
optional $gt?: number;
```

Greater than comparison with the provided value.

---

### $gte?

```ts
optional $gte?: number;
```

Greater than or equal comparison with the provided value.

---

### $in?

```ts
optional $in?: number[];
```

Checks if the property matches any of the provided values.

---

### $lt?

```ts
optional $lt?: number;
```

Lower than comparison with the provided value.

---

### $lte?

```ts
optional $lte?: number;
```

Lower than or equal comparison with the provided value.

---

### $neq?

```ts
optional $neq?: number;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedJobKeyFilter


```ts
type AdvancedJobKeyFilter = object;
```

Advanced filter

Advanced JobKey filter.

## Properties

### $eq?

```ts
optional $eq?: JobKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: JobKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: JobKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: JobKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedJobKindFilter


```ts
type AdvancedJobKindFilter = object;
```

Advanced filter

Advanced JobKindEnum filter.

## Properties

### $eq?

```ts
optional $eq?: JobKindEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: JobKindEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: JobKindEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedJobListenerEventTypeFilter


```ts
type AdvancedJobListenerEventTypeFilter = object;
```

Advanced filter

Advanced JobListenerEventTypeEnum filter.

## Properties

### $eq?

```ts
optional $eq?: JobListenerEventTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: JobListenerEventTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: JobListenerEventTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedJobStateFilter


```ts
type AdvancedJobStateFilter = object;
```

Advanced filter

Advanced JobStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: JobStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: JobStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: JobStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedMessageSubscriptionKeyFilter


```ts
type AdvancedMessageSubscriptionKeyFilter = object;
```

Advanced filter

Advanced MessageSubscriptionKey filter.

## Properties

### $eq?

```ts
optional $eq?: MessageSubscriptionKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: MessageSubscriptionKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: MessageSubscriptionKey;
```

Checks for equality with the provided value.

---

### $notIn?

```ts
optional $notIn?: MessageSubscriptionKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedMessageSubscriptionStateFilter


```ts
type AdvancedMessageSubscriptionStateFilter = object;
```

Advanced filter

Advanced MessageSubscriptionStateEnum filter

## Properties

### $eq?

```ts
optional $eq?: MessageSubscriptionStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: MessageSubscriptionStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: MessageSubscriptionStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedMessageSubscriptionTypeFilter


```ts
type AdvancedMessageSubscriptionTypeFilter = object;
```

Advanced filter

Advanced MessageSubscriptionTypeEnum filter

## Properties

### $eq?

```ts
optional $eq?: MessageSubscriptionTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: MessageSubscriptionTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: MessageSubscriptionTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedOperationTypeFilter


```ts
type AdvancedOperationTypeFilter = object;
```

Advanced filter

Advanced AuditLogOperationTypeEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogOperationTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogOperationTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: AuditLogOperationTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedProcessDefinitionIdFilter


```ts
type AdvancedProcessDefinitionIdFilter = object;
```

Advanced filter

Advanced ProcessDefinitionId filter.

## Properties

### $eq?

```ts
optional $eq?: ProcessDefinitionId;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ProcessDefinitionId[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: ProcessDefinitionId;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ProcessDefinitionId[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedProcessDefinitionKeyFilter


```ts
type AdvancedProcessDefinitionKeyFilter = object;
```

Advanced filter

Advanced ProcessDefinitionKey filter.

## Properties

### $eq?

```ts
optional $eq?: ProcessDefinitionKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ProcessDefinitionKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: ProcessDefinitionKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ProcessDefinitionKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedProcessInstanceKeyFilter


```ts
type AdvancedProcessInstanceKeyFilter = object;
```

Advanced filter

Advanced ProcessInstanceKey filter.

## Properties

### $eq?

```ts
optional $eq?: ProcessInstanceKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ProcessInstanceKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: ProcessInstanceKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ProcessInstanceKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedProcessInstanceStateFilter


```ts
type AdvancedProcessInstanceStateFilter = object;
```

Advanced filter

Advanced ProcessInstanceStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: ProcessInstanceStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ProcessInstanceStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: ProcessInstanceStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedResourceKeyFilter


```ts
type AdvancedResourceKeyFilter = object;
```

Advanced filter

Advanced ResourceKey filter.

## Properties

### $eq?

```ts
optional $eq?: ResourceKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ResourceKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: ResourceKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ResourceKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedResultFilter


```ts
type AdvancedResultFilter = object;
```

Advanced filter

Advanced AuditLogResultEnum filter.

## Properties

### $eq?

```ts
optional $eq?: AuditLogResultEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: AuditLogResultEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: AuditLogResultEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedScopeKeyFilter


```ts
type AdvancedScopeKeyFilter = object;
```

Advanced filter

Advanced ScopeKey filter.

## Properties

### $eq?

```ts
optional $eq?: ScopeKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: ScopeKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: ScopeKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: ScopeKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedStringFilter


```ts
type AdvancedStringFilter = BasicStringFilter & object;
```

Advanced filter

Advanced string filter.

## Type Declaration

### $like?

```ts
optional $like?: LikeFilter;
```

---

## Type Alias: AdvancedUserTaskStateFilter


```ts
type AdvancedUserTaskStateFilter = object;
```

Advanced filter

Advanced UserTaskStateEnum filter.

## Properties

### $eq?

```ts
optional $eq?: UserTaskStateEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: UserTaskStateEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: UserTaskStateEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedVariableKeyFilter


```ts
type AdvancedVariableKeyFilter = object;
```

Advanced filter

Advanced VariableKey filter.

## Properties

### $eq?

```ts
optional $eq?: VariableKey;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: VariableKey[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: VariableKey;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: VariableKey[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: AdvancedWaitStateElementTypeFilter


```ts
type AdvancedWaitStateElementTypeFilter = object;
```

Advanced filter

Advanced element type filter.

## Properties

### $eq?

```ts
optional $eq?: WaitStateElementTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: WaitStateElementTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: WaitStateElementTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AdvancedWaitStateTypeFilter


```ts
type AdvancedWaitStateTypeFilter = object;
```

Advanced filter

Advanced wait state type filter.

## Properties

### $eq?

```ts
optional $eq?: WaitStateTypeEnum;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: WaitStateTypeEnum[];
```

Checks if the property matches any of the provided values.

---

### $like?

```ts
optional $like?: LikeFilter;
```

---

### $neq?

```ts
optional $neq?: WaitStateTypeEnum;
```

Checks for inequality with the provided value.

---

## Type Alias: AgentHistoryItemKey


```ts
type AgentHistoryItemKey = CamundaKey<"AgentHistoryItemKey">;
```

System-generated key for an agent history item.

---

## Type Alias: AgentHistoryItemKeyExactMatch


```ts
type AgentHistoryItemKeyExactMatch = AgentHistoryItemKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: AgentHistoryItemKeyFilterProperty


```ts
type AgentHistoryItemKeyFilterProperty =
  AgentHistoryItemKeyExactMatch | AdvancedAgentHistoryItemKeyFilter;
```

AgentHistoryItemKey property with full advanced search capabilities.

---

## Type Alias: AgentInstanceCreationRequest


```ts
type AgentInstanceCreationRequest = object;
```

Request to create a new agent instance.

## Properties

### definition

```ts
definition: AgentInstanceDefinition;
```

Static definition set once at creation.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the AHSP or AI Agent Task element instance.
The engine uses this key to infer processInstanceKey, elementId,
processDefinitionKey, and tenantId.

---

### limits?

```ts
optional limits?: AgentInstanceLimits;
```

Limits for the agent execution. When omitted, all limits default to -1
(no limit).

---

## Type Alias: AgentInstanceCreationResult


```ts
type AgentInstanceCreationResult = object;
```

Response returned after successfully creating an agent instance.

## Properties

### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The system-generated key for the created agent instance.

---

## Type Alias: AgentInstanceDefinition


```ts
type AgentInstanceDefinition = object;
```

The static definition of an agent instance, set once at creation.

## Properties

### model

```ts
model: string;
```

The LLM model identifier (for example, gpt-4o).

---

### provider

```ts
provider: string;
```

The LLM provider (for example, openai or anthropic).

---

### systemPrompt

```ts
systemPrompt: string;
```

The system prompt configured for this agent instance.

---

## Type Alias: AgentInstanceDocumentContent


```ts
type AgentInstanceDocumentContent = object;
```

Document content

A Camunda Document Store reference content block.

## Properties

### contentType

```ts
contentType: string;
```

The content type discriminator.

---

### documentReference

```ts
documentReference: DocumentReference;
```

A reference to a document stored in the Camunda Document Store.

---

## Type Alias: AgentInstanceFilter


```ts
type AgentInstanceFilter = object;
```

Agent instance search filter.

## Properties

### agentInstanceKey?

```ts
optional agentInstanceKey?: AgentInstanceKeyFilterProperty;
```

The unique key of the agent instance.

---

### completionDate?

```ts
optional completionDate?: DateTimeFilterProperty;
```

The completion date of the agent instance.

---

### creationDate?

```ts
optional creationDate?: DateTimeFilterProperty;
```

The creation date of the agent instance.

---

### elementId?

```ts
optional elementId?: ElementIdFilterProperty;
```

The BPMN element ID of the agent task.

---

### elementInstanceKeys?

```ts
optional elementInstanceKeys?: ElementInstanceKeyFilterProperty[];
```

The keys of element instances associated with this agent instance.
If multiple keys are provided, the filter matches agent instances associated with all of the provided keys at the same time.

---

### lastUpdatedDate?

```ts
optional lastUpdatedDate?: DateTimeFilterProperty;
```

The date the agent instance was last updated.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The BPMN process ID of the process definition associated with this agent instance.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The key of the process definition associated with this agent instance.

---

### processDefinitionVersion?

```ts
optional processDefinitionVersion?: IntegerFilterProperty;
```

The version of the process definition associated with this agent instance.

---

### processDefinitionVersionTag?

```ts
optional processDefinitionVersionTag?: StringFilterProperty;
```

The version tag of the process definition associated with this agent instance.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The key of the process instance that owns this agent instance.

---

### rootProcessInstanceKey?

```ts
optional rootProcessInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The key of the root process instance. Filters agent instances belonging to a specific
call hierarchy. The root process instance is the top-level ancestor in the process
instance hierarchy.

---

### status?

```ts
optional status?: AgentInstanceStatusFilterProperty;
```

The current status of the agent instance.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The tenant ID of the agent instance.

---

## Type Alias: AgentInstanceHistoryCommitStatusEnum


```ts
type AgentInstanceHistoryCommitStatusEnum =
  (typeof AgentInstanceHistoryCommitStatusEnum)[keyof typeof AgentInstanceHistoryCommitStatusEnum];
```

The commit status of a history item.
COMMITTED: the producing job completed successfully.
PENDING: the producing job is still active (in-flight).
DISCARDED: the producing job failed; this item was superseded by a later activation.

---

## Type Alias: AgentInstanceHistoryCommitStatusExactMatch


```ts
type AgentInstanceHistoryCommitStatusExactMatch =
  AgentInstanceHistoryCommitStatusEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: AgentInstanceHistoryCommitStatusFilterProperty


```ts
type AgentInstanceHistoryCommitStatusFilterProperty =
  | AgentInstanceHistoryCommitStatusExactMatch
  | AdvancedAgentInstanceHistoryCommitStatusFilter;
```

AgentInstanceHistoryCommitStatusEnum property with full advanced search capabilities.

---

## Type Alias: AgentInstanceHistoryFilter


```ts
type AgentInstanceHistoryFilter = object;
```

Agent instance history item search filter.

## Properties

### commitStatus?

```ts
optional commitStatus?: AgentInstanceHistoryCommitStatusFilterProperty;
```

The commit status of the history item. Defaults to COMMITTED only.
Include PENDING or DISCARDED explicitly to debug in-flight or failed activations.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The key of the element instance under which the history item was produced.

---

### historyItemKey?

```ts
optional historyItemKey?: AgentHistoryItemKeyFilterProperty;
```

The unique key of the history item.

---

### iteration?

```ts
optional iteration?: IntegerFilterProperty;
```

The iteration number.

---

### jobKey?

```ts
optional jobKey?: JobKeyFilterProperty;
```

The key of the job activation that produced the history item.

---

### producedAt?

```ts
optional producedAt?: DateTimeFilterProperty;
```

The timestamp when the history item was produced.

---

### role?

```ts
optional role?: AgentInstanceHistoryRoleFilterProperty;
```

The role of the history item.

---

## Type Alias: AgentInstanceHistoryItemCreationResult


```ts
type AgentInstanceHistoryItemCreationResult = object;
```

Response returned after successfully appending a history item.

## Properties

### historyItemKey

```ts
historyItemKey: AgentHistoryItemKey;
```

The system-generated key for the created history item.

---

## Type Alias: AgentInstanceHistoryItemMetrics


```ts
type AgentInstanceHistoryItemMetrics = object;
```

Per-call token and latency metrics for an ASSISTANT history item.

## Properties

### durationMs

```ts
durationMs: number;
```

Wall-clock duration of the LLM call in milliseconds.

---

### inputTokens

```ts
inputTokens: number;
```

Input tokens consumed by this LLM call.

---

### outputTokens

```ts
outputTokens: number;
```

Output tokens produced by this LLM call.

---

## Type Alias: AgentInstanceHistoryItemRequest


```ts
type AgentInstanceHistoryItemRequest = object;
```

Request to append a single history item to an agent instance's conversation history.

## Properties

### content

```ts
content: AgentInstanceMessageContent[];
```

The content blocks of this history item.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the currently-active element instance.

---

### iteration?

```ts
optional iteration?: IterationId | null;
```

Sequential iteration number this item belongs to. Omit if not grouping items into iterations.

---

### jobKey

```ts
jobKey: JobKey;
```

The key of the current job activation during which this history item was produced.

---

### jobLease

```ts
jobLease: string;
```

Opaque lease token received from the job activation response.

---

### metrics?

```ts
optional metrics?:
  | AgentInstanceHistoryItemMetrics
  | null;
```

Per-call token and latency metrics. Present on ASSISTANT items only.

---

### producedAt

```ts
producedAt: string;
```

The connector-side timestamp of when this message was produced.

---

### role

```ts
role: AgentInstanceHistoryRoleEnum;
```

The role of this history item in the conversation.

---

### toolCalls?

```ts
optional toolCalls?: AgentInstanceToolCall[] | null;
```

Tool calls associated with this history item.
For ASSISTANT items: tool calls dispatched by this LLM response, with arguments populated.
For TOOL_RESULT items: single-entry array referencing the originating tool call, with arguments null.
Omit for USER items.

---

## Type Alias: AgentInstanceHistoryItemResult


```ts
type AgentInstanceHistoryItemResult = object;
```

A single conversation history item belonging to an agent instance.

## Properties

### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The key of the agent instance this item belongs to.

---

### commitStatus

```ts
commitStatus: AgentInstanceHistoryCommitStatusEnum;
```

The commit status of this history item.

---

### content

```ts
content: AgentInstanceMessageContent[];
```

The content blocks of this history item.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the AI Agent Task or ad-hoc sub-process element instance under which this item was produced.

---

### historyItemKey

```ts
historyItemKey: AgentHistoryItemKey;
```

The unique key for this history item. Stable and sortable by creation order.

---

### iteration

```ts
iteration: IterationId | null;
```

The sequential iteration number this item belongs to. Null if not provided by the connector.

---

### jobKey

```ts
jobKey: JobKey;
```

The key of the job activation during which this item was produced.

---

### jobLease

```ts
jobLease: string;
```

The lease token of the activation that produced this item.

---

### metrics

```ts
metrics: AgentInstanceHistoryItemMetrics;
```

Per-call token and latency metrics. Zero-valued when not available.

---

### producedAt

```ts
producedAt: string;
```

The connector-side timestamp of when this message was produced.

---

### role

```ts
role: AgentInstanceHistoryRoleEnum;
```

The role of this history item in the conversation.

---

### toolCalls

```ts
toolCalls: AgentInstanceToolCall[];
```

Tool calls for this item. Empty for USER items and ASSISTANT items with no tool dispatches.
ASSISTANT items: dispatched tool calls with arguments populated.
TOOL_RESULT items: single-entry array referencing the originating tool call (arguments null).

---

## Type Alias: AgentInstanceHistoryRoleEnum


```ts
type AgentInstanceHistoryRoleEnum =
  (typeof AgentInstanceHistoryRoleEnum)[keyof typeof AgentInstanceHistoryRoleEnum];
```

The role of a history item in the agent conversation.

---

## Type Alias: AgentInstanceHistoryRoleExactMatch


```ts
type AgentInstanceHistoryRoleExactMatch = AgentInstanceHistoryRoleEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: AgentInstanceHistoryRoleFilterProperty


```ts
type AgentInstanceHistoryRoleFilterProperty =
  AgentInstanceHistoryRoleExactMatch | AdvancedAgentInstanceHistoryRoleFilter;
```

AgentInstanceHistoryRoleEnum property with full advanced search capabilities.

---

## Type Alias: AgentInstanceHistorySearchQuery


```ts
type AgentInstanceHistorySearchQuery = SearchQueryRequest & object;
```

Agent instance history search request.

## Type Declaration

### filter?

```ts
optional filter?: AgentInstanceHistoryFilter;
```

The history item search filters.

### sort?

```ts
optional sort?: AgentInstanceHistorySearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: AgentInstanceHistorySearchQueryResult


```ts
type AgentInstanceHistorySearchQueryResult = SearchQueryResponse & object;
```

Agent instance history search response.

## Type Declaration

### items

```ts
items: AgentInstanceHistoryItemResult[];
```

The matching history items.

---

## Type Alias: AgentInstanceHistorySearchQuerySortRequest


```ts
type AgentInstanceHistorySearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "producedAt" | "historyItemKey" | "iteration";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: AgentInstanceKey


```ts
type AgentInstanceKey = CamundaKey<"AgentInstanceKey">;
```

System-generated key for an agent instance.

---

## Type Alias: AgentInstanceKeyExactMatch


```ts
type AgentInstanceKeyExactMatch = AgentInstanceKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: AgentInstanceKeyFilterProperty


```ts
type AgentInstanceKeyFilterProperty =
  AgentInstanceKeyExactMatch | AdvancedAgentInstanceKeyFilter;
```

AgentInstanceKey property with full advanced search capabilities.

---

## Type Alias: AgentInstanceLimits


```ts
type AgentInstanceLimits = object;
```

The configured limits for an agent instance, set once at creation.

## Properties

### maxModelCalls

```ts
maxModelCalls: number;
```

Maximum LLM calls allowed. -1 if no limit is configured.

---

### maxTokens

```ts
maxTokens: number;
```

Maximum total tokens allowed. -1 if no limit is configured.

---

### maxToolCalls

```ts
maxToolCalls: number;
```

Maximum tool calls allowed. -1 if no limit is configured.

---

## Type Alias: AgentInstanceMessageContent


```ts
type AgentInstanceMessageContent =
  | (object & AgentInstanceTextContent)
  | (object & AgentInstanceDocumentContent)
  | (object & AgentInstanceObjectContent);
```

A single content block within a history item. Discriminated by `contentType`.

---

## Type Alias: AgentInstanceMessageContentTypeEnum


```ts
type AgentInstanceMessageContentTypeEnum =
  (typeof AgentInstanceMessageContentTypeEnum)[keyof typeof AgentInstanceMessageContentTypeEnum];
```

The content type discriminator for a history item content block.

---

## Type Alias: AgentInstanceMetrics


```ts
type AgentInstanceMetrics = object;
```

Aggregated metrics for an agent instance across all model calls.

## Properties

### inputTokens

```ts
inputTokens: number;
```

Total input tokens consumed across all model calls.

---

### modelCalls

```ts
modelCalls: number;
```

Total number of LLM calls made.

---

### outputTokens

```ts
outputTokens: number;
```

Total output tokens produced across all model calls.

---

### toolCalls

```ts
toolCalls: number;
```

Total number of tool calls made.

---

## Type Alias: AgentInstanceMetricsDelta


```ts
type AgentInstanceMetricsDelta = object;
```

Metric increments to apply to the agent instance aggregate counters. The engine
accumulates these deltas into running totals on each UPDATED event. All fields
are optional; omit a field to leave the corresponding counter unchanged.

## Properties

### inputTokens?

```ts
optional inputTokens?: number;
```

Increment to apply to the total input token counter.

---

### modelCalls?

```ts
optional modelCalls?: number;
```

Increment to apply to the total model call counter.

---

### outputTokens?

```ts
optional outputTokens?: number;
```

Increment to apply to the total output token counter.

---

### toolCalls?

```ts
optional toolCalls?: number;
```

Increment to apply to the total tool call counter.

---

## Type Alias: AgentInstanceObjectContent


```ts
type AgentInstanceObjectContent = object;
```

Object content

An arbitrary structured content block.

## Properties

### contentType

```ts
contentType: string;
```

The content type discriminator.

---

### object

```ts
object: object;
```

Arbitrary structured content.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: AgentInstanceResult


```ts
type AgentInstanceResult = object;
```

## Properties

### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The unique key for this agent instance.

---

### completionDate

```ts
completionDate: string | null;
```

The date when this agent instance completed. Null while the agent is still running.

---

### creationDate

```ts
creationDate: string;
```

The date when this agent instance was created.

---

### definition

```ts
definition: AgentInstanceDefinition;
```

The static definition of the agent, including model, provider, and system prompt.

---

### elementId

```ts
elementId: ElementId;
```

The BPMN element ID of the ad-hoc sub-process or AI agent task that owns this agent instance.

---

### elementInstanceKeys

```ts
elementInstanceKeys: ElementInstanceKey[];
```

The keys of all element instances associated with this agent instance.

---

### lastUpdatedDate

```ts
lastUpdatedDate: string;
```

The date when this agent instance was last updated.

---

### limits

```ts
limits: AgentInstanceLimits;
```

The configured limits for this agent instance, set once at creation.

---

### metrics

```ts
metrics: AgentInstanceMetrics;
```

Aggregated metrics across all iterations of this agent instance.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The BPMN process ID of the process definition associated with this agent instance.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the process definition associated with this agent instance.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version of the process definition associated with this agent instance.

---

### processDefinitionVersionTag

```ts
processDefinitionVersionTag: string | null;
```

The version tag of the process definition associated with this agent instance.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance that owns this agent instance.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy.

---

### status

```ts
status: AgentInstanceStatusEnum;
```

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of this agent instance.

---

### tools

```ts
tools: AgentTool[];
```

The tools available to the agent.

---

## Type Alias: AgentInstanceSearchQuery


```ts
type AgentInstanceSearchQuery = SearchQueryRequest & object;
```

Agent instance search request.

## Type Declaration

### filter?

```ts
optional filter?: AgentInstanceFilter;
```

The agent instance search filters.

### sort?

```ts
optional sort?: AgentInstanceSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: AgentInstanceSearchQueryResult


```ts
type AgentInstanceSearchQueryResult = SearchQueryResponse & object;
```

Agent instance search response.

## Type Declaration

### items

```ts
items: AgentInstanceResult[];
```

The matching agent instances.

---

## Type Alias: AgentInstanceSearchQuerySortRequest


```ts
type AgentInstanceSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "agentInstanceKey"
  | "status"
  | "elementId"
  | "processInstanceKey"
  | "rootProcessInstanceKey"
  | "processDefinitionKey"
  | "tenantId"
  | "creationDate"
  | "lastUpdatedDate"
  | "completionDate";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: AgentInstanceStatusEnum


```ts
type AgentInstanceStatusEnum =
  (typeof AgentInstanceStatusEnum)[keyof typeof AgentInstanceStatusEnum];
```

The current status of an agent instance.

---

## Type Alias: AgentInstanceStatusExactMatch


```ts
type AgentInstanceStatusExactMatch = AgentInstanceStatusEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: AgentInstanceStatusFilterProperty


```ts
type AgentInstanceStatusFilterProperty =
  AgentInstanceStatusExactMatch | AdvancedAgentInstanceStatusFilter;
```

AgentInstanceStatusEnum property with full advanced search capabilities.

---

## Type Alias: AgentInstanceTextContent


```ts
type AgentInstanceTextContent = object;
```

Text content

A plain-text content block.

## Properties

### contentType

```ts
contentType: string;
```

The content type discriminator.

---

### text

```ts
text: string;
```

The text content.

---

## Type Alias: AgentInstanceToolCall


```ts
type AgentInstanceToolCall = object;
```

A tool call associated with a history item. Used in both ASSISTANT and TOOL_RESULT items.
ASSISTANT items carry arguments; TOOL_RESULT items carry arguments as null.

## Properties

### arguments

```ts
arguments:
  | {
[key: string]: unknown;
}
  | null;
```

The tool call arguments as provided by the LLM. Null on TOOL_RESULT items.

---

### elementId

```ts
elementId: string | null;
```

The BPMN element ID handling this tool.

---

### toolCallId

```ts
toolCallId: string;
```

The LLM-assigned tool call ID. Correlates ASSISTANT items to their matching TOOL_RESULT items.

---

### toolName

```ts
toolName: string;
```

The LLM-visible tool name.

---

## Type Alias: AgentInstanceUpdateRequest


```ts
type AgentInstanceUpdateRequest = object;
```

Request to update the mutable state of an agent instance.

## Properties

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the currently-active element instance for this agent instance.
Used for ownership/equality validation against the stored agent instance
and, when the supplied key differs from the previous association (re-entry
of an ad-hoc sub-process or AI Agent task), appended to elementInstanceKeys
with the reverse link updated on the supplied element instance.

---

### metrics?

```ts
optional metrics?: AgentInstanceMetricsDelta;
```

Metric increments to apply to the aggregate counters.

---

### status?

```ts
optional status?: AgentInstanceUpdateStatusEnum;
```

The new status of the agent instance.

---

### tools?

```ts
optional tools?: AgentTool[] | null;
```

The complete list of tools available to the agent, replacing any previously
stored tools. When provided, the engine replaces the existing tool list with
this value.

---

## Type Alias: AgentInstanceUpdateStatusEnum


```ts
type AgentInstanceUpdateStatusEnum =
  (typeof AgentInstanceUpdateStatusEnum)[keyof typeof AgentInstanceUpdateStatusEnum];
```

The status values that can be set on an agent instance via an update request.

---

## Type Alias: AgentTool


```ts
type AgentTool = object;
```

A tool available to the agent.

## Properties

### description

```ts
description: string | null;
```

A human-readable description of the tool.

---

### elementId

```ts
elementId: string | null;
```

The BPMN element ID of the tool element within the ad-hoc sub-process.

---

### name

```ts
name: string;
```

The tool name as visible to the LLM.

---

## Type Alias: AncestorScopeInstruction


```ts
type AncestorScopeInstruction =
  | (object & DirectAncestorKeyInstruction)
  | (object & InferredAncestorKeyInstruction)
  | (object & UseSourceParentKeyInstruction);
```

Defines the ancestor scope for the created element instances. The default behavior resembles
a "direct" scope instruction with an `ancestorElementInstanceKey` of `"-1"`.

---

## Type Alias: AnyVariableSchema


```ts
type AnyVariableSchema = z.ZodObject<any>;
```

Any Zod object schema; used as the DTO that declares the variables to fetch.

---

## Type Alias: AssignClientToGroupData


```ts
type AssignClientToGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### clientId

```ts
clientId: ClientId;
```

The client ID.

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/clients/{clientId}";
```

---

## Type Alias: AssignClientToGroupError


```ts
type AssignClientToGroupError =
  AssignClientToGroupErrors[keyof AssignClientToGroupErrors];
```

---

## Type Alias: AssignClientToGroupErrors


```ts
type AssignClientToGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 409

```ts
409: ProblemDetail;
```

The client with the given ID is already assigned to the group.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignClientToGroupResponse


```ts
type AssignClientToGroupResponse =
  AssignClientToGroupResponses[keyof AssignClientToGroupResponses];
```

---

## Type Alias: AssignClientToGroupResponses


```ts
type AssignClientToGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The client was assigned successfully to the group.

---

## Type Alias: AssignClientToTenantData


```ts
type AssignClientToTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### clientId

```ts
clientId: ClientId;
```

The unique identifier of the application.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/clients/{clientId}";
```

---

## Type Alias: AssignClientToTenantError


```ts
type AssignClientToTenantError =
  AssignClientToTenantErrors[keyof AssignClientToTenantErrors];
```

---

## Type Alias: AssignClientToTenantErrors


```ts
type AssignClientToTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The tenant was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignClientToTenantResponse


```ts
type AssignClientToTenantResponse =
  AssignClientToTenantResponses[keyof AssignClientToTenantResponses];
```

---

## Type Alias: AssignClientToTenantResponses


```ts
type AssignClientToTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The client was successfully assigned to the tenant.

---

## Type Alias: AssignGroupToTenantData


```ts
type AssignGroupToTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The unique identifier of the group.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/groups/{groupId}";
```

---

## Type Alias: AssignGroupToTenantError


```ts
type AssignGroupToTenantError =
  AssignGroupToTenantErrors[keyof AssignGroupToTenantErrors];
```

---

## Type Alias: AssignGroupToTenantErrors


```ts
type AssignGroupToTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or group was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignGroupToTenantResponse


```ts
type AssignGroupToTenantResponse =
  AssignGroupToTenantResponses[keyof AssignGroupToTenantResponses];
```

---

## Type Alias: AssignGroupToTenantResponses


```ts
type AssignGroupToTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The group was successfully assigned to the tenant.

---

## Type Alias: AssignMappingRuleToGroupData


```ts
type AssignMappingRuleToGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The mapping rule ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: AssignMappingRuleToGroupError


```ts
type AssignMappingRuleToGroupError =
  AssignMappingRuleToGroupErrors[keyof AssignMappingRuleToGroupErrors];
```

---

## Type Alias: AssignMappingRuleToGroupErrors


```ts
type AssignMappingRuleToGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group or mapping rule with the given ID was not found.

---

### 409

```ts
409: ProblemDetail;
```

The mapping rule with the given ID is already assigned to the group.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignMappingRuleToGroupResponse


```ts
type AssignMappingRuleToGroupResponse =
  AssignMappingRuleToGroupResponses[keyof AssignMappingRuleToGroupResponses];
```

---

## Type Alias: AssignMappingRuleToGroupResponses


```ts
type AssignMappingRuleToGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The mapping rule was assigned successfully to the group.

---

## Type Alias: AssignMappingRuleToTenantData


```ts
type AssignMappingRuleToTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The unique identifier of the mapping rule.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: AssignMappingRuleToTenantError


```ts
type AssignMappingRuleToTenantError =
  AssignMappingRuleToTenantErrors[keyof AssignMappingRuleToTenantErrors];
```

---

## Type Alias: AssignMappingRuleToTenantErrors


```ts
type AssignMappingRuleToTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or mapping rule was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignMappingRuleToTenantResponse


```ts
type AssignMappingRuleToTenantResponse =
  AssignMappingRuleToTenantResponses[keyof AssignMappingRuleToTenantResponses];
```

---

## Type Alias: AssignMappingRuleToTenantResponses


```ts
type AssignMappingRuleToTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The mapping rule was successfully assigned to the tenant.

---

## Type Alias: AssignRoleToClientData


```ts
type AssignRoleToClientData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### clientId

```ts
clientId: ClientId;
```

The client ID.

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/clients/{clientId}";
```

---

## Type Alias: AssignRoleToClientError


```ts
type AssignRoleToClientError =
  AssignRoleToClientErrors[keyof AssignRoleToClientErrors];
```

---

## Type Alias: AssignRoleToClientErrors


```ts
type AssignRoleToClientErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role with the given ID was not found.

---

### 409

```ts
409: ProblemDetail;
```

The role was already assigned to the client with the given ID.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignRoleToClientResponse


```ts
type AssignRoleToClientResponse =
  AssignRoleToClientResponses[keyof AssignRoleToClientResponses];
```

---

## Type Alias: AssignRoleToClientResponses


```ts
type AssignRoleToClientResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was assigned successfully to the client.

---

## Type Alias: AssignRoleToGroupData


```ts
type AssignRoleToGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/groups/{groupId}";
```

---

## Type Alias: AssignRoleToGroupError


```ts
type AssignRoleToGroupError =
  AssignRoleToGroupErrors[keyof AssignRoleToGroupErrors];
```

---

## Type Alias: AssignRoleToGroupErrors


```ts
type AssignRoleToGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or group with the given ID was not found.

---

### 409

```ts
409: ProblemDetail;
```

The role is already assigned to the group with the given ID.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignRoleToGroupResponse


```ts
type AssignRoleToGroupResponse =
  AssignRoleToGroupResponses[keyof AssignRoleToGroupResponses];
```

---

## Type Alias: AssignRoleToGroupResponses


```ts
type AssignRoleToGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was assigned successfully to the group.

---

## Type Alias: AssignRoleToMappingRuleData


```ts
type AssignRoleToMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The mapping rule ID.

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: AssignRoleToMappingRuleError


```ts
type AssignRoleToMappingRuleError =
  AssignRoleToMappingRuleErrors[keyof AssignRoleToMappingRuleErrors];
```

---

## Type Alias: AssignRoleToMappingRuleErrors


```ts
type AssignRoleToMappingRuleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or mapping rule with the given ID was not found.

---

### 409

```ts
409: ProblemDetail;
```

The role is already assigned to the mapping rule with the given ID.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignRoleToMappingRuleResponse


```ts
type AssignRoleToMappingRuleResponse =
  AssignRoleToMappingRuleResponses[keyof AssignRoleToMappingRuleResponses];
```

---

## Type Alias: AssignRoleToMappingRuleResponses


```ts
type AssignRoleToMappingRuleResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was assigned successfully to the mapping rule.

---

## Type Alias: AssignRoleToTenantData


```ts
type AssignRoleToTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The unique identifier of the role.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/roles/{roleId}";
```

---

## Type Alias: AssignRoleToTenantError


```ts
type AssignRoleToTenantError =
  AssignRoleToTenantErrors[keyof AssignRoleToTenantErrors];
```

---

## Type Alias: AssignRoleToTenantErrors


```ts
type AssignRoleToTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or role was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignRoleToTenantResponse


```ts
type AssignRoleToTenantResponse =
  AssignRoleToTenantResponses[keyof AssignRoleToTenantResponses];
```

---

## Type Alias: AssignRoleToTenantResponses


```ts
type AssignRoleToTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was successfully assigned to the tenant.

---

## Type Alias: AssignRoleToUserData


```ts
type AssignRoleToUserData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

#### username

```ts
username: Username;
```

The user username.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/users/{username}";
```

---

## Type Alias: AssignRoleToUserError


```ts
type AssignRoleToUserError =
  AssignRoleToUserErrors[keyof AssignRoleToUserErrors];
```

---

## Type Alias: AssignRoleToUserErrors


```ts
type AssignRoleToUserErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or user with the given ID or username was not found.

---

### 409

```ts
409: ProblemDetail;
```

The role is already assigned to the user with the given ID.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignRoleToUserResponse


```ts
type AssignRoleToUserResponse =
  AssignRoleToUserResponses[keyof AssignRoleToUserResponses];
```

---

## Type Alias: AssignRoleToUserResponses


```ts
type AssignRoleToUserResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was assigned successfully to the user.

---

## Type Alias: AssignUserTaskData


```ts
type AssignUserTaskData = object;
```

## Properties

### body

```ts
body: UserTaskAssignmentRequest;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task to assign.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}/assignment";
```

---

## Type Alias: AssignUserTaskError


```ts
type AssignUserTaskError = AssignUserTaskErrors[keyof AssignUserTaskErrors];
```

---

## Type Alias: AssignUserTaskErrors


```ts
type AssignUserTaskErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The user task with the given key was not found.

---

### 409

```ts
409: ProblemDetail;
```

The user task with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response.
Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists

---

## Type Alias: AssignUserTaskResponse


```ts
type AssignUserTaskResponse =
  AssignUserTaskResponses[keyof AssignUserTaskResponses];
```

---

## Type Alias: AssignUserTaskResponses


```ts
type AssignUserTaskResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user task's assignment was adjusted.

---

## Type Alias: AssignUserToGroupData


```ts
type AssignUserToGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

#### username

```ts
username: Username;
```

The user username.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/users/{username}";
```

---

## Type Alias: AssignUserToGroupError


```ts
type AssignUserToGroupError =
  AssignUserToGroupErrors[keyof AssignUserToGroupErrors];
```

---

## Type Alias: AssignUserToGroupErrors


```ts
type AssignUserToGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group or user with the given ID or username was not found.

---

### 409

```ts
409: ProblemDetail;
```

The user with the given ID is already assigned to the group.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignUserToGroupResponse


```ts
type AssignUserToGroupResponse =
  AssignUserToGroupResponses[keyof AssignUserToGroupResponses];
```

---

## Type Alias: AssignUserToGroupResponses


```ts
type AssignUserToGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user was assigned successfully to the group.

---

## Type Alias: AssignUserToTenantData


```ts
type AssignUserToTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

#### username

```ts
username: Username;
```

The unique identifier of the user.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/users/{username}";
```

---

## Type Alias: AssignUserToTenantError


```ts
type AssignUserToTenantError =
  AssignUserToTenantErrors[keyof AssignUserToTenantErrors];
```

---

## Type Alias: AssignUserToTenantErrors


```ts
type AssignUserToTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or user was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: AssignUserToTenantResponse


```ts
type AssignUserToTenantResponse =
  AssignUserToTenantResponses[keyof AssignUserToTenantResponses];
```

---

## Type Alias: AssignUserToTenantResponses


```ts
type AssignUserToTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user was successfully assigned to the tenant.

---

## Type Alias: AuditLogActorTypeEnum


```ts
type AuditLogActorTypeEnum =
  (typeof AuditLogActorTypeEnum)[keyof typeof AuditLogActorTypeEnum];
```

The type of actor who performed the operation.

---

## Type Alias: AuditLogActorTypeExactMatch


```ts
type AuditLogActorTypeExactMatch = AuditLogActorTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: AuditLogActorTypeFilterProperty


```ts
type AuditLogActorTypeFilterProperty =
  AuditLogActorTypeExactMatch | AdvancedActorTypeFilter;
```

AuditLogActorTypeEnum property with full advanced search capabilities.

---

## Type Alias: AuditLogCategoryEnum


```ts
type AuditLogCategoryEnum =
  (typeof AuditLogCategoryEnum)[keyof typeof AuditLogCategoryEnum];
```

The category of the audit log operation.

---

## Type Alias: AuditLogEntityKey


```ts
type AuditLogEntityKey = CamundaKey<"AuditLogEntityKey">;
```

System-generated entity key for an audit log entry.

---

## Type Alias: AuditLogEntityKeyExactMatch


```ts
type AuditLogEntityKeyExactMatch = AuditLogEntityKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: AuditLogEntityKeyFilterProperty


```ts
type AuditLogEntityKeyFilterProperty =
  AuditLogEntityKeyExactMatch | AdvancedAuditLogEntityKeyFilter;
```

EntityKey property with full advanced search capabilities.

---

## Type Alias: AuditLogEntityTypeEnum


```ts
type AuditLogEntityTypeEnum =
  (typeof AuditLogEntityTypeEnum)[keyof typeof AuditLogEntityTypeEnum];
```

The type of entity affected by the operation.

---

## Type Alias: AuditLogFilter


```ts
type AuditLogFilter = object;
```

Audit log filter request

## Properties

### actorId?

```ts
optional actorId?: StringFilterProperty;
```

The actor ID search filter.

---

### actorType?

```ts
optional actorType?: AuditLogActorTypeFilterProperty;
```

The actor type search filter.

---

### agentElementId?

```ts
optional agentElementId?: StringFilterProperty;
```

The agent element ID search filter.

---

### auditLogKey?

```ts
optional auditLogKey?: AuditLogKeyFilterProperty;
```

The audit log key search filter.

---

### batchOperationType?

```ts
optional batchOperationType?: BatchOperationTypeFilterProperty;
```

The batch operation type search filter.

---

### category?

```ts
optional category?: CategoryFilterProperty;
```

The category search filter.

---

### decisionDefinitionId?

```ts
optional decisionDefinitionId?: StringFilterProperty;
```

The decision definition ID search filter.

---

### decisionDefinitionKey?

```ts
optional decisionDefinitionKey?: DecisionDefinitionKeyFilterProperty;
```

The decision definition key search filter.

---

### decisionEvaluationKey?

```ts
optional decisionEvaluationKey?: DecisionEvaluationKeyFilterProperty;
```

The decision evaluation key search filter.

---

### decisionRequirementsId?

```ts
optional decisionRequirementsId?: StringFilterProperty;
```

The decision requirements ID search filter.

---

### decisionRequirementsKey?

```ts
optional decisionRequirementsKey?: DecisionRequirementsKeyFilterProperty;
```

The decision requirements key search filter.

---

### deploymentKey?

```ts
optional deploymentKey?: DeploymentKeyFilterProperty;
```

The deployment key search filter.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The element instance key search filter.

---

### entityDescription?

```ts
optional entityDescription?: StringFilterProperty;
```

The entity description filter.

---

### entityKey?

```ts
optional entityKey?: AuditLogEntityKeyFilterProperty;
```

The entity key search filter.

---

### entityType?

```ts
optional entityType?: EntityTypeFilterProperty;
```

The entity type search filter.

---

### formKey?

```ts
optional formKey?: FormKeyFilterProperty;
```

The form key search filter.

---

### inboundChannelToolName?

```ts
optional inboundChannelToolName?: StringFilterProperty;
```

The inbound channel tool name search filter.

---

### inboundChannelType?

```ts
optional inboundChannelType?: StringFilterProperty;
```

The inbound channel type search filter (e.g. MCP).

---

### jobKey?

```ts
optional jobKey?: JobKeyFilterProperty;
```

The job key search filter.

---

### operationType?

```ts
optional operationType?: OperationTypeFilterProperty;
```

The operation type search filter.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The process definition ID search filter.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The process definition key search filter.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The process instance key search filter.

---

### relatedEntityKey?

```ts
optional relatedEntityKey?: AuditLogEntityKeyFilterProperty;
```

The related entity key search filter.

---

### relatedEntityType?

```ts
optional relatedEntityType?: EntityTypeFilterProperty;
```

The related entity type search filter.

---

### resourceKey?

```ts
optional resourceKey?: ResourceKeyFilterProperty;
```

The resource key search filter.

---

### result?

```ts
optional result?: AuditLogResultFilterProperty;
```

The result search filter.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The tenant ID search filter.

---

### timestamp?

```ts
optional timestamp?: DateTimeFilterProperty;
```

The timestamp search filter.

---

### userTaskKey?

```ts
optional userTaskKey?: BasicStringFilterProperty;
```

The user task key search filter.

---

## Type Alias: AuditLogKey


```ts
type AuditLogKey = CamundaKey<"AuditLogKey">;
```

System-generated key for an audit log entry.

---

## Type Alias: AuditLogKeyExactMatch


```ts
type AuditLogKeyExactMatch = AuditLogKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: AuditLogKeyFilterProperty


```ts
type AuditLogKeyFilterProperty =
  AuditLogKeyExactMatch | AdvancedAuditLogKeyFilter;
```

AuditLogKey property with full advanced search capabilities.

---

## Type Alias: AuditLogOperationTypeEnum


```ts
type AuditLogOperationTypeEnum =
  (typeof AuditLogOperationTypeEnum)[keyof typeof AuditLogOperationTypeEnum];
```

The type of operation performed.

---

## Type Alias: AuditLogResult


```ts
type AuditLogResult = object;
```

Audit log item.

## Properties

### actorId

```ts
actorId: string | null;
```

The ID of the actor who performed the operation.

---

### actorType

```ts
actorType: AuditLogActorTypeEnum | null;
```

The type of the actor who performed the operation.

---

### agentElementId

```ts
agentElementId: string | null;
```

The element ID of the agent that performed the operation (e.g. ad-hoc subprocess element ID).

---

### auditLogKey

```ts
auditLogKey: AuditLogKey;
```

The unique key of the audit log entry.

---

### batchOperationKey

```ts
batchOperationKey: BatchOperationKey | null;
```

Key of the batch operation.

---

### batchOperationType

```ts
batchOperationType: BatchOperationTypeEnum | null;
```

The type of batch operation performed, if this is part of a batch.

---

### category

```ts
category: AuditLogCategoryEnum;
```

---

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId | null;
```

The decision definition ID.

---

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey | null;
```

The key of the decision definition.

---

### decisionEvaluationKey

```ts
decisionEvaluationKey: DecisionEvaluationKey | null;
```

The key of the decision evaluation.

---

### decisionRequirementsId

```ts
decisionRequirementsId: string | null;
```

The decision requirements ID.

---

### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey | null;
```

The assigned key of the decision requirements.

---

### deploymentKey

```ts
deploymentKey: DeploymentKey | null;
```

The key of the deployment.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey | null;
```

The key of the element instance.

---

### entityDescription

```ts
entityDescription: string | null;
```

Additional description of the entity affected by the operation.
For example, for variable operations, this will contain the variable name.

---

### entityKey

```ts
entityKey: AuditLogEntityKey;
```

---

### entityType

```ts
entityType: AuditLogEntityTypeEnum;
```

---

### formKey

```ts
formKey: FormKey | null;
```

The key of the form.

---

### inboundChannelToolName

```ts
inboundChannelToolName: string | null;
```

The tool name of the inbound channel (e.g. the MCP tool that triggered the operation).

---

### inboundChannelType

```ts
inboundChannelType: string | null;
```

The type of the inbound channel that triggered the operation (e.g. MCP).

---

### jobKey

```ts
jobKey: JobKey | null;
```

The key of the job.

---

### operationType

```ts
operationType: AuditLogOperationTypeEnum;
```

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId | null;
```

The process definition ID.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey | null;
```

The key of the process definition.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey | null;
```

The key of the process instance.

---

### relatedEntityKey

```ts
relatedEntityKey: AuditLogEntityKey | null;
```

The key of the related entity. The content depends on the operation type and entity type.
For example, for authorization operations, this will contain the ID of the owner (e.g., user or group) the authorization belongs to.

---

### relatedEntityType

```ts
relatedEntityType: AuditLogEntityTypeEnum | null;
```

The type of the related entity. The content depends on the operation type and entity type.
For example, for authorization operations, this will contain the type of the owner (e.g., USER or GROUP) the authorization belongs to.

---

### resourceKey

```ts
resourceKey: ResourceKey | null;
```

The system-assigned key for this resource.

---

### result

```ts
result: AuditLogResultEnum;
```

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### tenantId

```ts
tenantId: TenantId | null;
```

The tenant ID of the audit log.

---

### timestamp

```ts
timestamp: string;
```

The timestamp when the operation occurred.

---

### userTaskKey

```ts
userTaskKey: UserTaskKey | null;
```

The key of the user task.

---

## Type Alias: AuditLogResultEnum


```ts
type AuditLogResultEnum =
  (typeof AuditLogResultEnum)[keyof typeof AuditLogResultEnum];
```

The result status of the operation.

---

## Type Alias: AuditLogResultExactMatch


```ts
type AuditLogResultExactMatch = AuditLogResultEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: AuditLogResultFilterProperty


```ts
type AuditLogResultFilterProperty =
  AuditLogResultExactMatch | AdvancedResultFilter;
```

AuditLogResultEnum property with full advanced search capabilities.

---

## Type Alias: AuditLogSearchQueryRequest


```ts
type AuditLogSearchQueryRequest = SearchQueryRequest & object;
```

Audit log search request.

## Type Declaration

### filter?

```ts
optional filter?: AuditLogFilter;
```

The audit log search filters.

### sort?

```ts
optional sort?: AuditLogSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: AuditLogSearchQueryResult


```ts
type AuditLogSearchQueryResult = SearchQueryResponse & object;
```

Audit log search response.

## Type Declaration

### items

```ts
items: AuditLogResult[];
```

The matching audit logs.

---

## Type Alias: AuditLogSearchQuerySortRequest


```ts
type AuditLogSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "actorId"
  | "actorType"
  | "auditLogKey"
  | "batchOperationKey"
  | "batchOperationType"
  | "category"
  | "decisionDefinitionId"
  | "decisionDefinitionKey"
  | "decisionEvaluationKey"
  | "decisionRequirementsId"
  | "decisionRequirementsKey"
  | "elementInstanceKey"
  | "entityKey"
  | "entityType"
  | "jobKey"
  | "operationType"
  | "processDefinitionId"
  | "processDefinitionKey"
  | "processInstanceKey"
  | "inboundChannelType"
  | "inboundChannelToolName"
  | "result"
  | "tenantId"
  | "timestamp"
  | "userTaskKey";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: AuthStrategy


```ts
type AuthStrategy = "NONE" | "OAUTH" | "BASIC";
```

---

## Type Alias: AuthenticationConfigurationResponse


```ts
type AuthenticationConfigurationResponse = object;
```

Configuration for authentication and session management.

## Properties

### canLogout

```ts
canLogout: boolean;
```

Whether users can log out (false for SaaS deployments).

---

### isLoginDelegated

```ts
isLoginDelegated: boolean;
```

Whether login is delegated to an external identity provider.

---

## Type Alias: AuthorizationCreateResult


```ts
type AuthorizationCreateResult = object;
```

## Properties

### authorizationKey

```ts
authorizationKey: AuthorizationKey;
```

The key of the created authorization.

---

## Type Alias: AuthorizationFilter


```ts
type AuthorizationFilter = object;
```

Authorization search filter.

## Properties

### ownerId?

```ts
optional ownerId?: string;
```

The ID of the owner of permissions.

---

### ownerType?

```ts
optional ownerType?: OwnerTypeEnum;
```

---

### resourceIds?

```ts
optional resourceIds?: string[];
```

The IDs of the resource to search permissions for.

---

### resourcePropertyNames?

```ts
optional resourcePropertyNames?: string[];
```

The names of the resource properties to search permissions for.

---

### resourceType?

```ts
optional resourceType?: ResourceTypeEnum;
```

The type of resource to search permissions for.

---

## Type Alias: AuthorizationIdBasedRequest


```ts
type AuthorizationIdBasedRequest = object;
```

## Properties

### ownerId

```ts
ownerId: string;
```

The ID of the owner of the permissions.

---

### ownerType

```ts
ownerType: OwnerTypeEnum;
```

---

### permissionTypes

```ts
permissionTypes: PermissionTypeEnum[];
```

The permission types to add.

---

### resourceId

```ts
resourceId: string;
```

The ID of the resource to add permissions to.

---

### resourceType

```ts
resourceType: ResourceTypeEnum;
```

The type of resource to add permissions to.

---

## Type Alias: AuthorizationKey


```ts
type AuthorizationKey = CamundaKey<"AuthorizationKey">;
```

System-generated key for an authorization.

---

## Type Alias: AuthorizationPropertyBasedRequest


```ts
type AuthorizationPropertyBasedRequest = object;
```

## Properties

### ownerId

```ts
ownerId: string;
```

The ID of the owner of the permissions.

---

### ownerType

```ts
ownerType: OwnerTypeEnum;
```

---

### permissionTypes

```ts
permissionTypes: PermissionTypeEnum[];
```

The permission types to add.

---

### resourcePropertyName

```ts
resourcePropertyName: string;
```

The name of the resource property on which this authorization is based.

---

### resourceType

```ts
resourceType: ResourceTypeEnum;
```

The type of resource to add permissions to.

---

## Type Alias: AuthorizationRequest


```ts
type AuthorizationRequest =
  AuthorizationIdBasedRequest | AuthorizationPropertyBasedRequest;
```

Defines an authorization request.
Either an id-based or a property-based authorization can be provided.

---

## Type Alias: AuthorizationResult


```ts
type AuthorizationResult = object;
```

## Properties

### authorizationKey

```ts
authorizationKey: AuthorizationKey;
```

The key of the authorization.

---

### ownerId

```ts
ownerId: string;
```

The ID of the owner of permissions.

---

### ownerType

```ts
ownerType: OwnerTypeEnum;
```

---

### permissionTypes

```ts
permissionTypes: PermissionTypeEnum[];
```

Specifies the types of the permissions.

---

### resourceId

```ts
resourceId: string | null;
```

ID of the resource the permission relates to (mutually exclusive with `resourcePropertyName`).

---

### resourcePropertyName

```ts
resourcePropertyName: string | null;
```

The name of the resource property the permission relates to (mutually exclusive with `resourceId`).

---

### resourceType

```ts
resourceType: ResourceTypeEnum;
```

The type of resource that the permissions relate to.

---

## Type Alias: AuthorizationSearchQuery


```ts
type AuthorizationSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: AuthorizationFilter;
```

The authorization search filters.

### sort?

```ts
optional sort?: AuthorizationSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: AuthorizationSearchQuerySortRequest


```ts
type AuthorizationSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "ownerId"
  | "ownerType"
  | "resourceId"
  | "resourcePropertyName"
  | "resourceType";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: AuthorizationSearchResult


```ts
type AuthorizationSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: AuthorizationResult[];
```

The matching authorizations.

---

## Type Alias: BackpressureSeverity


```ts
type BackpressureSeverity = "healthy" | "soft" | "severe";
```

---

## Type Alias: BaseProcessInstanceFilterFields


```ts
type BaseProcessInstanceFilterFields = object;
```

Base process instance search filter.

## Properties

### ~~batchOperationId?~~

```ts
optional batchOperationId?: StringFilterProperty;
```

The batch operation id.
**Deprecated**: Use `batchOperationKey` instead. This field will be removed in a future release. If both `batchOperationId` and `batchOperationKey` are provided, the request will be rejected with a 400 error.

#### Deprecated

---

### batchOperationKey?

```ts
optional batchOperationKey?: StringFilterProperty;
```

The batch operation key.

---

### businessId?

```ts
optional businessId?: StringFilterProperty;
```

The business id associated with the process instance.

---

### elementId?

```ts
optional elementId?: StringFilterProperty;
```

The element id associated with the process instance.

---

### elementInstanceState?

```ts
optional elementInstanceState?: ElementInstanceStateFilterProperty;
```

The state of the element instances associated with the process instance.

---

### endDate?

```ts
optional endDate?: DateTimeFilterProperty;
```

The end date.

---

### errorMessage?

```ts
optional errorMessage?: StringFilterProperty;
```

The error message related to the process.

---

### hasElementInstanceIncident?

```ts
optional hasElementInstanceIncident?: boolean;
```

Whether the element instance has an incident or not.

---

### hasIncident?

```ts
optional hasIncident?: boolean;
```

Whether this process instance has a related incident or not.

---

### hasRetriesLeft?

```ts
optional hasRetriesLeft?: boolean;
```

Whether the process has failed jobs with retries left.

---

### incidentErrorHashCode?

```ts
optional incidentErrorHashCode?: IntegerFilterProperty;
```

The incident error hash code, associated with this process.

---

### parentElementInstanceKey?

```ts
optional parentElementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The parent element instance key.

---

### parentProcessInstanceKey?

```ts
optional parentProcessInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The parent process instance key.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The key of this process instance.

---

### startDate?

```ts
optional startDate?: DateTimeFilterProperty;
```

The start date.

---

### state?

```ts
optional state?: ProcessInstanceStateFilterProperty;
```

The process instance state.

---

### tags?

```ts
optional tags?: TagSet;
```

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The tenant id.

---

### variables?

```ts
optional variables?: VariableValueFilterProperty[];
```

The process instance variables.

---

## Type Alias: BaseWaitStateDetails


```ts
type BaseWaitStateDetails = object;
```

Common fields shared by all wait-state details variants.

## Properties

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: BasicStringFilter


```ts
type BasicStringFilter = object;
```

Advanced filter

Basic advanced string filter.

## Properties

### $eq?

```ts
optional $eq?: string;
```

Checks for equality with the provided value.

---

### $exists?

```ts
optional $exists?: boolean;
```

Checks if the current property exists.

---

### $in?

```ts
optional $in?: string[];
```

Checks if the property matches any of the provided values.

---

### $neq?

```ts
optional $neq?: string;
```

Checks for inequality with the provided value.

---

### $notIn?

```ts
optional $notIn?: string[];
```

Checks if the property matches none of the provided values.

---

## Type Alias: BasicStringFilterProperty


```ts
type BasicStringFilterProperty = string | BasicStringFilter;
```

String property with basic advanced search capabilities.

---

## Type Alias: BatchOperationCreatedResult


```ts
type BatchOperationCreatedResult = object;
```

The created batch operation.

## Properties

### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

Key of the batch operation.

---

### batchOperationType

```ts
batchOperationType: BatchOperationTypeEnum;
```

---

## Type Alias: BatchOperationError


```ts
type BatchOperationError = object;
```

## Properties

### message

```ts
message: string;
```

The error message that occurred during the batch operation.

---

### partitionId

```ts
partitionId: number;
```

The partition ID where the error occurred.

---

### type

```ts
type: "QUERY_FAILED" | "RESULT_BUFFER_SIZE_EXCEEDED";
```

The type of the error that occurred during the batch operation.

---

## Type Alias: BatchOperationFilter


```ts
type BatchOperationFilter = object;
```

Batch operation filter request.

## Properties

### actorId?

```ts
optional actorId?: StringFilterProperty;
```

The ID of the actor who performed the operation.

---

### actorType?

```ts
optional actorType?: AuditLogActorTypeEnum;
```

The type of the actor who performed the operation.

---

### batchOperationKey?

```ts
optional batchOperationKey?: BasicStringFilterProperty;
```

The key (or operate legacy ID) of the batch operation.

---

### operationType?

```ts
optional operationType?: BatchOperationTypeFilterProperty;
```

The type of the batch operation.

---

### state?

```ts
optional state?: BatchOperationStateFilterProperty;
```

The state of the batch operation.

---

## Type Alias: BatchOperationItemFilter


```ts
type BatchOperationItemFilter = object;
```

Batch operation item filter request.

## Properties

### batchOperationKey?

```ts
optional batchOperationKey?: BasicStringFilterProperty;
```

The key (or operate legacy ID) of the batch operation.

---

### itemKey?

```ts
optional itemKey?: BasicStringFilterProperty;
```

The key of the item, e.g. a process instance key.

---

### operationType?

```ts
optional operationType?: BatchOperationTypeFilterProperty;
```

The type of the batch operation.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The process instance key of the processed item.

---

### state?

```ts
optional state?: BatchOperationItemStateFilterProperty;
```

The state of the batch operation.

---

## Type Alias: BatchOperationItemResponse


```ts
type BatchOperationItemResponse = object;
```

## Properties

### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

The key (or operate legacy ID) of the batch operation.

---

### errorMessage

```ts
errorMessage: string | null;
```

The error message from the engine in case of a failed operation.

---

### itemKey

```ts
itemKey: string;
```

Key of the item, e.g. a process instance key.

---

### operationType

```ts
operationType: BatchOperationTypeEnum;
```

---

### processedDate

```ts
processedDate: string | null;
```

The date this item was processed.
This is `null` if the item has not yet been processed.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey | null;
```

The process instance key of the processed item. Null for batch-op types whose targets
are not process instances (e.g. DELETE_DECISION_INSTANCE, DELETE_DECISION_DEFINITION,
DELETE_PROCESS_DEFINITION).

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### state

```ts
state: "ACTIVE" | "COMPLETED" | "SKIPPED" | "CANCELED" | "FAILED";
```

State of the item.

---

## Type Alias: BatchOperationItemSearchQuery


```ts
type BatchOperationItemSearchQuery = SearchQueryRequest & object;
```

Batch operation item search request.

## Type Declaration

### filter?

```ts
optional filter?: BatchOperationItemFilter;
```

The batch operation item search filters.

### sort?

```ts
optional sort?: BatchOperationItemSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: BatchOperationItemSearchQueryResult


```ts
type BatchOperationItemSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: BatchOperationItemResponse[];
```

The matching batch operation items.

---

## Type Alias: BatchOperationItemSearchQuerySortRequest


```ts
type BatchOperationItemSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "batchOperationKey"
  | "itemKey"
  | "processInstanceKey"
  | "processedDate"
  | "state";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: BatchOperationItemStateEnum


```ts
type BatchOperationItemStateEnum =
  (typeof BatchOperationItemStateEnum)[keyof typeof BatchOperationItemStateEnum];
```

The batch operation item state.

---

## Type Alias: BatchOperationItemStateExactMatch


```ts
type BatchOperationItemStateExactMatch = BatchOperationItemStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: BatchOperationItemStateFilterProperty


```ts
type BatchOperationItemStateFilterProperty =
  BatchOperationItemStateExactMatch | AdvancedBatchOperationItemStateFilter;
```

BatchOperationItemStateEnum property with full advanced search capabilities.

---

## Type Alias: BatchOperationKey


```ts
type BatchOperationKey = CamundaKey<"BatchOperationKey">;
```

System-generated key for an batch operation.

---

## Type Alias: BatchOperationResponse


```ts
type BatchOperationResponse = object;
```

## Properties

### actorId

```ts
actorId: string | null;
```

The ID of the actor who performed the operation. Available for batch operations created since 8.9.

---

### actorType

```ts
actorType: AuditLogActorTypeEnum | null;
```

The type of the actor who performed the operation.
This is `null` if the batch operation was created before 8.9,
or if the actor information is not available.

---

### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

Key or (Operate Legacy ID = UUID) of the batch operation.

---

### batchOperationType

```ts
batchOperationType: BatchOperationTypeEnum;
```

---

### endDate

```ts
endDate: string | null;
```

The end date of the batch operation.
This is `null` if the batch operation is still running.

---

### errors

```ts
errors: BatchOperationError[];
```

The errors that occurred per partition during the batch operation.

---

### operationsCompletedCount

```ts
operationsCompletedCount: number;
```

The number of successfully completed tasks.

---

### operationsFailedCount

```ts
operationsFailedCount: number;
```

The number of items which failed during execution of the batch operation. (e.g. because they are rejected by the Zeebe engine).

---

### operationsTotalCount

```ts
operationsTotalCount: number;
```

The total number of items contained in this batch operation.

---

### startDate

```ts
startDate: string | null;
```

The start date of the batch operation.
This is `null` if the batch operation has not yet started.

---

### state

```ts
state: BatchOperationStateEnum;
```

---

## Type Alias: BatchOperationSearchQuery


```ts
type BatchOperationSearchQuery = SearchQueryRequest & object;
```

Batch operation search request.

## Type Declaration

### filter?

```ts
optional filter?: BatchOperationFilter;
```

The batch operation search filters.

### sort?

```ts
optional sort?: BatchOperationSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: BatchOperationSearchQueryResult


```ts
type BatchOperationSearchQueryResult = SearchQueryResponse & object;
```

The batch operation search query result.

## Type Declaration

### items

```ts
items: BatchOperationResponse[];
```

The matching batch operations.

---

## Type Alias: BatchOperationSearchQuerySortRequest


```ts
type BatchOperationSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "batchOperationKey"
  | "operationType"
  | "state"
  | "startDate"
  | "endDate"
  | "actorType"
  | "actorId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: BatchOperationStateEnum


```ts
type BatchOperationStateEnum =
  (typeof BatchOperationStateEnum)[keyof typeof BatchOperationStateEnum];
```

The batch operation state.

---

## Type Alias: BatchOperationStateExactMatch


```ts
type BatchOperationStateExactMatch = BatchOperationStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: BatchOperationStateFilterProperty


```ts
type BatchOperationStateFilterProperty =
  BatchOperationStateExactMatch | AdvancedBatchOperationStateFilter;
```

BatchOperationStateEnum property with full advanced search capabilities.

---

## Type Alias: BatchOperationTypeEnum


```ts
type BatchOperationTypeEnum =
  (typeof BatchOperationTypeEnum)[keyof typeof BatchOperationTypeEnum];
```

The type of the batch operation.

---

## Type Alias: BatchOperationTypeExactMatch


```ts
type BatchOperationTypeExactMatch = BatchOperationTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: BatchOperationTypeFilterProperty


```ts
type BatchOperationTypeFilterProperty =
  BatchOperationTypeExactMatch | AdvancedBatchOperationTypeFilter;
```

BatchOperationTypeEnum property with full advanced search capabilities.

---

## Type Alias: BroadcastSignalData


```ts
type BroadcastSignalData = object;
```

## Properties

### body

```ts
body: SignalBroadcastRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/signals/broadcast";
```

---

## Type Alias: BroadcastSignalError


```ts
type BroadcastSignalError = BroadcastSignalErrors[keyof BroadcastSignalErrors];
```

---

## Type Alias: BroadcastSignalErrors


```ts
type BroadcastSignalErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The signal is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: BroadcastSignalResponse


```ts
type BroadcastSignalResponse =
  BroadcastSignalResponses[keyof BroadcastSignalResponses];
```

---

## Type Alias: BroadcastSignalResponses


```ts
type BroadcastSignalResponses = object;
```

## Properties

### 200

```ts
200: SignalBroadcastResult;
```

The signal was broadcast.

---

## Type Alias: BrokerInfo


```ts
type BrokerInfo = object;
```

Provides information on a broker node.

## Properties

### host

```ts
host: string;
```

The hostname for reaching the broker.

---

### nodeId

```ts
nodeId: number;
```

The unique (within a cluster) node ID for the broker.

---

### partitions

```ts
partitions: Partition[];
```

A list of partitions managed or replicated on this broker.

---

### port

```ts
port: number;
```

The port for reaching the broker.

---

### version

```ts
version: string;
```

The broker version.

---

## Type Alias: BusinessId


```ts
type BusinessId = CamundaKey<"BusinessId">;
```

An optional, user-defined string identifier that identifies the process instance
within the scope of a process definition (scoped by tenant). If provided and uniqueness
enforcement is enabled, the engine will reject creation if another root process instance
with the same business id is already active for the same process definition.
Note that any active child process instances with the same business id are not taken into account.

---

## Type Alias: CamundaClientLoose


```ts
type CamundaClientLoose = ReturnType<typeof createCamundaClientLoose>;
```

---

## Type Alias: CamundaFpClient


```ts
type CamundaFpClient = Fpify<CamundaClient>;
```

---

## Type Alias: CamundaKey<T>

# Type Alias: CamundaKey\<T\>

```ts
type CamundaKey<T> = string & object;
```

## Type Declaration

### \_\_brand

```ts
readonly __brand: T;
```

## Type Parameters

### T

`T` _extends_ `string` = `string`

---

## Type Alias: CamundaResultClient


```ts
type CamundaResultClient = object & {
  [K in keyof CamundaClient]: CamundaClient[K] extends (
    a: infer A
  ) => Promise<infer R>
    ? (a: A) => Promise<Result<R>>
    : CamundaClient[K] extends (a: infer A) => any
      ? (
          a: A
        ) =>
          | Promise<Result<ReturnType<CamundaClient[K]>>>
          | ReturnType<CamundaClient[K]>
      : CamundaClient[K];
};
```

## Type Declaration

### inner

```ts
inner: CamundaClient;
```

---

## Type Alias: CamundaUserResult


```ts
type CamundaUserResult = object;
```

## Properties

### authorizedComponents

```ts
authorizedComponents: string[];
```

The web components the user is authorized to use.

---

### c8Links

```ts
c8Links: object;
```

The links to the components in the C8 stack.

#### Index Signature

```ts
[key: string]: string
```

---

### canLogout

```ts
canLogout: boolean;
```

Flag for understanding if the user is able to perform logout.

---

### displayName

```ts
displayName: string | null;
```

The display name of the user.

---

### email

```ts
email: string | null;
```

The email of the user.

---

### groups

```ts
groups: string[];
```

The groups assigned to the user.

---

### roles

```ts
roles: string[];
```

The roles assigned to the user.

---

### salesPlanType

```ts
salesPlanType: string | null;
```

The plan of the user.

---

### tenants

```ts
tenants: TenantResult[];
```

The tenants the user is a member of.

---

### username

```ts
username: Username;
```

The username of the user.

---

## Type Alias: CancelBatchOperationData


```ts
type CancelBatchOperationData = object;
```

## Properties

### body?

```ts
optional body?: unknown;
```

---

### path

```ts
path: object;
```

#### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

The key (or operate legacy ID) of the batch operation.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/batch-operations/{batchOperationKey}/cancellation";
```

---

## Type Alias: CancelBatchOperationError


```ts
type CancelBatchOperationError =
  CancelBatchOperationErrors[keyof CancelBatchOperationErrors];
```

---

## Type Alias: CancelBatchOperationErrors


```ts
type CancelBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The batch operation was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: CancelBatchOperationResponse


```ts
type CancelBatchOperationResponse =
  CancelBatchOperationResponses[keyof CancelBatchOperationResponses];
```

---

## Type Alias: CancelBatchOperationResponses


```ts
type CancelBatchOperationResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The batch operation cancel request was created.

---

## Type Alias: CancelProcessInstanceData


```ts
type CancelProcessInstanceData = object;
```

## Properties

### body?

```ts
optional body?: CancelProcessInstanceRequest;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance to cancel.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/cancellation";
```

---

## Type Alias: CancelProcessInstanceError


```ts
type CancelProcessInstanceError =
  CancelProcessInstanceErrors[keyof CancelProcessInstanceErrors];
```

---

## Type Alias: CancelProcessInstanceErrors


```ts
type CancelProcessInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The process instance is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response.
Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists

---

## Type Alias: CancelProcessInstanceRequest


```ts
type CancelProcessInstanceRequest = {
  operationReference?: OperationReference;
} | null;
```

---

## Type Alias: CancelProcessInstanceResponse


```ts
type CancelProcessInstanceResponse =
  CancelProcessInstanceResponses[keyof CancelProcessInstanceResponses];
```

---

## Type Alias: CancelProcessInstanceResponses


```ts
type CancelProcessInstanceResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The process instance is canceled.

---

## Type Alias: CancelProcessInstancesBatchOperationData


```ts
type CancelProcessInstancesBatchOperationData = object;
```

## Properties

### body

```ts
body: ProcessInstanceCancellationBatchOperationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/cancellation";
```

---

## Type Alias: CancelProcessInstancesBatchOperationError


```ts
type CancelProcessInstancesBatchOperationError =
  CancelProcessInstancesBatchOperationErrors[keyof CancelProcessInstancesBatchOperationErrors];
```

---

## Type Alias: CancelProcessInstancesBatchOperationErrors


```ts
type CancelProcessInstancesBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The process instance batch operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: CancelProcessInstancesBatchOperationResponse


```ts
type CancelProcessInstancesBatchOperationResponse =
  CancelProcessInstancesBatchOperationResponses[keyof CancelProcessInstancesBatchOperationResponses];
```

---

## Type Alias: CancelProcessInstancesBatchOperationResponses


```ts
type CancelProcessInstancesBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request was created.

---

## Type Alias: CategoryExactMatch


```ts
type CategoryExactMatch = AuditLogCategoryEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: CategoryFilterProperty


```ts
type CategoryFilterProperty = CategoryExactMatch | AdvancedCategoryFilter;
```

AuditLogCategoryEnum property with full advanced search capabilities.

---

## Type Alias: Changeset


```ts
type Changeset = {
  [key: string]: unknown;
  candidateGroups?: string[] | null;
  candidateUsers?: string[] | null;
  dueDate?: string | null;
  followUpDate?: string | null;
  priority?: number | null;
} | null;
```

JSON object with changed task attribute values.

The following attributes can be adjusted with this endpoint, additional attributes
will be ignored:

- `candidateGroups` - reset by providing an empty list
- `candidateUsers` - reset by providing an empty list
- `dueDate` - reset by providing an empty String
- `followUpDate` - reset by providing an empty String
- `priority` - minimum 0, maximum 100, default 50

Providing any of those attributes with a `null` value or omitting it preserves
the persisted attribute's value.

The assignee cannot be adjusted with this endpoint, use the Assign task endpoint.
This ensures correct event emission for assignee changes.

## Union Members

### Type Literal

```ts
{
[key: string]: unknown;
  candidateGroups?: string[] | null;
  candidateUsers?: string[] | null;
  dueDate?: string | null;
  followUpDate?: string | null;
  priority?: number | null;
}
```

### Index Signature

```ts
[key: string]: unknown
```

#### candidateGroups?

```ts
optional candidateGroups?: string[] | null;
```

The list of candidate groups of the task. Reset by providing an empty list.

#### candidateUsers?

```ts
optional candidateUsers?: string[] | null;
```

The list of candidate users of the task. Reset by providing an empty list.

#### dueDate?

```ts
optional dueDate?: string | null;
```

The due date of the task. Reset by providing an empty String.

#### followUpDate?

```ts
optional followUpDate?: string | null;
```

The follow-up date of the task. Reset by providing an empty String.

#### priority?

```ts
optional priority?: number | null;
```

The priority of the task.

---

`null`

---

## Type Alias: ClientId


```ts
type ClientId = CamundaKey<"ClientId">;
```

The unique identifier of an OAuth client.
Minted outside the Camunda REST API: in SaaS by Console, in Self-Managed
with OIDC by the external identity provider (e.g. EntraID, Keycloak,
Okta). In Self-Managed with Basic authentication, machine-to-machine
applications are modelled as users instead — see the user identifier.

---

## Type Alias: ClientOptions


```ts
type ClientOptions = object;
```

## Properties

### baseUrl

```ts
baseUrl: "{schema}://{host}:{port}/v2" | (string & object);
```

---

## Type Alias: ClockPinRequest


```ts
type ClockPinRequest = object;
```

## Properties

### timestamp

```ts
timestamp: number;
```

The exact time in epoch milliseconds to which the clock should be pinned.

---

## Type Alias: CloudConfigurationResponse


```ts
type CloudConfigurationResponse = object;
```

Configuration for SaaS/cloud-specific settings.

## Properties

### stage

```ts
stage: CloudStage | null;
```

The cloud deployment stage.

---

## Type Alias: CloudStage


```ts
type CloudStage = "dev" | "int" | "prod";
```

The cloud deployment stage.

---

## Type Alias: ClusterVariableName


```ts
type ClusterVariableName = CamundaKey<"ClusterVariableName">;
```

The name of a cluster variable. Unique within its scope (global or tenant-specific).

---

## Type Alias: ClusterVariableResult


```ts
type ClusterVariableResult = ClusterVariableResultBase & object;
```

## Type Declaration

### value

```ts
value: string;
```

Full value of this cluster variable.

---

## Type Alias: ClusterVariableResultBase


```ts
type ClusterVariableResultBase = object;
```

Cluster variable response item.

## Properties

### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable. Unique within its scope (global or tenant-specific).

---

### scope

```ts
scope: ClusterVariableScopeEnum;
```

---

### tenantId

```ts
tenantId: string | null;
```

Only provided if the cluster variable scope is TENANT. Null for global scope variables.

---

## Type Alias: ClusterVariableScopeEnum


```ts
type ClusterVariableScopeEnum =
  (typeof ClusterVariableScopeEnum)[keyof typeof ClusterVariableScopeEnum];
```

The scope of a cluster variable.

---

## Type Alias: ClusterVariableScopeExactMatch


```ts
type ClusterVariableScopeExactMatch = ClusterVariableScopeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: ClusterVariableScopeFilterProperty


```ts
type ClusterVariableScopeFilterProperty =
  ClusterVariableScopeExactMatch | AdvancedClusterVariableScopeFilter;
```

ClusterVariableScopeEnum property with full advanced search capabilities.

---

## Type Alias: ClusterVariableSearchQueryFilterRequest


```ts
type ClusterVariableSearchQueryFilterRequest = object;
```

Cluster variable filter request.

## Properties

### isTruncated?

```ts
optional isTruncated?: boolean;
```

Filter cluster variables by truncation status of their stored values. When true, returns only variables whose stored values are truncated (i.e., the value exceeds the storage size limit and is truncated in storage). When false, returns only variables with non-truncated stored values. This filter is based on the underlying storage characteristic, not the response format.

---

### name?

```ts
optional name?: StringFilterProperty;
```

Name of the cluster variable.

---

### scope?

```ts
optional scope?: ClusterVariableScopeFilterProperty;
```

The scope filter for cluster variables.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

Tenant ID of this variable.

---

### value?

```ts
optional value?: StringFilterProperty;
```

The value of the cluster variable.

---

## Type Alias: ClusterVariableSearchQueryRequest


```ts
type ClusterVariableSearchQueryRequest = SearchQueryRequest & object;
```

Cluster variable search query request.

## Type Declaration

### filter?

```ts
optional filter?: ClusterVariableSearchQueryFilterRequest;
```

The cluster variable search filters.

### sort?

```ts
optional sort?: ClusterVariableSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ClusterVariableSearchQueryResult


```ts
type ClusterVariableSearchQueryResult = SearchQueryResponse & object;
```

Cluster variable search query response.

## Type Declaration

### items

```ts
items: ClusterVariableSearchResult[];
```

The matching cluster variables.

---

## Type Alias: ClusterVariableSearchQuerySortRequest


```ts
type ClusterVariableSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "name" | "value" | "tenantId" | "scope";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ClusterVariableSearchResult


```ts
type ClusterVariableSearchResult = ClusterVariableResultBase & object;
```

Cluster variable search response item.

## Type Declaration

### isTruncated

```ts
isTruncated: boolean;
```

Whether the value is truncated or not.

### value

```ts
value: string;
```

Value of this cluster variable. Can be truncated.

---

## Type Alias: CompleteJobData


```ts
type CompleteJobData = object;
```

## Properties

### body?

```ts
optional body?: JobCompletionRequest;
```

---

### path

```ts
path: object;
```

#### jobKey

```ts
jobKey: JobKey;
```

The key of the job to complete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/{jobKey}/completion";
```

---

## Type Alias: CompleteJobError


```ts
type CompleteJobError = CompleteJobErrors[keyof CompleteJobErrors];
```

---

## Type Alias: CompleteJobErrors


```ts
type CompleteJobErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The job with the given key was not found.

---

### 409

```ts
409: ProblemDetail;
```

The job with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CompleteJobResponse


```ts
type CompleteJobResponse = CompleteJobResponses[keyof CompleteJobResponses];
```

---

## Type Alias: CompleteJobResponses


```ts
type CompleteJobResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The job was completed successfully.

---

## Type Alias: CompleteUserTaskData


```ts
type CompleteUserTaskData = object;
```

## Properties

### body?

```ts
optional body?: UserTaskCompletionRequest;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task to complete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}/completion";
```

---

## Type Alias: CompleteUserTaskError


```ts
type CompleteUserTaskError =
  CompleteUserTaskErrors[keyof CompleteUserTaskErrors];
```

---

## Type Alias: CompleteUserTaskErrors


```ts
type CompleteUserTaskErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The user task with the given key was not found.

---

### 409

```ts
409: ProblemDetail;
```

The user task with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response.
Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists

---

## Type Alias: CompleteUserTaskResponse


```ts
type CompleteUserTaskResponse =
  CompleteUserTaskResponses[keyof CompleteUserTaskResponses];
```

---

## Type Alias: CompleteUserTaskResponses


```ts
type CompleteUserTaskResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user task was completed successfully.

---

## Type Alias: ComponentsConfigurationResponse


```ts
type ComponentsConfigurationResponse = object;
```

Configuration for active Camunda components in the deployment.

## Properties

### active

```ts
active: WebappComponent[];
```

List of webapp components whose UI is enabled in this deployment.

---

## Type Alias: ConditionWaitStateDetails


```ts
type ConditionWaitStateDetails = BaseWaitStateDetails & object;
```

## Type Declaration

### events

```ts
events: ("create" | "update")[];
```

The variable events that trigger condition re-evaluation. Empty means all events.

### expression

```ts
expression: string;
```

The condition expression that must evaluate to true to proceed.

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: ConditionalEvaluationInstruction


```ts
type ConditionalEvaluationInstruction = object;
```

## Properties

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKey;
```

Used to evaluate root-level conditional start events of the process definition with the given key.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

Used to evaluate root-level conditional start events for a tenant with the given ID.
This will only evaluate root-level conditional start events of process definitions which belong to the tenant.

---

### variables

```ts
variables: object;
```

JSON object representing the variables to use for evaluation of the conditions and to pass to the process instances that have been triggered.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: ConditionalEvaluationKey


```ts
type ConditionalEvaluationKey = CamundaKey<"ConditionalEvaluationKey">;
```

System-generated key for a conditional evaluation.

---

## Type Alias: CorrelateMessageData


```ts
type CorrelateMessageData = object;
```

## Properties

### body

```ts
body: MessageCorrelationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/messages/correlation";
```

---

## Type Alias: CorrelateMessageError


```ts
type CorrelateMessageError =
  CorrelateMessageErrors[keyof CorrelateMessageErrors];
```

---

## Type Alias: CorrelateMessageErrors


```ts
type CorrelateMessageErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CorrelateMessageResponse


```ts
type CorrelateMessageResponse =
  CorrelateMessageResponses[keyof CorrelateMessageResponses];
```

---

## Type Alias: CorrelateMessageResponses


```ts
type CorrelateMessageResponses = object;
```

## Properties

### 200

```ts
200: MessageCorrelationResult;
```

The message is correlated to one or more process instances

---

## Type Alias: CorrelatedMessageSubscriptionFilter


```ts
type CorrelatedMessageSubscriptionFilter = object;
```

Correlated message subscriptions search filter.

## Properties

### businessId?

```ts
optional businessId?: StringFilterProperty;
```

Filter by the business id stored on the correlated message subscription — for message
start event correlations the correlating message's business id, and for catch, boundary,
or intermediate event correlations the subscribing process instance's business id.
Supports advanced string filtering, including `$like` with `*`/`?` wildcards.

---

### correlationKey?

```ts
optional correlationKey?: StringFilterProperty;
```

The correlation key of the message.

---

### correlationTime?

```ts
optional correlationTime?: DateTimeFilterProperty;
```

The time when the message was correlated.

---

### elementId?

```ts
optional elementId?: StringFilterProperty;
```

The element ID that received the message.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The element instance key that received the message.

---

### messageKey?

```ts
optional messageKey?: BasicStringFilterProperty;
```

The message key.

---

### messageName?

```ts
optional messageName?: StringFilterProperty;
```

The name of the message.

---

### partitionId?

```ts
optional partitionId?: IntegerFilterProperty;
```

The partition ID that correlated the message.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The process definition ID associated with this correlated message subscription.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The process definition key associated with this correlated message subscription. For intermediate message events, this only works for data created with 8.9 and later.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The process instance key associated with this correlated message subscription.

---

### subscriptionKey?

```ts
optional subscriptionKey?: MessageSubscriptionKeyFilterProperty;
```

The subscription key that received the message.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The tenant ID associated with this correlated message subscription.

---

## Type Alias: CorrelatedMessageSubscriptionResult


```ts
type CorrelatedMessageSubscriptionResult = object;
```

## Properties

### businessId

```ts
businessId: BusinessId | null;
```

The business id associated with this correlated message subscription. For a message
start event correlation, it is the business id carried by the correlating message that
was stamped on the started process instance to enforce its uniqueness. For a catch,
boundary, or intermediate event correlation, it is the business id of the subscribing
process instance, captured when the subscription was opened. It is `null` when the
relevant process instance has no business id.

---

### correlationKey

```ts
correlationKey: string | null;
```

The correlation key of the message.

---

### correlationTime

```ts
correlationTime: string;
```

The time when the message was correlated.

---

### elementId

```ts
elementId: string;
```

The element ID that received the message.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey | null;
```

The element instance key that received the message.
It is `null` for start event subscriptions.

---

### messageKey

```ts
messageKey: MessageKey;
```

The message key.

---

### messageName

```ts
messageName: string;
```

The name of the message.

---

### partitionId

```ts
partitionId: number;
```

The partition ID that correlated the message.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition ID associated with this correlated message subscription.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key associated with this correlated message subscription.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The process instance key associated with this correlated message subscription.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### subscriptionKey

```ts
subscriptionKey: MessageSubscriptionKey;
```

The subscription key that received the message.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID associated with this correlated message subscription.

---

## Type Alias: CorrelatedMessageSubscriptionSearchQuery


```ts
type CorrelatedMessageSubscriptionSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: CorrelatedMessageSubscriptionFilter;
```

The correlated message subscriptions search filters.

### sort?

```ts
optional sort?: CorrelatedMessageSubscriptionSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: CorrelatedMessageSubscriptionSearchQueryResult


```ts
type CorrelatedMessageSubscriptionSearchQueryResult = SearchQueryResponse &
  object;
```

## Type Declaration

### items

```ts
items: CorrelatedMessageSubscriptionResult[];
```

The matching correlated message subscriptions.

---

## Type Alias: CorrelatedMessageSubscriptionSearchQuerySortRequest


```ts
type CorrelatedMessageSubscriptionSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "businessId"
  | "correlationKey"
  | "correlationTime"
  | "elementId"
  | "elementInstanceKey"
  | "messageKey"
  | "messageName"
  | "partitionId"
  | "processDefinitionId"
  | "processDefinitionKey"
  | "processInstanceKey"
  | "subscriptionKey"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: CreateAdminUserData


```ts
type CreateAdminUserData = object;
```

## Properties

### body

```ts
body: UserRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/setup/user";
```

---

## Type Alias: CreateAdminUserError


```ts
type CreateAdminUserError = CreateAdminUserErrors[keyof CreateAdminUserErrors];
```

---

## Type Alias: CreateAdminUserErrors


```ts
type CreateAdminUserErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 409

```ts
409: ProblemDetail;
```

A user with this username already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateAdminUserResponse


```ts
type CreateAdminUserResponse =
  CreateAdminUserResponses[keyof CreateAdminUserResponses];
```

---

## Type Alias: CreateAdminUserResponses


```ts
type CreateAdminUserResponses = object;
```

## Properties

### 201

```ts
201: UserCreateResult;
```

The admin user was created successfully.

---

## Type Alias: CreateAgentInstanceData


```ts
type CreateAgentInstanceData = object;
```

## Properties

### body

```ts
body: AgentInstanceCreationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/agent-instances";
```

---

## Type Alias: CreateAgentInstanceError


```ts
type CreateAgentInstanceError =
  CreateAgentInstanceErrors[keyof CreateAgentInstanceErrors];
```

---

## Type Alias: CreateAgentInstanceErrors


```ts
type CreateAgentInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The elementInstanceKey does not correspond to an active element instance.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateAgentInstanceHistoryItemData


```ts
type CreateAgentInstanceHistoryItemData = object;
```

## Properties

### body

```ts
body: AgentInstanceHistoryItemRequest;
```

---

### path

```ts
path: object;
```

#### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The key of the agent instance to append the history item to.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/agent-instances/{agentInstanceKey}/history";
```

---

## Type Alias: CreateAgentInstanceHistoryItemError


```ts
type CreateAgentInstanceHistoryItemError =
  CreateAgentInstanceHistoryItemErrors[keyof CreateAgentInstanceHistoryItemErrors];
```

---

## Type Alias: CreateAgentInstanceHistoryItemErrors


```ts
type CreateAgentInstanceHistoryItemErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The agent instance with the given key was not found, or the specified
jobKey does not correspond to an active job.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateAgentInstanceHistoryItemResponse


```ts
type CreateAgentInstanceHistoryItemResponse =
  CreateAgentInstanceHistoryItemResponses[keyof CreateAgentInstanceHistoryItemResponses];
```

---

## Type Alias: CreateAgentInstanceHistoryItemResponses


```ts
type CreateAgentInstanceHistoryItemResponses = object;
```

## Properties

### 201

```ts
201: AgentInstanceHistoryItemCreationResult;
```

The history item was created.

---

## Type Alias: CreateAgentInstanceResponse


```ts
type CreateAgentInstanceResponse =
  CreateAgentInstanceResponses[keyof CreateAgentInstanceResponses];
```

---

## Type Alias: CreateAgentInstanceResponses


```ts
type CreateAgentInstanceResponses = object;
```

## Properties

### 200

```ts
200: AgentInstanceCreationResult;
```

The agent instance was created.

---

## Type Alias: CreateAuthorizationData


```ts
type CreateAuthorizationData = object;
```

## Properties

### body

```ts
body: AuthorizationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/authorizations";
```

---

## Type Alias: CreateAuthorizationError


```ts
type CreateAuthorizationError =
  CreateAuthorizationErrors[keyof CreateAuthorizationErrors];
```

---

## Type Alias: CreateAuthorizationErrors


```ts
type CreateAuthorizationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The owner was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateAuthorizationResponse


```ts
type CreateAuthorizationResponse =
  CreateAuthorizationResponses[keyof CreateAuthorizationResponses];
```

---

## Type Alias: CreateAuthorizationResponses


```ts
type CreateAuthorizationResponses = object;
```

## Properties

### 201

```ts
201: AuthorizationCreateResult;
```

The authorization was created successfully.

---

## Type Alias: CreateClusterVariableRequest


```ts
type CreateClusterVariableRequest = object;
```

## Properties

### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable. Must be unique within its scope (global or tenant-specific).

---

### value

```ts
value: object;
```

The value of the cluster variable. Can be any JSON object or primitive value. Will be serialized as a JSON string in responses.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: CreateDeploymentData


```ts
type CreateDeploymentData = object;
```

## Properties

### body

```ts
body: object;
```

#### resources

```ts
resources: (Blob | File)[];
```

The binary data to create the deployment resources. It is possible to have more than one form part with different form part names for the binary data to create a deployment.

#### tenantId?

```ts
optional tenantId?: TenantId;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/deployments";
```

---

## Type Alias: CreateDeploymentError


```ts
type CreateDeploymentError =
  CreateDeploymentErrors[keyof CreateDeploymentErrors];
```

---

## Type Alias: CreateDeploymentErrors


```ts
type CreateDeploymentErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateDeploymentResponse


```ts
type CreateDeploymentResponse =
  CreateDeploymentResponses[keyof CreateDeploymentResponses];
```

---

## Type Alias: CreateDeploymentResponses


```ts
type CreateDeploymentResponses = object;
```

## Properties

### 200

```ts
200: DeploymentResult;
```

The resources are deployed.

---

## Type Alias: CreateDocumentData


```ts
type CreateDocumentData = object;
```

## Properties

### body

```ts
body: object;
```

#### file

```ts
file: Blob | File;
```

#### metadata?

```ts
optional metadata?: DocumentMetadata;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: object;
```

#### documentId?

```ts
optional documentId?: DocumentId;
```

The ID of the document to upload. If not provided, a new ID will be generated. Specifying an existing ID will result in an error if the document already exists.

#### storeId?

```ts
optional storeId?: string;
```

The ID of the document store to upload the documents to. Currently, only a single document store is supported per cluster. However, this attribute is included to allow for potential future support of multiple document stores.

---

### url

```ts
url: "/documents";
```

---

## Type Alias: CreateDocumentError


```ts
type CreateDocumentError = CreateDocumentErrors[keyof CreateDocumentErrors];
```

---

## Type Alias: CreateDocumentErrors


```ts
type CreateDocumentErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 415

```ts
415: ProblemDetail;
```

The server cannot process the request because the media type (Content-Type) of the request payload is not supported
by the server for the requested resource and method.

---

## Type Alias: CreateDocumentLinkData


```ts
type CreateDocumentLinkData = object;
```

## Properties

### body?

```ts
optional body?: DocumentLinkRequest;
```

---

### path

```ts
path: object;
```

#### documentId

```ts
documentId: DocumentId;
```

The ID of the document to link.

---

### query?

```ts
optional query?: object;
```

#### contentHash?

```ts
optional contentHash?: string;
```

The hash of the document content that was computed by the document store during upload. The hash is part of the document reference that is returned when uploading a document. If the client fails to provide the correct hash, the request will be rejected.

#### storeId?

```ts
optional storeId?: string;
```

The ID of the document store where the document is located.

---

### url

```ts
url: "/documents/{documentId}/links";
```

---

## Type Alias: CreateDocumentLinkError


```ts
type CreateDocumentLinkError =
  CreateDocumentLinkErrors[keyof CreateDocumentLinkErrors];
```

---

## Type Alias: CreateDocumentLinkErrors


```ts
type CreateDocumentLinkErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

## Type Alias: CreateDocumentLinkResponse


```ts
type CreateDocumentLinkResponse =
  CreateDocumentLinkResponses[keyof CreateDocumentLinkResponses];
```

---

## Type Alias: CreateDocumentLinkResponses


```ts
type CreateDocumentLinkResponses = object;
```

## Properties

### 201

```ts
201: DocumentLink;
```

The document link was created successfully.

---

## Type Alias: CreateDocumentResponse


```ts
type CreateDocumentResponse =
  CreateDocumentResponses[keyof CreateDocumentResponses];
```

---

## Type Alias: CreateDocumentResponses


```ts
type CreateDocumentResponses = object;
```

## Properties

### 201

```ts
201: DocumentReference;
```

The document was uploaded successfully.

---

## Type Alias: CreateDocumentsData


```ts
type CreateDocumentsData = object;
```

## Properties

### body

```ts
body: object;
```

#### files

```ts
files: (Blob | File)[];
```

The documents to upload.

#### metadataList?

```ts
optional metadataList?: DocumentMetadata[];
```

Optional JSON array of metadata object whose index aligns with each file entry. The metadata array must have the same length as the files array.

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: object;
```

#### storeId?

```ts
optional storeId?: string;
```

The ID of the document store to upload the documents to. Currently, only a single document store is supported per cluster. However, this attribute is included to allow for potential future support of multiple document stores.

---

### url

```ts
url: "/documents/batch";
```

---

## Type Alias: CreateDocumentsError


```ts
type CreateDocumentsError = CreateDocumentsErrors[keyof CreateDocumentsErrors];
```

---

## Type Alias: CreateDocumentsErrors


```ts
type CreateDocumentsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 415

```ts
415: ProblemDetail;
```

The server cannot process the request because the media type (Content-Type) of the request payload is not supported
by the server for the requested resource and method.

---

## Type Alias: CreateDocumentsResponse


```ts
type CreateDocumentsResponse =
  CreateDocumentsResponses[keyof CreateDocumentsResponses];
```

---

## Type Alias: CreateDocumentsResponses


```ts
type CreateDocumentsResponses = object;
```

## Properties

### 201

```ts
201: DocumentCreationBatchResponse;
```

All documents were uploaded successfully.

---

### 207

```ts
207: DocumentCreationBatchResponse;
```

Some documents were uploaded successfully, others failed.

---

## Type Alias: CreateElementInstanceVariablesData


```ts
type CreateElementInstanceVariablesData = object;
```

## Properties

### body

```ts
body: SetVariableRequest;
```

---

### path

```ts
path: object;
```

#### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the element instance to update the variables for.
This can be the process instance key (as obtained during instance creation), or a given
element, such as a service task (see the `elementInstanceKey` on the job message).

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/element-instances/{elementInstanceKey}/variables";
```

---

## Type Alias: CreateElementInstanceVariablesError


```ts
type CreateElementInstanceVariablesError =
  CreateElementInstanceVariablesErrors[keyof CreateElementInstanceVariablesErrors];
```

---

## Type Alias: CreateElementInstanceVariablesErrors


```ts
type CreateElementInstanceVariablesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response.
Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists

---

## Type Alias: CreateElementInstanceVariablesResponse


```ts
type CreateElementInstanceVariablesResponse =
  CreateElementInstanceVariablesResponses[keyof CreateElementInstanceVariablesResponses];
```

---

## Type Alias: CreateElementInstanceVariablesResponses


```ts
type CreateElementInstanceVariablesResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The variables were updated.

---

## Type Alias: CreateGlobalClusterVariableData


```ts
type CreateGlobalClusterVariableData = object;
```

## Properties

### body

```ts
body: CreateClusterVariableRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/global";
```

---

## Type Alias: CreateGlobalClusterVariableError


```ts
type CreateGlobalClusterVariableError =
  CreateGlobalClusterVariableErrors[keyof CreateGlobalClusterVariableErrors];
```

---

## Type Alias: CreateGlobalClusterVariableErrors


```ts
type CreateGlobalClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 409

```ts
409: ProblemDetail;
```

A cluster variable with this name already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: CreateGlobalClusterVariableResponse


```ts
type CreateGlobalClusterVariableResponse =
  CreateGlobalClusterVariableResponses[keyof CreateGlobalClusterVariableResponses];
```

---

## Type Alias: CreateGlobalClusterVariableResponses


```ts
type CreateGlobalClusterVariableResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableResult;
```

Cluster variable created

---

## Type Alias: CreateGlobalTaskListenerData


```ts
type CreateGlobalTaskListenerData = object;
```

## Properties

### body

```ts
body: CreateGlobalTaskListenerRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/global-task-listeners";
```

---

## Type Alias: CreateGlobalTaskListenerError


```ts
type CreateGlobalTaskListenerError =
  CreateGlobalTaskListenerErrors[keyof CreateGlobalTaskListenerErrors];
```

---

## Type Alias: CreateGlobalTaskListenerErrors


```ts
type CreateGlobalTaskListenerErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 409

```ts
409: ProblemDetail;
```

A global listener with this id already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateGlobalTaskListenerRequest


```ts
type CreateGlobalTaskListenerRequest = GlobalTaskListenerBase & object;
```

## Type Declaration

### eventTypes

```ts
eventTypes: GlobalTaskListenerEventTypes;
```

### id

```ts
id: GlobalListenerId;
```

---

## Type Alias: CreateGlobalTaskListenerResponse


```ts
type CreateGlobalTaskListenerResponse =
  CreateGlobalTaskListenerResponses[keyof CreateGlobalTaskListenerResponses];
```

---

## Type Alias: CreateGlobalTaskListenerResponses


```ts
type CreateGlobalTaskListenerResponses = object;
```

## Properties

### 201

```ts
201: GlobalTaskListenerResult;
```

The global user task listener was created successfully.

---

## Type Alias: CreateGroupData


```ts
type CreateGroupData = object;
```

## Properties

### body?

```ts
optional body?: GroupCreateRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups";
```

---

## Type Alias: CreateGroupError


```ts
type CreateGroupError = CreateGroupErrors[keyof CreateGroupErrors];
```

---

## Type Alias: CreateGroupErrors


```ts
type CreateGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 409

```ts
409: ProblemDetail;
```

Group with this id already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateGroupResponse


```ts
type CreateGroupResponse = CreateGroupResponses[keyof CreateGroupResponses];
```

---

## Type Alias: CreateGroupResponses


```ts
type CreateGroupResponses = object;
```

## Properties

### 201

```ts
201: GroupCreateResult;
```

The group was created successfully.

---

## Type Alias: CreateMappingRuleData


```ts
type CreateMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: MappingRuleCreateRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/mapping-rules";
```

---

## Type Alias: CreateMappingRuleError


```ts
type CreateMappingRuleError =
  CreateMappingRuleErrors[keyof CreateMappingRuleErrors];
```

---

## Type Alias: CreateMappingRuleErrors


```ts
type CreateMappingRuleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

The request to create a mapping rule was denied.
More details are provided in the response body.

---

### 404

```ts
404: ProblemDetail;
```

The request to create a mapping rule was denied.

---

### 409

```ts
409: ProblemDetail;
```

Mapping rule with this id already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: CreateMappingRuleResponse


```ts
type CreateMappingRuleResponse =
  CreateMappingRuleResponses[keyof CreateMappingRuleResponses];
```

---

## Type Alias: CreateMappingRuleResponses


```ts
type CreateMappingRuleResponses = object;
```

## Properties

### 201

```ts
201: MappingRuleCreateResult;
```

The mapping rule was created successfully.

---

## Type Alias: CreateProcessInstanceData


```ts
type CreateProcessInstanceData = object;
```

## Properties

### body

```ts
body: ProcessInstanceCreationInstruction;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances";
```

---

## Type Alias: CreateProcessInstanceError


```ts
type CreateProcessInstanceError =
  CreateProcessInstanceErrors[keyof CreateProcessInstanceErrors];
```

---

## Type Alias: CreateProcessInstanceErrors


```ts
type CreateProcessInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 409

```ts
409: ProblemDetail;
```

The process instance creation was rejected due to a business ID uniqueness conflict.
This can happen only when Business ID Uniqueness Control is enabled and an
active root process instance with the provided business ID already exists
for the same process definition and tenant.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The process instance creation request timed out in the gateway.
This can happen if the `awaitCompletion` request parameter is set to `true`
and the created process instance did not complete within the defined request timeout.
This often happens when the created instance is not fully automated or contains wait states.

---

## Type Alias: CreateProcessInstanceResponse


```ts
type CreateProcessInstanceResponse =
  CreateProcessInstanceResponses[keyof CreateProcessInstanceResponses];
```

---

## Type Alias: CreateProcessInstanceResponses


```ts
type CreateProcessInstanceResponses = object;
```

## Properties

### 200

```ts
200: CreateProcessInstanceResult;
```

The process instance was created.

---

## Type Alias: CreateProcessInstanceResult


```ts
type CreateProcessInstanceResult = object;
```

## Properties

### businessId

```ts
businessId: BusinessId | null;
```

Business id as provided on creation.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The BPMN process id of the process definition which was used to create the process.
instance

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the process definition which was used to create the process instance.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version of the process definition which was used to create the process instance.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The unique identifier of the created process instance; to be used wherever a request
needs a process instance key (e.g. CancelProcessInstanceRequest).

---

### tags

```ts
tags: TagSet;
```

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant id of the created process instance.

---

### variables

```ts
variables: object;
```

All the variables visible in the root scope.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: CreateRoleData


```ts
type CreateRoleData = object;
```

## Properties

### body?

```ts
optional body?: RoleCreateRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles";
```

---

## Type Alias: CreateRoleError


```ts
type CreateRoleError = CreateRoleErrors[keyof CreateRoleErrors];
```

---

## Type Alias: CreateRoleErrors


```ts
type CreateRoleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 409

```ts
409: ProblemDetail;
```

Role with this id already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateRoleResponse


```ts
type CreateRoleResponse = CreateRoleResponses[keyof CreateRoleResponses];
```

---

## Type Alias: CreateRoleResponses


```ts
type CreateRoleResponses = object;
```

## Properties

### 201

```ts
201: RoleCreateResult;
```

The role was created successfully.

---

## Type Alias: CreateTenantClusterVariableData


```ts
type CreateTenantClusterVariableData = object;
```

## Properties

### body

```ts
body: CreateClusterVariableRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The tenant ID

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/tenants/{tenantId}";
```

---

## Type Alias: CreateTenantClusterVariableError


```ts
type CreateTenantClusterVariableError =
  CreateTenantClusterVariableErrors[keyof CreateTenantClusterVariableErrors];
```

---

## Type Alias: CreateTenantClusterVariableErrors


```ts
type CreateTenantClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The tenant with the given ID was not found.

---

### 409

```ts
409: ProblemDetail;
```

A cluster variable with this name already exists for the given tenant.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: CreateTenantClusterVariableResponse


```ts
type CreateTenantClusterVariableResponse =
  CreateTenantClusterVariableResponses[keyof CreateTenantClusterVariableResponses];
```

---

## Type Alias: CreateTenantClusterVariableResponses


```ts
type CreateTenantClusterVariableResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableResult;
```

Cluster variable created

---

## Type Alias: CreateTenantData


```ts
type CreateTenantData = object;
```

## Properties

### body

```ts
body: TenantCreateRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants";
```

---

## Type Alias: CreateTenantError


```ts
type CreateTenantError = CreateTenantErrors[keyof CreateTenantErrors];
```

---

## Type Alias: CreateTenantErrors


```ts
type CreateTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The resource was not found.

---

### 409

```ts
409: ProblemDetail;
```

Tenant with this id already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateTenantResponse


```ts
type CreateTenantResponse = CreateTenantResponses[keyof CreateTenantResponses];
```

---

## Type Alias: CreateTenantResponses


```ts
type CreateTenantResponses = object;
```

## Properties

### 201

```ts
201: TenantCreateResult;
```

The tenant was created successfully.

---

## Type Alias: CreateUserData


```ts
type CreateUserData = object;
```

## Properties

### body

```ts
body: UserRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/users";
```

---

## Type Alias: CreateUserError


```ts
type CreateUserError = CreateUserErrors[keyof CreateUserErrors];
```

---

## Type Alias: CreateUserErrors


```ts
type CreateUserErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 409

```ts
409: ProblemDetail;
```

A user with this username already exists.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: CreateUserResponse


```ts
type CreateUserResponse = CreateUserResponses[keyof CreateUserResponses];
```

---

## Type Alias: CreateUserResponses


```ts
type CreateUserResponses = object;
```

## Properties

### 201

```ts
201: UserCreateResult;
```

The user was created successfully.

---

## Type Alias: CursorBackwardPagination


```ts
type CursorBackwardPagination = object;
```

Cursor-based backward pagination

## Properties

### before?

```ts
optional before?: StartCursor;
```

Use the `startCursor` value from the previous response to fetch the previous page of results.

---

### limit?

```ts
optional limit?: number;
```

The maximum number of items to return in one request.

---

## Type Alias: CursorForwardPagination


```ts
type CursorForwardPagination = object;
```

Cursor-based forward pagination

## Properties

### after?

```ts
optional after?: EndCursor;
```

Use the `endCursor` value from the previous response to fetch the next page of results.

---

### limit?

```ts
optional limit?: number;
```

The maximum number of items to return in one request.

---

## Type Alias: DateTimeFilterProperty


```ts
type DateTimeFilterProperty = string | AdvancedDateTimeFilter;
```

Date-time property with full advanced search capabilities.

---

## Type Alias: DecisionDefinitionFilter


```ts
type DecisionDefinitionFilter = object;
```

Decision definition search filter.

## Properties

### decisionDefinitionId?

```ts
optional decisionDefinitionId?: DecisionDefinitionId;
```

The DMN ID of the decision definition.

---

### decisionDefinitionKey?

```ts
optional decisionDefinitionKey?: DecisionDefinitionKey;
```

The assigned key, which acts as a unique identifier for this decision definition.

---

### decisionRequirementsId?

```ts
optional decisionRequirementsId?: string;
```

the DMN ID of the decision requirements graph that the decision definition is part of.

---

### decisionRequirementsKey?

```ts
optional decisionRequirementsKey?: DecisionRequirementsKey;
```

The assigned key of the decision requirements graph that the decision definition is part of.

---

### decisionRequirementsName?

```ts
optional decisionRequirementsName?: string;
```

The DMN name of the decision requirements that the decision definition is part of.

---

### decisionRequirementsVersion?

```ts
optional decisionRequirementsVersion?: number;
```

The assigned version of the decision requirements that the decision definition is part of.

---

### isLatestVersion?

```ts
optional isLatestVersion?: boolean;
```

Whether to only return the latest version of each decision definition.
When using this filter, pagination functionality is limited, you can only paginate forward using `after` and `limit`.
The response contains no `startCursor` in the `page`, and requests ignore the `from` and `before` in the `page`.

---

### name?

```ts
optional name?: string;
```

The DMN name of the decision definition.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant ID of the decision definition.

---

### version?

```ts
optional version?: number;
```

The assigned version of the decision definition.

---

## Type Alias: DecisionDefinitionId


```ts
type DecisionDefinitionId = CamundaKey<"DecisionDefinitionId">;
```

Id of a decision definition, from the model. Only ids of decision definitions that are deployed are useful.

---

## Type Alias: DecisionDefinitionKey


```ts
type DecisionDefinitionKey = CamundaKey<"DecisionDefinitionKey">;
```

System-generated key for a decision definition.

---

## Type Alias: DecisionDefinitionKeyExactMatch


```ts
type DecisionDefinitionKeyExactMatch = DecisionDefinitionKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: DecisionDefinitionKeyFilterProperty


```ts
type DecisionDefinitionKeyFilterProperty =
  DecisionDefinitionKeyExactMatch | AdvancedDecisionDefinitionKeyFilter;
```

DecisionDefinitionKey property with full advanced search capabilities.

---

## Type Alias: DecisionDefinitionResult


```ts
type DecisionDefinitionResult = object;
```

## Properties

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId;
```

The DMN ID of the decision definition.

---

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The assigned key, which acts as a unique identifier for this decision definition.

---

### decisionRequirementsId

```ts
decisionRequirementsId: string;
```

the DMN ID of the decision requirements graph that the decision definition is part of.

---

### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The assigned key of the decision requirements graph that the decision definition is part of.

---

### decisionRequirementsName

```ts
decisionRequirementsName: string;
```

The DMN name of the decision requirements that the decision definition is part of.

---

### decisionRequirementsVersion

```ts
decisionRequirementsVersion: number;
```

The assigned version of the decision requirements that the decision definition is part of.

---

### name

```ts
name: string;
```

The DMN name of the decision definition.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the decision definition.

---

### version

```ts
version: number;
```

The assigned version of the decision definition.

---

## Type Alias: DecisionDefinitionSearchQuery


```ts
type DecisionDefinitionSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: DecisionDefinitionFilter;
```

The decision definition search filters.

### sort?

```ts
optional sort?: DecisionDefinitionSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: DecisionDefinitionSearchQueryResult


```ts
type DecisionDefinitionSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: DecisionDefinitionResult[];
```

The matching decision definitions.

---

## Type Alias: DecisionDefinitionSearchQuerySortRequest


```ts
type DecisionDefinitionSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "decisionDefinitionKey"
  | "decisionDefinitionId"
  | "name"
  | "version"
  | "decisionRequirementsId"
  | "decisionRequirementsKey"
  | "decisionRequirementsName"
  | "decisionRequirementsVersion"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: DecisionDefinitionTypeEnum


```ts
type DecisionDefinitionTypeEnum =
  (typeof DecisionDefinitionTypeEnum)[keyof typeof DecisionDefinitionTypeEnum];
```

The type of the decision. UNSPECIFIED is deprecated and should not be used anymore, for removal in 8.10

---

## Type Alias: DecisionEvaluationById


```ts
type DecisionEvaluationById = object;
```

Decision evaluation by ID

## Properties

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId;
```

The ID of the decision to be evaluated.
When using the decision ID, the latest
deployed version of the decision is used.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant ID of the decision.

---

### variables?

```ts
optional variables?: object;
```

The decision evaluation variables as JSON document.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: DecisionEvaluationByKey


```ts
type DecisionEvaluationByKey = object;
```

Decision evaluation by key

## Properties

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant ID of the decision.

---

### variables?

```ts
optional variables?: object;
```

The decision evaluation variables as JSON document.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: DecisionEvaluationInstanceKey


```ts
type DecisionEvaluationInstanceKey =
  CamundaKey<"DecisionEvaluationInstanceKey">;
```

System-generated identifier for a decision evaluation instance. It is composed of the
parent decision evaluation key and the 1-based index of the evaluated decision within
that evaluation, joined by a hyphen (format: `<decisionEvaluationKey>-<index>`).

---

## Type Alias: DecisionEvaluationInstanceKeyExactMatch


```ts
type DecisionEvaluationInstanceKeyExactMatch = DecisionEvaluationInstanceKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: DecisionEvaluationInstanceKeyFilterProperty


```ts
type DecisionEvaluationInstanceKeyFilterProperty =
  | DecisionEvaluationInstanceKeyExactMatch
  | AdvancedDecisionEvaluationInstanceKeyFilter;
```

DecisionEvaluationInstanceKey property with full advanced search capabilities.

---

## Type Alias: DecisionEvaluationInstruction


```ts
type DecisionEvaluationInstruction =
  DecisionEvaluationById | DecisionEvaluationByKey;
```

---

## Type Alias: DecisionEvaluationKey


```ts
type DecisionEvaluationKey = CamundaKey<"DecisionEvaluationKey">;
```

System-generated key for a decision evaluation.

---

## Type Alias: DecisionEvaluationKeyExactMatch


```ts
type DecisionEvaluationKeyExactMatch = DecisionEvaluationKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: DecisionEvaluationKeyFilterProperty


```ts
type DecisionEvaluationKeyFilterProperty =
  DecisionEvaluationKeyExactMatch | AdvancedDecisionEvaluationKeyFilter;
```

DecisionEvaluationKey property with full advanced search capabilities.

---

## Type Alias: DecisionInstanceDeletionBatchOperationRequest


```ts
type DecisionInstanceDeletionBatchOperationRequest = object;
```

The decision instance filter that defines which decision instances should be deleted.

## Properties

### filter

```ts
filter: DecisionInstanceFilter;
```

The decision instance filter.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: DecisionInstanceFilter


```ts
type DecisionInstanceFilter = object;
```

Decision instance search filter.

## Properties

### businessId?

```ts
optional businessId?: StringFilterProperty;
```

The business ID of the owning process instance the decision instance belongs to. This only works for decision instances created with 8.10 and onwards. Decision instances from prior versions and standalone evaluations don't contain this data and cannot be found.

---

### decisionDefinitionId?

```ts
optional decisionDefinitionId?: DecisionDefinitionId;
```

The ID of the DMN decision.

---

### decisionDefinitionKey?

```ts
optional decisionDefinitionKey?: DecisionDefinitionKeyFilterProperty;
```

The key of the decision.

---

### decisionDefinitionName?

```ts
optional decisionDefinitionName?: string;
```

The name of the DMN decision.

---

### decisionDefinitionType?

```ts
optional decisionDefinitionType?: DecisionDefinitionTypeEnum;
```

---

### decisionDefinitionVersion?

```ts
optional decisionDefinitionVersion?: number;
```

The version of the decision.

---

### decisionEvaluationInstanceKey?

```ts
optional decisionEvaluationInstanceKey?: DecisionEvaluationInstanceKeyFilterProperty;
```

The key of the decision evaluation instance.

---

### decisionEvaluationKey?

```ts
optional decisionEvaluationKey?: DecisionEvaluationKey;
```

The key of the parent decision evaluation. Note that this is not the identifier of an individual decision instance; the `decisionEvaluationInstanceKey` is the identifier for a decision instance.

---

### decisionRequirementsKey?

```ts
optional decisionRequirementsKey?: DecisionRequirementsKeyFilterProperty;
```

The key of the decision requirements definition.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The key of the element instance this decision instance is linked to.

---

### evaluationDate?

```ts
optional evaluationDate?: DateTimeFilterProperty;
```

The evaluation date of the decision instance.

---

### evaluationFailure?

```ts
optional evaluationFailure?: string;
```

The evaluation failure of the decision instance.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKey;
```

The key of the process definition.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKey;
```

The key of the process instance.

---

### rootDecisionDefinitionKey?

```ts
optional rootDecisionDefinitionKey?: DecisionDefinitionKeyFilterProperty;
```

The key of the root decision definition.

---

### state?

```ts
optional state?: DecisionInstanceStateFilterProperty;
```

The state of the decision instance.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant ID of the decision instance.

---

## Type Alias: DecisionInstanceGetQueryResult


```ts
type DecisionInstanceGetQueryResult = DecisionInstanceResult & object;
```

## Type Declaration

### evaluatedInputs

```ts
evaluatedInputs: EvaluatedDecisionInputItem[];
```

The evaluated inputs of the decision instance.

### matchedRules

```ts
matchedRules: MatchedDecisionRuleItem[];
```

The matched rules of the decision instance.

---

## Type Alias: DecisionInstanceKey


```ts
type DecisionInstanceKey = CamundaKey<"DecisionInstanceKey">;
```

System-generated key for a deployed decision instance.

---

## Type Alias: DecisionInstanceResult


```ts
type DecisionInstanceResult = object;
```

## Properties

### businessId

```ts
businessId: BusinessId | null;
```

The business ID of the owning process instance, inherited when the decision instance was
evaluated. This is `null` for decision instances created before version 8.10, for
standalone decision evaluations, and for decision instances whose owning process instance
has no business ID.

---

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId;
```

The ID of the DMN decision.

---

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The key of the decision.

---

### decisionDefinitionName

```ts
decisionDefinitionName: string;
```

The name of the DMN decision.

---

### decisionDefinitionType

```ts
decisionDefinitionType: DecisionDefinitionTypeEnum;
```

---

### decisionDefinitionVersion

```ts
decisionDefinitionVersion: number;
```

The version of the decision.

---

### decisionEvaluationInstanceKey

```ts
decisionEvaluationInstanceKey: DecisionEvaluationInstanceKey;
```

---

### decisionEvaluationKey

```ts
decisionEvaluationKey: DecisionEvaluationKey;
```

The key of the decision evaluation where this instance was created.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey | null;
```

The key of the element instance this decision instance is linked to.

---

### evaluationDate

```ts
evaluationDate: string;
```

The evaluation date of the decision instance.

---

### evaluationFailure

```ts
evaluationFailure: string | null;
```

The evaluation failure of the decision instance.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey | null;
```

The key of the process definition.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey | null;
```

The key of the process instance.

---

### result

```ts
result: string;
```

The result of the decision instance.

---

### rootDecisionDefinitionKey

```ts
rootDecisionDefinitionKey: DecisionDefinitionKey;
```

The key of the root decision definition.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### state

```ts
state: DecisionInstanceStateEnum;
```

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the decision instance.

---

## Type Alias: DecisionInstanceSearchQuery


```ts
type DecisionInstanceSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: DecisionInstanceFilter;
```

The decision instance search filters.

### sort?

```ts
optional sort?: DecisionInstanceSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: DecisionInstanceSearchQueryResult


```ts
type DecisionInstanceSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: DecisionInstanceResult[];
```

The matching decision instances.

---

## Type Alias: DecisionInstanceSearchQuerySortRequest


```ts
type DecisionInstanceSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "businessId"
  | "decisionDefinitionId"
  | "decisionDefinitionKey"
  | "decisionDefinitionName"
  | "decisionDefinitionType"
  | "decisionDefinitionVersion"
  | "decisionEvaluationInstanceKey"
  | "decisionEvaluationKey"
  | "elementInstanceKey"
  | "evaluationDate"
  | "evaluationFailure"
  | "processDefinitionKey"
  | "processInstanceKey"
  | "rootDecisionDefinitionKey"
  | "state"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: DecisionInstanceStateEnum


```ts
type DecisionInstanceStateEnum =
  (typeof DecisionInstanceStateEnum)[keyof typeof DecisionInstanceStateEnum];
```

The state of the decision instance. UNSPECIFIED and UNKNOWN are deprecated and should not be used anymore, for removal in 8.10

---

## Type Alias: DecisionInstanceStateExactMatch


```ts
type DecisionInstanceStateExactMatch = DecisionInstanceStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: DecisionInstanceStateFilterProperty


```ts
type DecisionInstanceStateFilterProperty =
  DecisionInstanceStateExactMatch | AdvancedDecisionInstanceStateFilter;
```

DecisionInstanceStateEnum property with full advanced search capabilities.

---

## Type Alias: DecisionRequirementsFilter


```ts
type DecisionRequirementsFilter = object;
```

Decision requirements search filter.

## Properties

### decisionRequirementsId?

```ts
optional decisionRequirementsId?: string;
```

the DMN ID of the decision requirements.

---

### decisionRequirementsKey?

```ts
optional decisionRequirementsKey?: DecisionRequirementsKey;
```

---

### decisionRequirementsName?

```ts
optional decisionRequirementsName?: string;
```

The DMN name of the decision requirements.

---

### resourceName?

```ts
optional resourceName?: string;
```

The name of the resource from which the decision requirements were parsed

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant ID of the decision requirements.

---

### version?

```ts
optional version?: number;
```

The assigned version of the decision requirements.

---

## Type Alias: DecisionRequirementsKey


```ts
type DecisionRequirementsKey = CamundaKey<"DecisionRequirementsKey">;
```

System-generated key for a deployed decision requirements definition.

---

## Type Alias: DecisionRequirementsKeyExactMatch


```ts
type DecisionRequirementsKeyExactMatch = DecisionRequirementsKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: DecisionRequirementsKeyFilterProperty


```ts
type DecisionRequirementsKeyFilterProperty =
  DecisionRequirementsKeyExactMatch | AdvancedDecisionRequirementsKeyFilter;
```

DecisionRequirementsKey property with full advanced search capabilities.

---

## Type Alias: DecisionRequirementsResult


```ts
type DecisionRequirementsResult = object;
```

## Properties

### decisionRequirementsId

```ts
decisionRequirementsId: string;
```

The DMN ID of the decision requirements.

---

### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The assigned key, which acts as a unique identifier for this decision requirements.

---

### decisionRequirementsName

```ts
decisionRequirementsName: string;
```

The DMN name of the decision requirements.

---

### resourceName

```ts
resourceName: string;
```

The name of the resource from which this decision requirements was parsed.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the decision requirements.

---

### version

```ts
version: number;
```

The assigned version of the decision requirements.

---

## Type Alias: DecisionRequirementsSearchQuery


```ts
type DecisionRequirementsSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: DecisionRequirementsFilter;
```

The decision definition search filters.

### sort?

```ts
optional sort?: DecisionRequirementsSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: DecisionRequirementsSearchQueryResult


```ts
type DecisionRequirementsSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: DecisionRequirementsResult[];
```

The matching decision requirements.

---

## Type Alias: DecisionRequirementsSearchQuerySortRequest


```ts
type DecisionRequirementsSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "decisionRequirementsKey"
  | "decisionRequirementsName"
  | "version"
  | "decisionRequirementsId"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: DeleteAuthorizationData


```ts
type DeleteAuthorizationData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### authorizationKey

```ts
authorizationKey: AuthorizationKey;
```

The key of the authorization to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/authorizations/{authorizationKey}";
```

---

## Type Alias: DeleteAuthorizationError


```ts
type DeleteAuthorizationError =
  DeleteAuthorizationErrors[keyof DeleteAuthorizationErrors];
```

---

## Type Alias: DeleteAuthorizationErrors


```ts
type DeleteAuthorizationErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The authorization with the authorizationKey was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteAuthorizationResponse


```ts
type DeleteAuthorizationResponse =
  DeleteAuthorizationResponses[keyof DeleteAuthorizationResponses];
```

---

## Type Alias: DeleteAuthorizationResponses


```ts
type DeleteAuthorizationResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The authorization was deleted successfully.

---

## Type Alias: DeleteDecisionInstanceData


```ts
type DeleteDecisionInstanceData = object;
```

## Properties

### body?

```ts
optional body?: DeleteDecisionInstanceRequest;
```

---

### path

```ts
path: object;
```

#### decisionEvaluationKey

```ts
decisionEvaluationKey: DecisionEvaluationKey;
```

The key of the decision evaluation to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-instances/{decisionEvaluationKey}/deletion";
```

---

## Type Alias: DeleteDecisionInstanceError


```ts
type DeleteDecisionInstanceError =
  DeleteDecisionInstanceErrors[keyof DeleteDecisionInstanceErrors];
```

---

## Type Alias: DeleteDecisionInstanceErrors


```ts
type DeleteDecisionInstanceErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The decision instance is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteDecisionInstanceRequest


```ts
type DeleteDecisionInstanceRequest = {
  operationReference?: OperationReference;
} | null;
```

---

## Type Alias: DeleteDecisionInstanceResponse


```ts
type DeleteDecisionInstanceResponse =
  DeleteDecisionInstanceResponses[keyof DeleteDecisionInstanceResponses];
```

---

## Type Alias: DeleteDecisionInstanceResponses


```ts
type DeleteDecisionInstanceResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The decision instance is marked for deletion.

---

## Type Alias: DeleteDecisionInstancesBatchOperationData


```ts
type DeleteDecisionInstancesBatchOperationData = object;
```

## Properties

### body

```ts
body: DecisionInstanceDeletionBatchOperationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-instances/deletion";
```

---

## Type Alias: DeleteDecisionInstancesBatchOperationError


```ts
type DeleteDecisionInstancesBatchOperationError =
  DeleteDecisionInstancesBatchOperationErrors[keyof DeleteDecisionInstancesBatchOperationErrors];
```

---

## Type Alias: DeleteDecisionInstancesBatchOperationErrors


```ts
type DeleteDecisionInstancesBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The decision instance batch operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: DeleteDecisionInstancesBatchOperationResponse


```ts
type DeleteDecisionInstancesBatchOperationResponse =
  DeleteDecisionInstancesBatchOperationResponses[keyof DeleteDecisionInstancesBatchOperationResponses];
```

---

## Type Alias: DeleteDecisionInstancesBatchOperationResponses


```ts
type DeleteDecisionInstancesBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request was created.

---

## Type Alias: DeleteDocumentData


```ts
type DeleteDocumentData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### documentId

```ts
documentId: DocumentId;
```

The ID of the document to delete.

---

### query?

```ts
optional query?: object;
```

#### storeId?

```ts
optional storeId?: string;
```

The ID of the document store to delete the document from.

---

### url

```ts
url: "/documents/{documentId}";
```

---

## Type Alias: DeleteDocumentError


```ts
type DeleteDocumentError = DeleteDocumentErrors[keyof DeleteDocumentErrors];
```

---

## Type Alias: DeleteDocumentErrors


```ts
type DeleteDocumentErrors = object;
```

## Properties

### 404

```ts
404: ProblemDetail;
```

The document with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: DeleteDocumentResponse


```ts
type DeleteDocumentResponse =
  DeleteDocumentResponses[keyof DeleteDocumentResponses];
```

---

## Type Alias: DeleteDocumentResponses


```ts
type DeleteDocumentResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The document was deleted successfully.

---

## Type Alias: DeleteGlobalClusterVariableData


```ts
type DeleteGlobalClusterVariableData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/global/{name}";
```

---

## Type Alias: DeleteGlobalClusterVariableError


```ts
type DeleteGlobalClusterVariableError =
  DeleteGlobalClusterVariableErrors[keyof DeleteGlobalClusterVariableErrors];
```

---

## Type Alias: DeleteGlobalClusterVariableErrors


```ts
type DeleteGlobalClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Cluster variable not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: DeleteGlobalClusterVariableResponse


```ts
type DeleteGlobalClusterVariableResponse =
  DeleteGlobalClusterVariableResponses[keyof DeleteGlobalClusterVariableResponses];
```

---

## Type Alias: DeleteGlobalClusterVariableResponses


```ts
type DeleteGlobalClusterVariableResponses = object;
```

## Properties

### 204

```ts
204: void;
```

Cluster variable deleted successfully

---

## Type Alias: DeleteGlobalTaskListenerData


```ts
type DeleteGlobalTaskListenerData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### id

```ts
id: GlobalListenerId;
```

The id of the global user task listener to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/global-task-listeners/{id}";
```

---

## Type Alias: DeleteGlobalTaskListenerError


```ts
type DeleteGlobalTaskListenerError =
  DeleteGlobalTaskListenerErrors[keyof DeleteGlobalTaskListenerErrors];
```

---

## Type Alias: DeleteGlobalTaskListenerErrors


```ts
type DeleteGlobalTaskListenerErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The global user task listener was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteGlobalTaskListenerResponse


```ts
type DeleteGlobalTaskListenerResponse =
  DeleteGlobalTaskListenerResponses[keyof DeleteGlobalTaskListenerResponses];
```

---

## Type Alias: DeleteGlobalTaskListenerResponses


```ts
type DeleteGlobalTaskListenerResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The global listener was deleted successfully.

---

## Type Alias: DeleteGroupData


```ts
type DeleteGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}";
```

---

## Type Alias: DeleteGroupError


```ts
type DeleteGroupError = DeleteGroupErrors[keyof DeleteGroupErrors];
```

---

## Type Alias: DeleteGroupErrors


```ts
type DeleteGroupErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteGroupResponse


```ts
type DeleteGroupResponse = DeleteGroupResponses[keyof DeleteGroupResponses];
```

---

## Type Alias: DeleteGroupResponses


```ts
type DeleteGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The group was deleted successfully.

---

## Type Alias: DeleteMappingRuleData


```ts
type DeleteMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The ID of the mapping rule to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: DeleteMappingRuleError


```ts
type DeleteMappingRuleError =
  DeleteMappingRuleErrors[keyof DeleteMappingRuleErrors];
```

---

## Type Alias: DeleteMappingRuleErrors


```ts
type DeleteMappingRuleErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The mapping rule with the mappingRuleId was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteMappingRuleResponse


```ts
type DeleteMappingRuleResponse =
  DeleteMappingRuleResponses[keyof DeleteMappingRuleResponses];
```

---

## Type Alias: DeleteMappingRuleResponses


```ts
type DeleteMappingRuleResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The mapping rule was deleted successfully.

---

## Type Alias: DeleteProcessInstanceData


```ts
type DeleteProcessInstanceData = object;
```

## Properties

### body?

```ts
optional body?: DeleteProcessInstanceRequest;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/deletion";
```

---

## Type Alias: DeleteProcessInstanceError


```ts
type DeleteProcessInstanceError =
  DeleteProcessInstanceErrors[keyof DeleteProcessInstanceErrors];
```

---

## Type Alias: DeleteProcessInstanceErrors


```ts
type DeleteProcessInstanceErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The process instance is not found.

---

### 409

```ts
409: ProblemDetail;
```

The process instance is not in a completed or terminated state and cannot be deleted.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteProcessInstanceRequest


```ts
type DeleteProcessInstanceRequest = {
  operationReference?: OperationReference;
} | null;
```

---

## Type Alias: DeleteProcessInstanceResponse


```ts
type DeleteProcessInstanceResponse =
  DeleteProcessInstanceResponses[keyof DeleteProcessInstanceResponses];
```

---

## Type Alias: DeleteProcessInstanceResponses


```ts
type DeleteProcessInstanceResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The process instance is marked for deletion.

---

## Type Alias: DeleteProcessInstancesBatchOperationData


```ts
type DeleteProcessInstancesBatchOperationData = object;
```

## Properties

### body

```ts
body: ProcessInstanceDeletionBatchOperationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/deletion";
```

---

## Type Alias: DeleteProcessInstancesBatchOperationError


```ts
type DeleteProcessInstancesBatchOperationError =
  DeleteProcessInstancesBatchOperationErrors[keyof DeleteProcessInstancesBatchOperationErrors];
```

---

## Type Alias: DeleteProcessInstancesBatchOperationErrors


```ts
type DeleteProcessInstancesBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The process instance batch operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: DeleteProcessInstancesBatchOperationResponse


```ts
type DeleteProcessInstancesBatchOperationResponse =
  DeleteProcessInstancesBatchOperationResponses[keyof DeleteProcessInstancesBatchOperationResponses];
```

---

## Type Alias: DeleteProcessInstancesBatchOperationResponses


```ts
type DeleteProcessInstancesBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request was created.

---

## Type Alias: DeleteResourceData


```ts
type DeleteResourceData = object;
```

## Properties

### body?

```ts
optional body?: DeleteResourceRequest;
```

---

### path

```ts
path: object;
```

#### resourceKey

```ts
resourceKey: ResourceKey;
```

The key of the resource to delete.
This can be the key of a process definition, the key of a decision requirements
definition or the key of a form definition

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/resources/{resourceKey}/deletion";
```

---

## Type Alias: DeleteResourceError


```ts
type DeleteResourceError = DeleteResourceErrors[keyof DeleteResourceErrors];
```

---

## Type Alias: DeleteResourceErrors


```ts
type DeleteResourceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The resource is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteResourceRequest


```ts
type DeleteResourceRequest = {
  deleteHistory?: boolean;
  operationReference?: OperationReference;
} | null;
```

## Union Members

### Type Literal

```ts
{
  deleteHistory?: boolean;
  operationReference?: OperationReference;
}
```

#### deleteHistory?

```ts
optional deleteHistory?: boolean;
```

Indicates if the historic data of a process resource should be deleted via a
batch operation asynchronously.

This flag is only effective for process resources. For other resource types
(decisions, forms, generic resources), this flag is ignored and no history
will be deleted. In those cases, the `batchOperation` field in the response
will not be populated.

#### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

`null`

---

## Type Alias: DeleteResourceResponse


```ts
type DeleteResourceResponse = object;
```

## Properties

### batchOperation

```ts
batchOperation: BatchOperationCreatedResult | null;
```

The batch operation created for asynchronously deleting the historic data.

This field is only populated when the request `deleteHistory` is set to `true` and the resource
is a process definition. For other resource types (decisions, forms, generic resources),
this field will be `null`.

---

### resourceKey

```ts
resourceKey: ResourceKey;
```

The system-assigned key for this resource, requested to be deleted.

---

## Type Alias: DeleteResourceResponse2


```ts
type DeleteResourceResponse2 =
  DeleteResourceResponses[keyof DeleteResourceResponses];
```

---

## Type Alias: DeleteResourceResponses


```ts
type DeleteResourceResponses = object;
```

## Properties

### 200

```ts
200: DeleteResourceResponse;
```

The resource is deleted.

---

## Type Alias: DeleteRoleData


```ts
type DeleteRoleData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}";
```

---

## Type Alias: DeleteRoleError


```ts
type DeleteRoleError = DeleteRoleErrors[keyof DeleteRoleErrors];
```

---

## Type Alias: DeleteRoleErrors


```ts
type DeleteRoleErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The role with the ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteRoleResponse


```ts
type DeleteRoleResponse = DeleteRoleResponses[keyof DeleteRoleResponses];
```

---

## Type Alias: DeleteRoleResponses


```ts
type DeleteRoleResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was deleted successfully.

---

## Type Alias: DeleteTenantClusterVariableData


```ts
type DeleteTenantClusterVariableData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable

#### tenantId

```ts
tenantId: TenantId;
```

The tenant ID

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/tenants/{tenantId}/{name}";
```

---

## Type Alias: DeleteTenantClusterVariableError


```ts
type DeleteTenantClusterVariableError =
  DeleteTenantClusterVariableErrors[keyof DeleteTenantClusterVariableErrors];
```

---

## Type Alias: DeleteTenantClusterVariableErrors


```ts
type DeleteTenantClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Cluster variable not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: DeleteTenantClusterVariableResponse


```ts
type DeleteTenantClusterVariableResponse =
  DeleteTenantClusterVariableResponses[keyof DeleteTenantClusterVariableResponses];
```

---

## Type Alias: DeleteTenantClusterVariableResponses


```ts
type DeleteTenantClusterVariableResponses = object;
```

## Properties

### 204

```ts
204: void;
```

Cluster variable deleted successfully

---

## Type Alias: DeleteTenantData


```ts
type DeleteTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}";
```

---

## Type Alias: DeleteTenantError


```ts
type DeleteTenantError = DeleteTenantErrors[keyof DeleteTenantErrors];
```

---

## Type Alias: DeleteTenantErrors


```ts
type DeleteTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteTenantResponse


```ts
type DeleteTenantResponse = DeleteTenantResponses[keyof DeleteTenantResponses];
```

---

## Type Alias: DeleteTenantResponses


```ts
type DeleteTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The tenant was deleted successfully.

---

## Type Alias: DeleteUserData


```ts
type DeleteUserData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### username

```ts
username: Username;
```

The username of the user to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/users/{username}";
```

---

## Type Alias: DeleteUserError


```ts
type DeleteUserError = DeleteUserErrors[keyof DeleteUserErrors];
```

---

## Type Alias: DeleteUserErrors


```ts
type DeleteUserErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The user is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: DeleteUserResponse


```ts
type DeleteUserResponse = DeleteUserResponses[keyof DeleteUserResponses];
```

---

## Type Alias: DeleteUserResponses


```ts
type DeleteUserResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user was deleted successfully.

---

## Type Alias: DeploymentConfigurationResponse


```ts
type DeploymentConfigurationResponse = object;
```

Configuration for deployment characteristics.

## Properties

### isMultiTenancyEnabled

```ts
isMultiTenancyEnabled: boolean;
```

Whether multi-tenancy is enabled.

---

### maxRequestSize

```ts
maxRequestSize: number;
```

The maximum HTTP request size in bytes.

---

## Type Alias: DeploymentDecisionRequirementsResult


```ts
type DeploymentDecisionRequirementsResult = object;
```

Deployed decision requirements.

## Properties

### decisionRequirementsId

```ts
decisionRequirementsId: string;
```

The id of the deployed decision requirements.

---

### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The assigned decision requirements key, which acts as a unique identifier for this decision requirements.

---

### decisionRequirementsName

```ts
decisionRequirementsName: string;
```

The name of the deployed decision requirements.

---

### resourceName

```ts
resourceName: string;
```

The name of the resource.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the deployed decision requirements.

---

### version

```ts
version: number;
```

The version of the deployed decision requirements.

---

## Type Alias: DeploymentDecisionResult


```ts
type DeploymentDecisionResult = object;
```

A deployed decision.

## Properties

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId;
```

The dmn decision ID, as parsed during deployment, together with the version forms a
unique identifier for a specific decision.

---

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The assigned decision key, which acts as a unique identifier for this decision.

---

### decisionRequirementsId

```ts
decisionRequirementsId: string;
```

The dmn ID of the decision requirements graph that this decision is part of, as parsed during deployment.

---

### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The assigned key of the decision requirements graph that this decision is part of.

---

### name

```ts
name: string;
```

The DMN name of the decision, as parsed during deployment.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the deployed decision.

---

### version

```ts
version: number;
```

The assigned decision version.

---

## Type Alias: DeploymentFormResult


```ts
type DeploymentFormResult = object;
```

A deployed form.

## Properties

### formId

```ts
formId: FormId;
```

The form ID, as parsed during deployment, together with the version forms a
unique identifier for a specific form.

---

### formKey

```ts
formKey: FormKey;
```

The assigned key, which acts as a unique identifier for this form.

---

### resourceName

```ts
resourceName: string;
```

The name of the resource.

---

### tenantId

```ts
tenantId: TenantId;
```

---

### version

```ts
version: number;
```

The version of the deployed form.

---

## Type Alias: DeploymentKey


```ts
type DeploymentKey = CamundaKey<"DeploymentKey">;
```

Key for a deployment.

---

## Type Alias: DeploymentKeyExactMatch


```ts
type DeploymentKeyExactMatch = DeploymentKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: DeploymentKeyFilterProperty


```ts
type DeploymentKeyFilterProperty =
  DeploymentKeyExactMatch | AdvancedDeploymentKeyFilter;
```

DeploymentKey property with full advanced search capabilities.

---

## Type Alias: DeploymentMetadataResult


```ts
type DeploymentMetadataResult = object;
```

## Properties

### decisionDefinition

```ts
decisionDefinition: DeploymentDecisionResult | null;
```

Deployed decision.

---

### decisionRequirements

```ts
decisionRequirements:
  | DeploymentDecisionRequirementsResult
  | null;
```

Deployed decision requirement definition.

---

### form

```ts
form: DeploymentFormResult | null;
```

Deployed form.

---

### processDefinition

```ts
processDefinition: DeploymentProcessResult | null;
```

Deployed process.

---

### resource

```ts
resource: DeploymentResourceResult | null;
```

Deployed resource.

---

## Type Alias: DeploymentProcessResult


```ts
type DeploymentProcessResult = object;
```

A deployed process.

## Properties

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The bpmn process ID, as parsed during deployment, together with the version forms a
unique identifier for a specific process definition.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The assigned key, which acts as a unique identifier for this process.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The assigned process version.

---

### resourceName

```ts
resourceName: string;
```

The resource name from which this process was parsed.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the deployed process.

---

## Type Alias: DeploymentResourceResult


```ts
type DeploymentResourceResult = object;
```

A deployed Resource.

## Properties

### resourceId

```ts
resourceId: string;
```

The resource id of the deployed resource.

---

### resourceKey

```ts
resourceKey: ResourceKey;
```

The assigned key, which acts as a unique identifier for this Resource.

---

### resourceName

```ts
resourceName: string;
```

The name of the deployed resource.

---

### tenantId

```ts
tenantId: TenantId;
```

---

### version

```ts
version: number;
```

The description of the deployed resource.

---

## Type Alias: DeploymentResult


```ts
type DeploymentResult = object;
```

## Properties

### deploymentKey

```ts
deploymentKey: DeploymentKey;
```

The unique key identifying the deployment.

---

### deployments

```ts
deployments: DeploymentMetadataResult[];
```

Items deployed by the request.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID associated with the deployment.

---

## Type Alias: DirectAncestorKeyInstruction


```ts
type DirectAncestorKeyInstruction = object;
```

Provides a concrete key to use as ancestor scope for the created element instance.

## Properties

### ancestorElementInstanceKey

```ts
ancestorElementInstanceKey: ElementInstanceKey;
```

The key of the ancestor scope the element instance should be created in.
Set to -1 to create the new element instance within an existing element instance of the
flow scope. If multiple instances of the target element's flow scope exist, choose one
specifically with this property by providing its key.

---

### ancestorScopeType

```ts
ancestorScopeType: string;
```

The type of ancestor scope instruction.

---

## Type Alias: DocumentCreationBatchResponse


```ts
type DocumentCreationBatchResponse = object;
```

## Properties

### createdDocuments

```ts
createdDocuments: DocumentReference[];
```

Documents that failed creation.

---

### failedDocuments

```ts
failedDocuments: DocumentCreationFailureDetail[];
```

Documents that were successfully created.

---

## Type Alias: DocumentCreationFailureDetail


```ts
type DocumentCreationFailureDetail = object;
```

## Properties

### detail

```ts
detail: string;
```

A human-readable explanation specific to this occurrence of the problem.

---

### fileName

```ts
fileName: string;
```

The name of the file that failed to upload.

---

### status

```ts
status: number;
```

The HTTP status code of the failure.

---

### title

```ts
title: string;
```

A short, human-readable summary of the problem type.

---

## Type Alias: DocumentId


```ts
type DocumentId = CamundaKey<"DocumentId">;
```

Document Id that uniquely identifies a document.

---

## Type Alias: DocumentLink


```ts
type DocumentLink = object;
```

## Properties

### expiresAt

```ts
expiresAt: string;
```

The date and time when the link expires.

---

### url

```ts
url: string;
```

The link to the document.

---

## Type Alias: DocumentLinkRequest


```ts
type DocumentLinkRequest = object;
```

## Properties

### timeToLive?

```ts
optional timeToLive?: number;
```

The time-to-live of the document link in ms.

---

## Type Alias: DocumentMetadata


```ts
type DocumentMetadata = object;
```

Information about the document.

## Properties

### contentType?

```ts
optional contentType?: string;
```

The content type of the document.

---

### customProperties?

```ts
optional customProperties?: object;
```

Custom properties of the document.

#### Index Signature

```ts
[key: string]: unknown
```

---

### expiresAt?

```ts
optional expiresAt?: string;
```

The date and time when the document expires.

---

### fileName?

```ts
optional fileName?: string;
```

The name of the file.

---

### processDefinitionId?

```ts
optional processDefinitionId?: ProcessDefinitionId;
```

The ID of the process definition that created the document.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKey;
```

The key of the process instance that created the document.

---

### size?

```ts
optional size?: number;
```

The size of the document in bytes.

---

## Type Alias: DocumentMetadataResponse


```ts
type DocumentMetadataResponse = object;
```

Information about the document that is returned in responses.

## Properties

### contentType

```ts
contentType: string;
```

The content type of the document.

---

### customProperties

```ts
customProperties: object;
```

Custom properties of the document.

#### Index Signature

```ts
[key: string]: unknown
```

---

### expiresAt

```ts
expiresAt: string | null;
```

The date and time when the document expires.

---

### fileName

```ts
fileName: string;
```

The name of the file.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId | null;
```

The ID of the process definition that created the document.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey | null;
```

The key of the process instance that created the document.

---

### size

```ts
size: number;
```

The size of the document in bytes.

---

## Type Alias: DocumentReference


```ts
type DocumentReference = object;
```

## Properties

### camunda.document.type

```ts
camunda.document.type: "camunda";
```

Document discriminator. Always set to "camunda".

---

### contentHash

```ts
contentHash: string | null;
```

The hash of the document.

---

### documentId

```ts
documentId: DocumentId;
```

The ID of the document.

---

### metadata

```ts
metadata: DocumentMetadataResponse;
```

---

### storeId

```ts
storeId: string;
```

The ID of the document store.

---

## Type Alias: Either<E, A>

# Type Alias: Either\<E, A\>

```ts
type Either<E, A> = Left<E> | Right;
```

## Type Parameters

### E

`E`

### A

`A`

---

## Type Alias: ElementId


```ts
type ElementId = CamundaKey<"ElementId">;
```

The model-defined id of an element.

---

## Type Alias: ElementIdExactMatch


```ts
type ElementIdExactMatch = ElementId;
```

Exact match

Matches the value exactly.

---

## Type Alias: ElementIdFilterProperty


```ts
type ElementIdFilterProperty = ElementIdExactMatch | AdvancedElementIdFilter;
```

ElementId property with full advanced search capabilities.

---

## Type Alias: ElementInstanceFilter


```ts
type ElementInstanceFilter = ElementInstanceFilterFields & object;
```

Element instance search filter.

## Type Declaration

### $or?

```ts
optional $or?: ElementInstanceFilterFields[];
```

Defines a list of alternative filter groups combined using OR logic. Each object in the array is evaluated independently, and the filter matches if any one of them is satisfied.

Top-level fields and the `$or` clause are combined using AND logic — meaning: (top-level filters) AND (any of the `$or` filters) must match.

_Example:_

```json
{
  "processInstanceKey": "2251799813685323",
  "$or": [
    { "elementName": { "$like": "*Order*" } },
    { "elementId": { "$like": "*Order*" } }
  ]
}
```

This matches element instances scoped to the given process instance whose:

- `elementName` contains _Order_, or
- `elementId` contains _Order_

Note: Using complex `$or` conditions may impact performance, use with caution in high-volume environments.

---

## Type Alias: ElementInstanceFilterFields


```ts
type ElementInstanceFilterFields = object;
```

Element instance filter fields.

## Properties

### elementId?

```ts
optional elementId?: ElementIdFilterProperty;
```

The element ID for this element instance.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKey;
```

The assigned key, which acts as a unique identifier for this element instance.

---

### elementInstanceScopeKey?

```ts
optional elementInstanceScopeKey?:
  | ElementInstanceKey
  | ProcessInstanceKey;
```

The scope key of this element instance. If provided with a process instance key it will return element instances that are immediate children of the process instance. If provided with an element instance key it will return element instances that are immediate children of the element instance.

---

### elementName?

```ts
optional elementName?: StringFilterProperty;
```

The element name. This only works for data created with 8.8 and onwards. Instances from prior versions don't contain this data and cannot be found.

---

### endDate?

```ts
optional endDate?: DateTimeFilterProperty;
```

The end date of this element instance.

---

### hasIncident?

```ts
optional hasIncident?: boolean;
```

Shows whether this element instance has an incident related to.

---

### incidentKey?

```ts
optional incidentKey?: IncidentKey;
```

The key of incident if field incident is true.

---

### processDefinitionId?

```ts
optional processDefinitionId?: ProcessDefinitionId;
```

The process definition ID associated to this element instance.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKey;
```

The process definition key associated to this element instance.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKey;
```

The process instance key associated to this element instance.

---

### startDate?

```ts
optional startDate?: DateTimeFilterProperty;
```

The start date of this element instance.

---

### state?

```ts
optional state?: ElementInstanceStateFilterProperty;
```

State of element instance as defined set of values.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

---

### type?

```ts
optional type?:
  | "UNSPECIFIED"
  | "PROCESS"
  | "SUB_PROCESS"
  | "EVENT_SUB_PROCESS"
  | "AD_HOC_SUB_PROCESS"
  | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
  | "START_EVENT"
  | "INTERMEDIATE_CATCH_EVENT"
  | "INTERMEDIATE_THROW_EVENT"
  | "BOUNDARY_EVENT"
  | "END_EVENT"
  | "SERVICE_TASK"
  | "RECEIVE_TASK"
  | "USER_TASK"
  | "MANUAL_TASK"
  | "TASK"
  | "EXCLUSIVE_GATEWAY"
  | "INCLUSIVE_GATEWAY"
  | "PARALLEL_GATEWAY"
  | "EVENT_BASED_GATEWAY"
  | "SEQUENCE_FLOW"
  | "MULTI_INSTANCE_BODY"
  | "CALL_ACTIVITY"
  | "BUSINESS_RULE_TASK"
  | "SCRIPT_TASK"
  | "SEND_TASK"
  | "UNKNOWN";
```

Type of element as defined set of values.

---

## Type Alias: ElementInstanceKey


```ts
type ElementInstanceKey = CamundaKey<"ElementInstanceKey">;
```

System-generated key for a element instance.

---

## Type Alias: ElementInstanceKeyExactMatch


```ts
type ElementInstanceKeyExactMatch = ElementInstanceKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: ElementInstanceKeyFilterProperty


```ts
type ElementInstanceKeyFilterProperty =
  ElementInstanceKeyExactMatch | AdvancedElementInstanceKeyFilter;
```

ElementInstanceKey property with full advanced search capabilities.

---

## Type Alias: ElementInstanceResult


```ts
type ElementInstanceResult = object;
```

## Properties

### elementId

```ts
elementId: ElementId;
```

The element ID for this element instance.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The assigned key, which acts as a unique identifier for this element instance.

---

### elementName

```ts
elementName: string;
```

The element name for this element instance.

---

### endDate

```ts
endDate: string | null;
```

Date when element instance finished.

---

### hasIncident

```ts
hasIncident: boolean;
```

Shows whether this element instance has an incident. If true also an incidentKey is provided.

---

### incidentKey

```ts
incidentKey: IncidentKey | null;
```

Incident key associated with this element instance.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition ID associated to this element instance.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key associated to this element instance.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The process instance key associated to this element instance.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### startDate

```ts
startDate: string;
```

Date when element instance started.

---

### state

```ts
state: ElementInstanceStateEnum;
```

State of element instance as defined set of values.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the incident.

---

### type

```ts
type:
  | "UNSPECIFIED"
  | "PROCESS"
  | "SUB_PROCESS"
  | "EVENT_SUB_PROCESS"
  | "AD_HOC_SUB_PROCESS"
  | "AD_HOC_SUB_PROCESS_INNER_INSTANCE"
  | "START_EVENT"
  | "INTERMEDIATE_CATCH_EVENT"
  | "INTERMEDIATE_THROW_EVENT"
  | "BOUNDARY_EVENT"
  | "END_EVENT"
  | "SERVICE_TASK"
  | "RECEIVE_TASK"
  | "USER_TASK"
  | "MANUAL_TASK"
  | "TASK"
  | "EXCLUSIVE_GATEWAY"
  | "INCLUSIVE_GATEWAY"
  | "PARALLEL_GATEWAY"
  | "EVENT_BASED_GATEWAY"
  | "SEQUENCE_FLOW"
  | "MULTI_INSTANCE_BODY"
  | "CALL_ACTIVITY"
  | "BUSINESS_RULE_TASK"
  | "SCRIPT_TASK"
  | "SEND_TASK"
  | "UNKNOWN";
```

Type of element as defined set of values.

---

## Type Alias: ElementInstanceSearchQuery


```ts
type ElementInstanceSearchQuery = SearchQueryRequest & object;
```

Element instance search request.

## Type Declaration

### filter?

```ts
optional filter?: ElementInstanceFilter;
```

The element instance search filters.

### sort?

```ts
optional sort?: ElementInstanceSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ElementInstanceSearchQueryResult


```ts
type ElementInstanceSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: ElementInstanceResult[];
```

The matching element instances.

---

## Type Alias: ElementInstanceSearchQuerySortRequest


```ts
type ElementInstanceSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "elementInstanceKey"
  | "processInstanceKey"
  | "processDefinitionKey"
  | "processDefinitionId"
  | "startDate"
  | "endDate"
  | "elementId"
  | "elementName"
  | "type"
  | "state"
  | "incidentKey"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ElementInstanceStateEnum


```ts
type ElementInstanceStateEnum =
  (typeof ElementInstanceStateEnum)[keyof typeof ElementInstanceStateEnum];
```

Element states

---

## Type Alias: ElementInstanceStateExactMatch


```ts
type ElementInstanceStateExactMatch = ElementInstanceStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: ElementInstanceStateFilterProperty


```ts
type ElementInstanceStateFilterProperty =
  ElementInstanceStateExactMatch | AdvancedElementInstanceStateFilter;
```

ElementInstanceStateEnum property with full advanced search capabilities.

---

## Type Alias: ElementInstanceWaitStateFilter


```ts
type ElementInstanceWaitStateFilter = object;
```

Filters for the element instance inspection.

## Properties

### elementId?

```ts
optional elementId?: ElementIdFilterProperty;
```

Filter by element ID.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

Filter by element instance key.

---

### elementType?

```ts
optional elementType?: WaitStateElementTypeFilterProperty;
```

Filter by element type.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

Filter by process instance key.

---

### rootProcessInstanceKey?

```ts
optional rootProcessInstanceKey?: ProcessInstanceKeyFilterProperty;
```

Filter by root process instance key.

---

### waitStateType?

```ts
optional waitStateType?: WaitStateTypeFilterProperty;
```

Filter by wait state type.

---

## Type Alias: ElementInstanceWaitStateQuery


```ts
type ElementInstanceWaitStateQuery = SearchQueryRequest & object;
```

Element instance inspection request.

## Type Declaration

### filter?

```ts
optional filter?: ElementInstanceWaitStateFilter;
```

Filter criteria for the inspection.

### sort?

```ts
optional sort?: ElementInstanceWaitStateQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ElementInstanceWaitStateQueryResult


```ts
type ElementInstanceWaitStateQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: ElementInstanceWaitStateResult[];
```

The matching waiting states.

---

## Type Alias: ElementInstanceWaitStateQuerySortRequest


```ts
type ElementInstanceWaitStateQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "elementInstanceKey"
  | "processInstanceKey"
  | "rootProcessInstanceKey"
  | "elementId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ElementInstanceWaitStateResult


```ts
type ElementInstanceWaitStateResult = object;
```

An element instance waiting state.

## Properties

### bpmnProcessId

```ts
bpmnProcessId: string;
```

The BPMN process ID of the process definition associated to this element instance.

---

### details

```ts
details: WaitStateDetails;
```

Wait-state-specific details, resolved by waitStateType.

---

### elementId

```ts
elementId: ElementId;
```

The element ID for this element instance.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The element instance key associated to this element instance.

---

### elementType

```ts
elementType: WaitStateElementTypeEnum;
```

The BPMN element type of this element instance.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The process instance key associated to this element instance.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

Key of the root process instance.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the element instance.

---

## Type Alias: EndCursor


```ts
type EndCursor = CamundaKey<"EndCursor">;
```

The end cursor in a search query result set.

---

## Type Alias: EntityTypeExactMatch


```ts
type EntityTypeExactMatch = AuditLogEntityTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: EntityTypeFilterProperty


```ts
type EntityTypeFilterProperty = EntityTypeExactMatch | AdvancedEntityTypeFilter;
```

AuditLogEntityTypeEnum property with full advanced search capabilities.

---

## Type Alias: EvaluateConditionalResult


```ts
type EvaluateConditionalResult = object;
```

## Properties

### conditionalEvaluationKey

```ts
conditionalEvaluationKey: ConditionalEvaluationKey;
```

The unique key of the conditional evaluation operation.

---

### processInstances

```ts
processInstances: ProcessInstanceReference[];
```

List of process instances created. If no root-level conditional start events evaluated to true, the list will be empty.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the conditional evaluation operation.

---

## Type Alias: EvaluateConditionalsData


```ts
type EvaluateConditionalsData = object;
```

## Properties

### body

```ts
body: ConditionalEvaluationInstruction;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/conditionals/evaluation";
```

---

## Type Alias: EvaluateConditionalsError


```ts
type EvaluateConditionalsError =
  EvaluateConditionalsErrors[keyof EvaluateConditionalsErrors];
```

---

## Type Alias: EvaluateConditionalsErrors


```ts
type EvaluateConditionalsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

The client is not authorized to start process instances for the specified process definition.
If a processDefinitionKey is not provided, this indicates that the client is not authorized
to start process instances for at least one of the matched process definitions.

---

### 404

```ts
404: ProblemDetail;
```

The process definition was not found for the given processDefinitionKey.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: EvaluateConditionalsResponse


```ts
type EvaluateConditionalsResponse =
  EvaluateConditionalsResponses[keyof EvaluateConditionalsResponses];
```

---

## Type Alias: EvaluateConditionalsResponses


```ts
type EvaluateConditionalsResponses = object;
```

## Properties

### 200

```ts
200: EvaluateConditionalResult;
```

Successfully evaluated root-level conditional start events.

---

## Type Alias: EvaluateDecisionData


```ts
type EvaluateDecisionData = object;
```

## Properties

### body

```ts
body: DecisionEvaluationInstruction;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-definitions/evaluation";
```

---

## Type Alias: EvaluateDecisionError


```ts
type EvaluateDecisionError =
  EvaluateDecisionErrors[keyof EvaluateDecisionErrors];
```

---

## Type Alias: EvaluateDecisionErrors


```ts
type EvaluateDecisionErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The decision is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: EvaluateDecisionResponse


```ts
type EvaluateDecisionResponse =
  EvaluateDecisionResponses[keyof EvaluateDecisionResponses];
```

---

## Type Alias: EvaluateDecisionResponses


```ts
type EvaluateDecisionResponses = object;
```

## Properties

### 200

```ts
200: EvaluateDecisionResult;
```

The decision was evaluated.

---

## Type Alias: EvaluateDecisionResult


```ts
type EvaluateDecisionResult = object;
```

## Properties

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId;
```

The ID of the decision which was evaluated.

---

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The unique key identifying the decision which was evaluated.

---

### decisionDefinitionName

```ts
decisionDefinitionName: string;
```

The name of the decision which was evaluated.

---

### decisionDefinitionVersion

```ts
decisionDefinitionVersion: number;
```

The version of the decision which was evaluated.

---

### decisionEvaluationKey

```ts
decisionEvaluationKey: DecisionEvaluationKey;
```

The unique key identifying this decision evaluation.

---

### ~~decisionInstanceKey~~

```ts
decisionInstanceKey: DecisionInstanceKey;
```

Deprecated, please refer to `decisionEvaluationKey`.

#### Deprecated

---

### decisionRequirementsId

```ts
decisionRequirementsId: string;
```

The ID of the decision requirements graph that the decision which was evaluated is part of.

---

### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The unique key identifying the decision requirements graph that the decision which was evaluated is part of.

---

### evaluatedDecisions

```ts
evaluatedDecisions: EvaluatedDecisionResult[];
```

Decisions that were evaluated within the requested decision evaluation.

---

### failedDecisionDefinitionId

```ts
failedDecisionDefinitionId: DecisionDefinitionId | null;
```

The ID of the decision which failed during evaluation.

---

### failureMessage

```ts
failureMessage: string | null;
```

Message describing why the decision which was evaluated failed.

---

### output

```ts
output: string;
```

JSON document that will instantiate the result of the decision which was evaluated.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the evaluated decision.

---

## Type Alias: EvaluateExpressionData


```ts
type EvaluateExpressionData = object;
```

## Properties

### body

```ts
body: ExpressionEvaluationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/expression/evaluation";
```

---

## Type Alias: EvaluateExpressionError


```ts
type EvaluateExpressionError =
  EvaluateExpressionErrors[keyof EvaluateExpressionErrors];
```

---

## Type Alias: EvaluateExpressionErrors


```ts
type EvaluateExpressionErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: EvaluateExpressionResponse


```ts
type EvaluateExpressionResponse =
  EvaluateExpressionResponses[keyof EvaluateExpressionResponses];
```

---

## Type Alias: EvaluateExpressionResponses


```ts
type EvaluateExpressionResponses = object;
```

## Properties

### 200

```ts
200: ExpressionEvaluationResult;
```

Expression evaluated successfully

---

## Type Alias: EvaluatedDecisionInputItem


```ts
type EvaluatedDecisionInputItem = object;
```

A decision input that was evaluated within this decision evaluation.

## Properties

### inputId

```ts
inputId: string;
```

The identifier of the decision input.

---

### inputName

```ts
inputName: string;
```

The name of the decision input.

---

### inputValue

```ts
inputValue: string;
```

The value of the decision input.

---

## Type Alias: EvaluatedDecisionOutputItem


```ts
type EvaluatedDecisionOutputItem = object;
```

The evaluated decision outputs.

## Properties

### outputId

```ts
outputId: string;
```

The ID of the evaluated decison output item.

---

### outputName

```ts
outputName: string;
```

The name of the of the evaluated decison output item.

---

### outputValue

```ts
outputValue: string;
```

The value of the evaluated decison output item.

---

### ruleId

```ts
ruleId: string | null;
```

The ID of the matched rule.

---

### ruleIndex

```ts
ruleIndex: number | null;
```

The index of the matched rule.

---

## Type Alias: EvaluatedDecisionResult


```ts
type EvaluatedDecisionResult = object;
```

A decision that was evaluated.

## Properties

### decisionDefinitionId

```ts
decisionDefinitionId: DecisionDefinitionId;
```

The ID of the decision which was evaluated.

---

### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The unique key identifying the decision which was evaluate.

---

### decisionDefinitionName

```ts
decisionDefinitionName: string;
```

The name of the decision which was evaluated.

---

### decisionDefinitionType

```ts
decisionDefinitionType: string;
```

The type of the decision which was evaluated.

---

### decisionDefinitionVersion

```ts
decisionDefinitionVersion: number;
```

The version of the decision which was evaluated.

---

### decisionEvaluationInstanceKey

```ts
decisionEvaluationInstanceKey: DecisionEvaluationInstanceKey;
```

The unique key identifying this decision evaluation instance.

---

### evaluatedInputs

```ts
evaluatedInputs: EvaluatedDecisionInputItem[];
```

The decision inputs that were evaluated within this decision evaluation.

---

### matchedRules

```ts
matchedRules: MatchedDecisionRuleItem[];
```

The decision rules that matched within this decision evaluation.

---

### output

```ts
output: string;
```

JSON document that will instantiate the result of the decision which was evaluated.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the evaluated decision.

---

## Type Alias: ExpressionEvaluationRequest


```ts
type ExpressionEvaluationRequest = object;
```

## Properties

### expression

```ts
expression: string;
```

The expression to evaluate (e.g., "=x + y")

---

### scopeKey?

```ts
optional scopeKey?: ScopeKey;
```

Key of the process instance or element instance whose variables should be made visible
to the expression. Use a process instance key to evaluate against the process instance
scope, or an element instance key to evaluate against that element instance scope. If
omitted, the expression is evaluated unscoped, using only cluster variables
and request-body variables.

---

### tenantId?

```ts
optional tenantId?: string;
```

Required when the expression references tenant-scoped cluster variables

---

### variables?

```ts
optional variables?:
  | {
[key: string]: unknown;
}
  | null;
```

Optional variables for expression evaluation. These variables are only used for the current evaluation and do not persist beyond it.

---

## Type Alias: ExpressionEvaluationResult


```ts
type ExpressionEvaluationResult = object;
```

## Properties

### expression

```ts
expression: string;
```

The evaluated expression

---

### result

```ts
result: unknown;
```

The result value. Its type can vary.

---

### warnings

```ts
warnings: ExpressionEvaluationWarningItem[];
```

List of warnings generated during expression evaluation

---

## Type Alias: ExpressionEvaluationWarningItem


```ts
type ExpressionEvaluationWarningItem = object;
```

## Properties

### message

```ts
message: string;
```

The warning message

---

## Type Alias: FailJobData


```ts
type FailJobData = object;
```

## Properties

### body?

```ts
optional body?: JobFailRequest;
```

---

### path

```ts
path: object;
```

#### jobKey

```ts
jobKey: JobKey;
```

The key of the job to fail.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/{jobKey}/failure";
```

---

## Type Alias: FailJobError


```ts
type FailJobError = FailJobErrors[keyof FailJobErrors];
```

---

## Type Alias: FailJobErrors


```ts
type FailJobErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The job with the given jobKey is not found. It was completed by another worker, or the process instance itself was canceled.

---

### 409

```ts
409: ProblemDetail;
```

The job with the given key is in the wrong state (i.e: not ACTIVATED or ACTIVATABLE). The job was failed by another worker with retries = 0, and the process is now in an incident state.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: FailJobResponse


```ts
type FailJobResponse = FailJobResponses[keyof FailJobResponses];
```

---

## Type Alias: FailJobResponses


```ts
type FailJobResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The job is failed.

---

## Type Alias: FormId


```ts
type FormId = CamundaKey<"FormId">;
```

The user-defined id for the form

---

## Type Alias: FormKey


```ts
type FormKey = CamundaKey<"FormKey">;
```

System-generated key for a deployed form.

---

## Type Alias: FormKeyExactMatch


```ts
type FormKeyExactMatch = FormKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: FormKeyFilterProperty


```ts
type FormKeyFilterProperty = FormKeyExactMatch | AdvancedFormKeyFilter;
```

FormKey property with full advanced search capabilities.

---

## Type Alias: FormResult


```ts
type FormResult = object;
```

## Properties

### formId

```ts
formId: FormId;
```

The user-provided identifier of the form.

---

### formKey

```ts
formKey: FormKey;
```

The assigned key, which acts as a unique identifier for this form.

---

### schema

```ts
schema: string;
```

The form schema as a JSON document serialized as a string.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the form.

---

### version

```ts
version: number;
```

The version of the the deployed form.

---

## Type Alias: GetAgentInstanceData


```ts
type GetAgentInstanceData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The key of the agent instance to retrieve.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/agent-instances/{agentInstanceKey}";
```

---

## Type Alias: GetAgentInstanceError


```ts
type GetAgentInstanceError =
  GetAgentInstanceErrors[keyof GetAgentInstanceErrors];
```

---

## Type Alias: GetAgentInstanceErrors


```ts
type GetAgentInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The agent instance with the given key was not found.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: GetAgentInstanceResponse


```ts
type GetAgentInstanceResponse =
  GetAgentInstanceResponses[keyof GetAgentInstanceResponses];
```

---

## Type Alias: GetAgentInstanceResponses


```ts
type GetAgentInstanceResponses = object;
```

## Properties

### 200

```ts
200: AgentInstanceResult;
```

The agent instance is successfully returned.

---

## Type Alias: GetAuditLogData


```ts
type GetAuditLogData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### auditLogKey

```ts
auditLogKey: AuditLogKey;
```

The audit log key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/audit-logs/{auditLogKey}";
```

---

## Type Alias: GetAuditLogError


```ts
type GetAuditLogError = GetAuditLogErrors[keyof GetAuditLogErrors];
```

---

## Type Alias: GetAuditLogErrors


```ts
type GetAuditLogErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The audit log with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetAuditLogResponse


```ts
type GetAuditLogResponse = GetAuditLogResponses[keyof GetAuditLogResponses];
```

---

## Type Alias: GetAuditLogResponses


```ts
type GetAuditLogResponses = object;
```

## Properties

### 200

```ts
200: AuditLogResult;
```

The audit log entry is successfully returned.

---

## Type Alias: GetAuthenticationData


```ts
type GetAuthenticationData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/authentication/me";
```

---

## Type Alias: GetAuthenticationError


```ts
type GetAuthenticationError =
  GetAuthenticationErrors[keyof GetAuthenticationErrors];
```

---

## Type Alias: GetAuthenticationErrors


```ts
type GetAuthenticationErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetAuthenticationResponse


```ts
type GetAuthenticationResponse =
  GetAuthenticationResponses[keyof GetAuthenticationResponses];
```

---

## Type Alias: GetAuthenticationResponses


```ts
type GetAuthenticationResponses = object;
```

## Properties

### 200

```ts
200: CamundaUserResult;
```

The current user is successfully returned.

---

## Type Alias: GetAuthorizationData


```ts
type GetAuthorizationData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### authorizationKey

```ts
authorizationKey: AuthorizationKey;
```

The key of the authorization to get.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/authorizations/{authorizationKey}";
```

---

## Type Alias: GetAuthorizationError


```ts
type GetAuthorizationError =
  GetAuthorizationErrors[keyof GetAuthorizationErrors];
```

---

## Type Alias: GetAuthorizationErrors


```ts
type GetAuthorizationErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The authorization with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetAuthorizationResponse


```ts
type GetAuthorizationResponse =
  GetAuthorizationResponses[keyof GetAuthorizationResponses];
```

---

## Type Alias: GetAuthorizationResponses


```ts
type GetAuthorizationResponses = object;
```

## Properties

### 200

```ts
200: AuthorizationResult;
```

The authorization was successfully returned.

---

## Type Alias: GetBatchOperationData


```ts
type GetBatchOperationData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

The key (or operate legacy ID) of the batch operation.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/batch-operations/{batchOperationKey}";
```

---

## Type Alias: GetBatchOperationError


```ts
type GetBatchOperationError =
  GetBatchOperationErrors[keyof GetBatchOperationErrors];
```

---

## Type Alias: GetBatchOperationErrors


```ts
type GetBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The batch operation is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetBatchOperationResponse


```ts
type GetBatchOperationResponse =
  GetBatchOperationResponses[keyof GetBatchOperationResponses];
```

---

## Type Alias: GetBatchOperationResponses


```ts
type GetBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationResponse;
```

The batch operation was found.

---

## Type Alias: GetDecisionDefinitionData


```ts
type GetDecisionDefinitionData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The assigned key of the decision definition, which acts as a unique identifier for this decision.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-definitions/{decisionDefinitionKey}";
```

---

## Type Alias: GetDecisionDefinitionError


```ts
type GetDecisionDefinitionError =
  GetDecisionDefinitionErrors[keyof GetDecisionDefinitionErrors];
```

---

## Type Alias: GetDecisionDefinitionErrors


```ts
type GetDecisionDefinitionErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The decision definition with the given key was not found. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetDecisionDefinitionResponse


```ts
type GetDecisionDefinitionResponse =
  GetDecisionDefinitionResponses[keyof GetDecisionDefinitionResponses];
```

---

## Type Alias: GetDecisionDefinitionResponses


```ts
type GetDecisionDefinitionResponses = object;
```

## Properties

### 200

```ts
200: DecisionDefinitionResult;
```

The decision definition is successfully returned.

---

## Type Alias: GetDecisionDefinitionXmlData


```ts
type GetDecisionDefinitionXmlData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### decisionDefinitionKey

```ts
decisionDefinitionKey: DecisionDefinitionKey;
```

The assigned key of the decision definition, which acts as a unique identifier for this decision.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-definitions/{decisionDefinitionKey}/xml";
```

---

## Type Alias: GetDecisionDefinitionXmlError


```ts
type GetDecisionDefinitionXmlError =
  GetDecisionDefinitionXmlErrors[keyof GetDecisionDefinitionXmlErrors];
```

---

## Type Alias: GetDecisionDefinitionXmlErrors


```ts
type GetDecisionDefinitionXmlErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The decision definition with the given key was not found. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetDecisionDefinitionXmlResponse


```ts
type GetDecisionDefinitionXmlResponse =
  GetDecisionDefinitionXmlResponses[keyof GetDecisionDefinitionXmlResponses];
```

---

## Type Alias: GetDecisionDefinitionXmlResponses


```ts
type GetDecisionDefinitionXmlResponses = object;
```

## Properties

### 200

```ts
200: string;
```

The XML of the decision definition is successfully returned.

---

## Type Alias: GetDecisionInstanceData


```ts
type GetDecisionInstanceData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### decisionEvaluationInstanceKey

```ts
decisionEvaluationInstanceKey: DecisionEvaluationInstanceKey;
```

The assigned key of the decision instance, which acts as a unique identifier for this decision instance.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-instances/{decisionEvaluationInstanceKey}";
```

---

## Type Alias: GetDecisionInstanceError


```ts
type GetDecisionInstanceError =
  GetDecisionInstanceErrors[keyof GetDecisionInstanceErrors];
```

---

## Type Alias: GetDecisionInstanceErrors


```ts
type GetDecisionInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The decision instance with the given key was not found. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetDecisionInstanceResponse


```ts
type GetDecisionInstanceResponse =
  GetDecisionInstanceResponses[keyof GetDecisionInstanceResponses];
```

---

## Type Alias: GetDecisionInstanceResponses


```ts
type GetDecisionInstanceResponses = object;
```

## Properties

### 200

```ts
200: DecisionInstanceGetQueryResult;
```

The decision instance is successfully returned.

---

## Type Alias: GetDecisionRequirementsData


```ts
type GetDecisionRequirementsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The assigned key of the decision requirements, which acts as a unique identifier for this decision requirements.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-requirements/{decisionRequirementsKey}";
```

---

## Type Alias: GetDecisionRequirementsError


```ts
type GetDecisionRequirementsError =
  GetDecisionRequirementsErrors[keyof GetDecisionRequirementsErrors];
```

---

## Type Alias: GetDecisionRequirementsErrors


```ts
type GetDecisionRequirementsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The decision requirements with the given key was not found. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetDecisionRequirementsResponse


```ts
type GetDecisionRequirementsResponse =
  GetDecisionRequirementsResponses[keyof GetDecisionRequirementsResponses];
```

---

## Type Alias: GetDecisionRequirementsResponses


```ts
type GetDecisionRequirementsResponses = object;
```

## Properties

### 200

```ts
200: DecisionRequirementsResult;
```

The decision requirements is successfully returned.

---

## Type Alias: GetDecisionRequirementsXmlData


```ts
type GetDecisionRequirementsXmlData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### decisionRequirementsKey

```ts
decisionRequirementsKey: DecisionRequirementsKey;
```

The assigned key of the decision requirements, which acts as a unique identifier for this decision.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-requirements/{decisionRequirementsKey}/xml";
```

---

## Type Alias: GetDecisionRequirementsXmlError


```ts
type GetDecisionRequirementsXmlError =
  GetDecisionRequirementsXmlErrors[keyof GetDecisionRequirementsXmlErrors];
```

---

## Type Alias: GetDecisionRequirementsXmlErrors


```ts
type GetDecisionRequirementsXmlErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The decision requirements with the given key was not found. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetDecisionRequirementsXmlResponse


```ts
type GetDecisionRequirementsXmlResponse =
  GetDecisionRequirementsXmlResponses[keyof GetDecisionRequirementsXmlResponses];
```

---

## Type Alias: GetDecisionRequirementsXmlResponses


```ts
type GetDecisionRequirementsXmlResponses = object;
```

## Properties

### 200

```ts
200: string;
```

The XML of the decision requirements is successfully returned.

---

## Type Alias: GetDocumentData


```ts
type GetDocumentData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### documentId

```ts
documentId: DocumentId;
```

The ID of the document to download.

---

### query?

```ts
optional query?: object;
```

#### contentHash?

```ts
optional contentHash?: string;
```

The hash of the document content that was computed by the document store during upload. The hash is part of the document reference that is returned when uploading a document. If the client fails to provide the correct hash, the request will be rejected.

#### storeId?

```ts
optional storeId?: string;
```

The ID of the document store to download the document from.

---

### url

```ts
url: "/documents/{documentId}";
```

---

## Type Alias: GetDocumentError


```ts
type GetDocumentError = GetDocumentErrors[keyof GetDocumentErrors];
```

---

## Type Alias: GetDocumentErrors


```ts
type GetDocumentErrors = object;
```

## Properties

### 404

```ts
404: ProblemDetail;
```

The document with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetDocumentResponse


```ts
type GetDocumentResponse = GetDocumentResponses[keyof GetDocumentResponses];
```

---

## Type Alias: GetDocumentResponses


```ts
type GetDocumentResponses = object;
```

## Properties

### 200

```ts
200: Blob | File;
```

The document was downloaded successfully.

---

## Type Alias: GetElementInstanceData


```ts
type GetElementInstanceData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The assigned key of the element instance, which acts as a unique identifier for this element instance.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/element-instances/{elementInstanceKey}";
```

---

## Type Alias: GetElementInstanceError


```ts
type GetElementInstanceError =
  GetElementInstanceErrors[keyof GetElementInstanceErrors];
```

---

## Type Alias: GetElementInstanceErrors


```ts
type GetElementInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The element instance with the given key was not found.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetElementInstanceResponse


```ts
type GetElementInstanceResponse =
  GetElementInstanceResponses[keyof GetElementInstanceResponses];
```

---

## Type Alias: GetElementInstanceResponses


```ts
type GetElementInstanceResponses = object;
```

## Properties

### 200

```ts
200: ElementInstanceResult;
```

The element instance is successfully returned.

---

## Type Alias: GetFormByKeyData


```ts
type GetFormByKeyData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### formKey

```ts
formKey: FormKey;
```

The form key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/forms/{formKey}";
```

---

## Type Alias: GetFormByKeyError


```ts
type GetFormByKeyError = GetFormByKeyErrors[keyof GetFormByKeyErrors];
```

---

## Type Alias: GetFormByKeyErrors


```ts
type GetFormByKeyErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The form with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetFormByKeyResponse


```ts
type GetFormByKeyResponse = GetFormByKeyResponses[keyof GetFormByKeyResponses];
```

---

## Type Alias: GetFormByKeyResponses


```ts
type GetFormByKeyResponses = object;
```

## Properties

### 200

```ts
200: FormResult;
```

The form is successfully returned.

---

## Type Alias: GetGlobalClusterVariableData


```ts
type GetGlobalClusterVariableData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/global/{name}";
```

---

## Type Alias: GetGlobalClusterVariableError


```ts
type GetGlobalClusterVariableError =
  GetGlobalClusterVariableErrors[keyof GetGlobalClusterVariableErrors];
```

---

## Type Alias: GetGlobalClusterVariableErrors


```ts
type GetGlobalClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Cluster variable not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetGlobalClusterVariableResponse


```ts
type GetGlobalClusterVariableResponse =
  GetGlobalClusterVariableResponses[keyof GetGlobalClusterVariableResponses];
```

---

## Type Alias: GetGlobalClusterVariableResponses


```ts
type GetGlobalClusterVariableResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableResult;
```

Cluster variable found

---

## Type Alias: GetGlobalJobStatisticsData


```ts
type GetGlobalJobStatisticsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query

```ts
query: object;
```

#### from

```ts
from: string;
```

Start of the time window to filter metrics. ISO 8601 date-time format.

#### jobType?

```ts
optional jobType?: string;
```

Optional job type to limit the aggregation to a single job type.

#### to

```ts
to: string;
```

End of the time window to filter metrics. ISO 8601 date-time format.

---

### url

```ts
url: "/jobs/statistics/global";
```

---

## Type Alias: GetGlobalJobStatisticsError


```ts
type GetGlobalJobStatisticsError =
  GetGlobalJobStatisticsErrors[keyof GetGlobalJobStatisticsErrors];
```

---

## Type Alias: GetGlobalJobStatisticsErrors


```ts
type GetGlobalJobStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetGlobalJobStatisticsResponse


```ts
type GetGlobalJobStatisticsResponse =
  GetGlobalJobStatisticsResponses[keyof GetGlobalJobStatisticsResponses];
```

---

## Type Alias: GetGlobalJobStatisticsResponses


```ts
type GetGlobalJobStatisticsResponses = object;
```

## Properties

### 200

```ts
200: GlobalJobStatisticsQueryResult;
```

Global job metrics

---

## Type Alias: GetGlobalTaskListenerData


```ts
type GetGlobalTaskListenerData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### id

```ts
id: GlobalListenerId;
```

The id of the global user task listener.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/global-task-listeners/{id}";
```

---

## Type Alias: GetGlobalTaskListenerError


```ts
type GetGlobalTaskListenerError =
  GetGlobalTaskListenerErrors[keyof GetGlobalTaskListenerErrors];
```

---

## Type Alias: GetGlobalTaskListenerErrors


```ts
type GetGlobalTaskListenerErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The global user task listener with the given id was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetGlobalTaskListenerResponse


```ts
type GetGlobalTaskListenerResponse =
  GetGlobalTaskListenerResponses[keyof GetGlobalTaskListenerResponses];
```

---

## Type Alias: GetGlobalTaskListenerResponses


```ts
type GetGlobalTaskListenerResponses = object;
```

## Properties

### 200

```ts
200: GlobalTaskListenerResult;
```

The global user task listener is successfully returned.

---

## Type Alias: GetGroupData


```ts
type GetGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}";
```

---

## Type Alias: GetGroupError


```ts
type GetGroupError = GetGroupErrors[keyof GetGroupErrors];
```

---

## Type Alias: GetGroupErrors


```ts
type GetGroupErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetGroupResponse


```ts
type GetGroupResponse = GetGroupResponses[keyof GetGroupResponses];
```

---

## Type Alias: GetGroupResponses


```ts
type GetGroupResponses = object;
```

## Properties

### 200

```ts
200: GroupResult;
```

The group is successfully returned.

---

## Type Alias: GetIncidentData


```ts
type GetIncidentData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### incidentKey

```ts
incidentKey: IncidentKey;
```

The assigned key of the incident, which acts as a unique identifier for this incident.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/incidents/{incidentKey}";
```

---

## Type Alias: GetIncidentError


```ts
type GetIncidentError = GetIncidentErrors[keyof GetIncidentErrors];
```

---

## Type Alias: GetIncidentErrors


```ts
type GetIncidentErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The incident with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetIncidentResponse


```ts
type GetIncidentResponse = GetIncidentResponses[keyof GetIncidentResponses];
```

---

## Type Alias: GetIncidentResponses


```ts
type GetIncidentResponses = object;
```

## Properties

### 200

```ts
200: IncidentResult;
```

The incident is successfully returned.

---

## Type Alias: GetJobErrorStatisticsData


```ts
type GetJobErrorStatisticsData = object;
```

## Properties

### body

```ts
body: JobErrorStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/statistics/errors";
```

---

## Type Alias: GetJobErrorStatisticsError


```ts
type GetJobErrorStatisticsError =
  GetJobErrorStatisticsErrors[keyof GetJobErrorStatisticsErrors];
```

---

## Type Alias: GetJobErrorStatisticsErrors


```ts
type GetJobErrorStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetJobErrorStatisticsResponse


```ts
type GetJobErrorStatisticsResponse =
  GetJobErrorStatisticsResponses[keyof GetJobErrorStatisticsResponses];
```

---

## Type Alias: GetJobErrorStatisticsResponses


```ts
type GetJobErrorStatisticsResponses = object;
```

## Properties

### 200

```ts
200: JobErrorStatisticsQueryResult;
```

The job error statistics result.

---

## Type Alias: GetJobTimeSeriesStatisticsData


```ts
type GetJobTimeSeriesStatisticsData = object;
```

## Properties

### body

```ts
body: JobTimeSeriesStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/statistics/time-series";
```

---

## Type Alias: GetJobTimeSeriesStatisticsError


```ts
type GetJobTimeSeriesStatisticsError =
  GetJobTimeSeriesStatisticsErrors[keyof GetJobTimeSeriesStatisticsErrors];
```

---

## Type Alias: GetJobTimeSeriesStatisticsErrors


```ts
type GetJobTimeSeriesStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetJobTimeSeriesStatisticsResponse


```ts
type GetJobTimeSeriesStatisticsResponse =
  GetJobTimeSeriesStatisticsResponses[keyof GetJobTimeSeriesStatisticsResponses];
```

---

## Type Alias: GetJobTimeSeriesStatisticsResponses


```ts
type GetJobTimeSeriesStatisticsResponses = object;
```

## Properties

### 200

```ts
200: JobTimeSeriesStatisticsQueryResult;
```

The job time-series statistics result.

---

## Type Alias: GetJobTypeStatisticsData


```ts
type GetJobTypeStatisticsData = object;
```

## Properties

### body

```ts
body: JobTypeStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/statistics/by-types";
```

---

## Type Alias: GetJobTypeStatisticsError


```ts
type GetJobTypeStatisticsError =
  GetJobTypeStatisticsErrors[keyof GetJobTypeStatisticsErrors];
```

---

## Type Alias: GetJobTypeStatisticsErrors


```ts
type GetJobTypeStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetJobTypeStatisticsResponse


```ts
type GetJobTypeStatisticsResponse =
  GetJobTypeStatisticsResponses[keyof GetJobTypeStatisticsResponses];
```

---

## Type Alias: GetJobTypeStatisticsResponses


```ts
type GetJobTypeStatisticsResponses = object;
```

## Properties

### 200

```ts
200: JobTypeStatisticsQueryResult;
```

The job type statistics result.

---

## Type Alias: GetJobWorkerStatisticsData


```ts
type GetJobWorkerStatisticsData = object;
```

## Properties

### body

```ts
body: JobWorkerStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/statistics/by-workers";
```

---

## Type Alias: GetJobWorkerStatisticsError


```ts
type GetJobWorkerStatisticsError =
  GetJobWorkerStatisticsErrors[keyof GetJobWorkerStatisticsErrors];
```

---

## Type Alias: GetJobWorkerStatisticsErrors


```ts
type GetJobWorkerStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetJobWorkerStatisticsResponse


```ts
type GetJobWorkerStatisticsResponse =
  GetJobWorkerStatisticsResponses[keyof GetJobWorkerStatisticsResponses];
```

---

## Type Alias: GetJobWorkerStatisticsResponses


```ts
type GetJobWorkerStatisticsResponses = object;
```

## Properties

### 200

```ts
200: JobWorkerStatisticsQueryResult;
```

The job worker statistics result.

---

## Type Alias: GetLicenseData


```ts
type GetLicenseData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/license";
```

---

## Type Alias: GetLicenseError


```ts
type GetLicenseError = GetLicenseErrors[keyof GetLicenseErrors];
```

---

## Type Alias: GetLicenseErrors


```ts
type GetLicenseErrors = object;
```

## Properties

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetLicenseResponse


```ts
type GetLicenseResponse = GetLicenseResponses[keyof GetLicenseResponses];
```

---

## Type Alias: GetLicenseResponses


```ts
type GetLicenseResponses = object;
```

## Properties

### 200

```ts
200: LicenseResponse;
```

Obtains the current status of the Camunda license.

---

## Type Alias: GetMappingRuleData


```ts
type GetMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The ID of the mapping rule to get.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: GetMappingRuleError


```ts
type GetMappingRuleError = GetMappingRuleErrors[keyof GetMappingRuleErrors];
```

---

## Type Alias: GetMappingRuleErrors


```ts
type GetMappingRuleErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The mapping rule with the mappingRuleId was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetMappingRuleResponse


```ts
type GetMappingRuleResponse =
  GetMappingRuleResponses[keyof GetMappingRuleResponses];
```

---

## Type Alias: GetMappingRuleResponses


```ts
type GetMappingRuleResponses = object;
```

## Properties

### 200

```ts
200: MappingRuleResult;
```

The mapping rule was returned successfully.

---

## Type Alias: GetProcessDefinitionData


```ts
type GetProcessDefinitionData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The assigned key of the process definition, which acts as a unique identifier for this process definition.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/{processDefinitionKey}";
```

---

## Type Alias: GetProcessDefinitionError


```ts
type GetProcessDefinitionError =
  GetProcessDefinitionErrors[keyof GetProcessDefinitionErrors];
```

---

## Type Alias: GetProcessDefinitionErrors


```ts
type GetProcessDefinitionErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The process definition with the given key was not found. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessDefinitionInstanceStatisticsData


```ts
type GetProcessDefinitionInstanceStatisticsData = object;
```

## Properties

### body?

```ts
optional body?: ProcessDefinitionInstanceStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/statistics/process-instances";
```

---

## Type Alias: GetProcessDefinitionInstanceStatisticsError


```ts
type GetProcessDefinitionInstanceStatisticsError =
  GetProcessDefinitionInstanceStatisticsErrors[keyof GetProcessDefinitionInstanceStatisticsErrors];
```

---

## Type Alias: GetProcessDefinitionInstanceStatisticsErrors


```ts
type GetProcessDefinitionInstanceStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessDefinitionInstanceStatisticsResponse


```ts
type GetProcessDefinitionInstanceStatisticsResponse =
  GetProcessDefinitionInstanceStatisticsResponses[keyof GetProcessDefinitionInstanceStatisticsResponses];
```

---

## Type Alias: GetProcessDefinitionInstanceStatisticsResponses


```ts
type GetProcessDefinitionInstanceStatisticsResponses = object;
```

## Properties

### 200

```ts
200: ProcessDefinitionInstanceStatisticsQueryResult;
```

The process definition instance statistic result.

---

## Type Alias: GetProcessDefinitionInstanceVersionStatisticsData


```ts
type GetProcessDefinitionInstanceVersionStatisticsData = object;
```

## Properties

### body

```ts
body: ProcessDefinitionInstanceVersionStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/statistics/process-instances-by-version";
```

---

## Type Alias: GetProcessDefinitionInstanceVersionStatisticsError


```ts
type GetProcessDefinitionInstanceVersionStatisticsError =
  GetProcessDefinitionInstanceVersionStatisticsErrors[keyof GetProcessDefinitionInstanceVersionStatisticsErrors];
```

---

## Type Alias: GetProcessDefinitionInstanceVersionStatisticsErrors


```ts
type GetProcessDefinitionInstanceVersionStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessDefinitionInstanceVersionStatisticsResponse


```ts
type GetProcessDefinitionInstanceVersionStatisticsResponse =
  GetProcessDefinitionInstanceVersionStatisticsResponses[keyof GetProcessDefinitionInstanceVersionStatisticsResponses];
```

---

## Type Alias: GetProcessDefinitionInstanceVersionStatisticsResponses


```ts
type GetProcessDefinitionInstanceVersionStatisticsResponses = object;
```

## Properties

### 200

```ts
200: ProcessDefinitionInstanceVersionStatisticsQueryResult;
```

The process definition instance version statistic result.

---

## Type Alias: GetProcessDefinitionMessageSubscriptionStatisticsData


```ts
type GetProcessDefinitionMessageSubscriptionStatisticsData = object;
```

## Properties

### body?

```ts
optional body?: ProcessDefinitionMessageSubscriptionStatisticsQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/statistics/message-subscriptions";
```

---

## Type Alias: GetProcessDefinitionMessageSubscriptionStatisticsError


```ts
type GetProcessDefinitionMessageSubscriptionStatisticsError =
  GetProcessDefinitionMessageSubscriptionStatisticsErrors[keyof GetProcessDefinitionMessageSubscriptionStatisticsErrors];
```

---

## Type Alias: GetProcessDefinitionMessageSubscriptionStatisticsErrors


```ts
type GetProcessDefinitionMessageSubscriptionStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessDefinitionMessageSubscriptionStatisticsResponse


```ts
type GetProcessDefinitionMessageSubscriptionStatisticsResponse =
  GetProcessDefinitionMessageSubscriptionStatisticsResponses[keyof GetProcessDefinitionMessageSubscriptionStatisticsResponses];
```

---

## Type Alias: GetProcessDefinitionMessageSubscriptionStatisticsResponses


```ts
type GetProcessDefinitionMessageSubscriptionStatisticsResponses = object;
```

## Properties

### 200

```ts
200: ProcessDefinitionMessageSubscriptionStatisticsQueryResult;
```

The process definition message subscription statistics result.

---

## Type Alias: GetProcessDefinitionResponse


```ts
type GetProcessDefinitionResponse =
  GetProcessDefinitionResponses[keyof GetProcessDefinitionResponses];
```

---

## Type Alias: GetProcessDefinitionResponses


```ts
type GetProcessDefinitionResponses = object;
```

## Properties

### 200

```ts
200: ProcessDefinitionResult;
```

The process definition is successfully returned.

---

## Type Alias: GetProcessDefinitionStatisticsData


```ts
type GetProcessDefinitionStatisticsData = object;
```

## Properties

### body?

```ts
optional body?: ProcessDefinitionElementStatisticsQuery;
```

---

### path

```ts
path: object;
```

#### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The assigned key of the process definition, which acts as a unique identifier for this process definition.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/{processDefinitionKey}/statistics/element-instances";
```

---

## Type Alias: GetProcessDefinitionStatisticsError


```ts
type GetProcessDefinitionStatisticsError =
  GetProcessDefinitionStatisticsErrors[keyof GetProcessDefinitionStatisticsErrors];
```

---

## Type Alias: GetProcessDefinitionStatisticsErrors


```ts
type GetProcessDefinitionStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessDefinitionStatisticsResponse


```ts
type GetProcessDefinitionStatisticsResponse =
  GetProcessDefinitionStatisticsResponses[keyof GetProcessDefinitionStatisticsResponses];
```

---

## Type Alias: GetProcessDefinitionStatisticsResponses


```ts
type GetProcessDefinitionStatisticsResponses = object;
```

## Properties

### 200

```ts
200: ProcessDefinitionElementStatisticsQueryResult;
```

The process definition statistics result.

---

## Type Alias: GetProcessDefinitionXmlData


```ts
type GetProcessDefinitionXmlData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The assigned key of the process definition, which acts as a unique identifier for this process definition.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/{processDefinitionKey}/xml";
```

---

## Type Alias: GetProcessDefinitionXmlError


```ts
type GetProcessDefinitionXmlError =
  GetProcessDefinitionXmlErrors[keyof GetProcessDefinitionXmlErrors];
```

---

## Type Alias: GetProcessDefinitionXmlErrors


```ts
type GetProcessDefinitionXmlErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The process definition with the given key was not found.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessDefinitionXmlResponse


```ts
type GetProcessDefinitionXmlResponse =
  GetProcessDefinitionXmlResponses[keyof GetProcessDefinitionXmlResponses];
```

---

## Type Alias: GetProcessDefinitionXmlResponses


```ts
type GetProcessDefinitionXmlResponses = object;
```

## Properties

### 200

```ts
200: string;
```

The XML of the process definition is successfully returned.

---

### 204

```ts
204: string;
```

The process definition was found but does not have XML.

---

## Type Alias: GetProcessInstanceCallHierarchyData


```ts
type GetProcessInstanceCallHierarchyData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance to fetch the hierarchy for.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/call-hierarchy";
```

---

## Type Alias: GetProcessInstanceCallHierarchyError


```ts
type GetProcessInstanceCallHierarchyError =
  GetProcessInstanceCallHierarchyErrors[keyof GetProcessInstanceCallHierarchyErrors];
```

---

## Type Alias: GetProcessInstanceCallHierarchyErrors


```ts
type GetProcessInstanceCallHierarchyErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The process instance is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceCallHierarchyResponse


```ts
type GetProcessInstanceCallHierarchyResponse =
  GetProcessInstanceCallHierarchyResponses[keyof GetProcessInstanceCallHierarchyResponses];
```

---

## Type Alias: GetProcessInstanceCallHierarchyResponses


```ts
type GetProcessInstanceCallHierarchyResponses = object;
```

## Properties

### 200

```ts
200: ProcessInstanceCallHierarchyEntry[];
```

The call hierarchy is successfully returned.

---

## Type Alias: GetProcessInstanceData


```ts
type GetProcessInstanceData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The process instance key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}";
```

---

## Type Alias: GetProcessInstanceError


```ts
type GetProcessInstanceError =
  GetProcessInstanceErrors[keyof GetProcessInstanceErrors];
```

---

## Type Alias: GetProcessInstanceErrors


```ts
type GetProcessInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The process instance with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceResponse


```ts
type GetProcessInstanceResponse =
  GetProcessInstanceResponses[keyof GetProcessInstanceResponses];
```

---

## Type Alias: GetProcessInstanceResponses


```ts
type GetProcessInstanceResponses = object;
```

## Properties

### 200

```ts
200: ProcessInstanceResult;
```

The process instance is successfully returned.

---

## Type Alias: GetProcessInstanceSequenceFlowsData


```ts
type GetProcessInstanceSequenceFlowsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The assigned key of the process instance, which acts as a unique identifier for this process instance.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/sequence-flows";
```

---

## Type Alias: GetProcessInstanceSequenceFlowsError


```ts
type GetProcessInstanceSequenceFlowsError =
  GetProcessInstanceSequenceFlowsErrors[keyof GetProcessInstanceSequenceFlowsErrors];
```

---

## Type Alias: GetProcessInstanceSequenceFlowsErrors


```ts
type GetProcessInstanceSequenceFlowsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceSequenceFlowsResponse


```ts
type GetProcessInstanceSequenceFlowsResponse =
  GetProcessInstanceSequenceFlowsResponses[keyof GetProcessInstanceSequenceFlowsResponses];
```

---

## Type Alias: GetProcessInstanceSequenceFlowsResponses


```ts
type GetProcessInstanceSequenceFlowsResponses = object;
```

## Properties

### 200

```ts
200: ProcessInstanceSequenceFlowsQueryResult;
```

The process instance sequence flows result.

---

## Type Alias: GetProcessInstanceStatisticsByDefinitionData


```ts
type GetProcessInstanceStatisticsByDefinitionData = object;
```

## Properties

### body

```ts
body: IncidentProcessInstanceStatisticsByDefinitionQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/incidents/statistics/process-instances-by-definition";
```

---

## Type Alias: GetProcessInstanceStatisticsByDefinitionError


```ts
type GetProcessInstanceStatisticsByDefinitionError =
  GetProcessInstanceStatisticsByDefinitionErrors[keyof GetProcessInstanceStatisticsByDefinitionErrors];
```

---

## Type Alias: GetProcessInstanceStatisticsByDefinitionErrors


```ts
type GetProcessInstanceStatisticsByDefinitionErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceStatisticsByDefinitionResponse


```ts
type GetProcessInstanceStatisticsByDefinitionResponse =
  GetProcessInstanceStatisticsByDefinitionResponses[keyof GetProcessInstanceStatisticsByDefinitionResponses];
```

---

## Type Alias: GetProcessInstanceStatisticsByDefinitionResponses


```ts
type GetProcessInstanceStatisticsByDefinitionResponses = object;
```

## Properties

### 200

```ts
200: IncidentProcessInstanceStatisticsByDefinitionQueryResult;
```

The process instance incident statistics grouped by process definition are successfully
returned.

---

## Type Alias: GetProcessInstanceStatisticsByErrorData


```ts
type GetProcessInstanceStatisticsByErrorData = object;
```

## Properties

### body?

```ts
optional body?: IncidentProcessInstanceStatisticsByErrorQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/incidents/statistics/process-instances-by-error";
```

---

## Type Alias: GetProcessInstanceStatisticsByErrorError


```ts
type GetProcessInstanceStatisticsByErrorError =
  GetProcessInstanceStatisticsByErrorErrors[keyof GetProcessInstanceStatisticsByErrorErrors];
```

---

## Type Alias: GetProcessInstanceStatisticsByErrorErrors


```ts
type GetProcessInstanceStatisticsByErrorErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceStatisticsByErrorResponse


```ts
type GetProcessInstanceStatisticsByErrorResponse =
  GetProcessInstanceStatisticsByErrorResponses[keyof GetProcessInstanceStatisticsByErrorResponses];
```

---

## Type Alias: GetProcessInstanceStatisticsByErrorResponses


```ts
type GetProcessInstanceStatisticsByErrorResponses = object;
```

## Properties

### 200

```ts
200: IncidentProcessInstanceStatisticsByErrorQueryResult;
```

The statistics about process instances with incident, grouped by error hash code are
successfully returned.

---

## Type Alias: GetProcessInstanceStatisticsData


```ts
type GetProcessInstanceStatisticsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The assigned key of the process instance, which acts as a unique identifier for this process instance.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/statistics/element-instances";
```

---

## Type Alias: GetProcessInstanceStatisticsError


```ts
type GetProcessInstanceStatisticsError =
  GetProcessInstanceStatisticsErrors[keyof GetProcessInstanceStatisticsErrors];
```

---

## Type Alias: GetProcessInstanceStatisticsErrors


```ts
type GetProcessInstanceStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceStatisticsResponse


```ts
type GetProcessInstanceStatisticsResponse =
  GetProcessInstanceStatisticsResponses[keyof GetProcessInstanceStatisticsResponses];
```

---

## Type Alias: GetProcessInstanceStatisticsResponses


```ts
type GetProcessInstanceStatisticsResponses = object;
```

## Properties

### 200

```ts
200: ProcessInstanceElementStatisticsQueryResult;
```

The process instance statistics result.

---

## Type Alias: GetProcessInstanceWaitStateStatisticsData


```ts
type GetProcessInstanceWaitStateStatisticsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The assigned key of the process instance, which acts as a unique identifier for this process instance.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/statistics/wait-states";
```

---

## Type Alias: GetProcessInstanceWaitStateStatisticsError


```ts
type GetProcessInstanceWaitStateStatisticsError =
  GetProcessInstanceWaitStateStatisticsErrors[keyof GetProcessInstanceWaitStateStatisticsErrors];
```

---

## Type Alias: GetProcessInstanceWaitStateStatisticsErrors


```ts
type GetProcessInstanceWaitStateStatisticsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetProcessInstanceWaitStateStatisticsResponse


```ts
type GetProcessInstanceWaitStateStatisticsResponse =
  GetProcessInstanceWaitStateStatisticsResponses[keyof GetProcessInstanceWaitStateStatisticsResponses];
```

---

## Type Alias: GetProcessInstanceWaitStateStatisticsResponses


```ts
type GetProcessInstanceWaitStateStatisticsResponses = object;
```

## Properties

### 200

```ts
200: ProcessInstanceWaitStateStatisticsQueryResult;
```

The process instance wait state statistics result.

---

## Type Alias: GetResourceContentBinaryData


```ts
type GetResourceContentBinaryData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### resourceKey

```ts
resourceKey: ResourceKey;
```

The unique key identifying the resource.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/resources/{resourceKey}/content/binary";
```

---

## Type Alias: GetResourceContentBinaryError


```ts
type GetResourceContentBinaryError =
  GetResourceContentBinaryErrors[keyof GetResourceContentBinaryErrors];
```

---

## Type Alias: GetResourceContentBinaryErrors


```ts
type GetResourceContentBinaryErrors = object;
```

## Properties

### 404

```ts
404: ProblemDetail;
```

A resource with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetResourceContentBinaryResponse


```ts
type GetResourceContentBinaryResponse =
  GetResourceContentBinaryResponses[keyof GetResourceContentBinaryResponses];
```

---

## Type Alias: GetResourceContentBinaryResponses


```ts
type GetResourceContentBinaryResponses = object;
```

## Properties

### 200

```ts
200: Blob | File;
```

The resource content is successfully returned.

---

## Type Alias: GetResourceContentData


```ts
type GetResourceContentData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### resourceKey

```ts
resourceKey: ResourceKey;
```

The unique key identifying the RPA resource.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/resources/{resourceKey}/content";
```

---

## Type Alias: GetResourceContentError


```ts
type GetResourceContentError =
  GetResourceContentErrors[keyof GetResourceContentErrors];
```

---

## Type Alias: GetResourceContentErrors


```ts
type GetResourceContentErrors = object;
```

## Properties

### 404

```ts
404: ProblemDetail;
```

A resource with the given key was not found.

---

### 406

```ts
406: ProblemDetail;
```

The resource exists but is not an RPA resource.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetResourceContentResponse


```ts
type GetResourceContentResponse =
  GetResourceContentResponses[keyof GetResourceContentResponses];
```

---

## Type Alias: GetResourceContentResponses


```ts
type GetResourceContentResponses = object;
```

## Properties

### 200

```ts
200: object;
```

The resource content is successfully returned.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: GetResourceData


```ts
type GetResourceData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### resourceKey

```ts
resourceKey: ResourceKey;
```

The unique key identifying the resource.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/resources/{resourceKey}";
```

---

## Type Alias: GetResourceError


```ts
type GetResourceError = GetResourceErrors[keyof GetResourceErrors];
```

---

## Type Alias: GetResourceErrors


```ts
type GetResourceErrors = object;
```

## Properties

### 404

```ts
404: ProblemDetail;
```

A resource with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetResourceResponse


```ts
type GetResourceResponse = GetResourceResponses[keyof GetResourceResponses];
```

---

## Type Alias: GetResourceResponses


```ts
type GetResourceResponses = object;
```

## Properties

### 200

```ts
200: ResourceResult;
```

The resource is successfully returned.

---

## Type Alias: GetRoleData


```ts
type GetRoleData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}";
```

---

## Type Alias: GetRoleError


```ts
type GetRoleError = GetRoleErrors[keyof GetRoleErrors];
```

---

## Type Alias: GetRoleErrors


```ts
type GetRoleErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetRoleResponse


```ts
type GetRoleResponse = GetRoleResponses[keyof GetRoleResponses];
```

---

## Type Alias: GetRoleResponses


```ts
type GetRoleResponses = object;
```

## Properties

### 200

```ts
200: RoleResult;
```

The role is successfully returned.

---

## Type Alias: GetStartProcessFormData


```ts
type GetStartProcessFormData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/{processDefinitionKey}/form";
```

---

## Type Alias: GetStartProcessFormError


```ts
type GetStartProcessFormError =
  GetStartProcessFormErrors[keyof GetStartProcessFormErrors];
```

---

## Type Alias: GetStartProcessFormErrors


```ts
type GetStartProcessFormErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetStartProcessFormResponse


```ts
type GetStartProcessFormResponse =
  GetStartProcessFormResponses[keyof GetStartProcessFormResponses];
```

---

## Type Alias: GetStartProcessFormResponses


```ts
type GetStartProcessFormResponses = object;
```

## Properties

### 200

```ts
200: FormResult;
```

The form is successfully returned.

---

### 204

```ts
204: void;
```

The process was found, but no form is associated with it.

---

## Type Alias: GetStatusData


```ts
type GetStatusData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/status";
```

---

## Type Alias: GetStatusErrors


```ts
type GetStatusErrors = object;
```

## Properties

### 503

```ts
503: unknown;
```

The cluster is DOWN and does not have any partition with a healthy leader.

---

## Type Alias: GetStatusResponse


```ts
type GetStatusResponse = GetStatusResponses[keyof GetStatusResponses];
```

---

## Type Alias: GetStatusResponses


```ts
type GetStatusResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The cluster is UP and has at least one partition with a healthy leader.

---

## Type Alias: GetSystemConfigurationData


```ts
type GetSystemConfigurationData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/system/configuration";
```

---

## Type Alias: GetSystemConfigurationError


```ts
type GetSystemConfigurationError =
  GetSystemConfigurationErrors[keyof GetSystemConfigurationErrors];
```

---

## Type Alias: GetSystemConfigurationErrors


```ts
type GetSystemConfigurationErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetSystemConfigurationResponse


```ts
type GetSystemConfigurationResponse =
  GetSystemConfigurationResponses[keyof GetSystemConfigurationResponses];
```

---

## Type Alias: GetSystemConfigurationResponses


```ts
type GetSystemConfigurationResponses = object;
```

## Properties

### 200

```ts
200: SystemConfigurationResponse;
```

Current system configuration grouped by feature area.

---

## Type Alias: GetTenantClusterVariableData


```ts
type GetTenantClusterVariableData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable

#### tenantId

```ts
tenantId: TenantId;
```

The tenant ID

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/tenants/{tenantId}/{name}";
```

---

## Type Alias: GetTenantClusterVariableError


```ts
type GetTenantClusterVariableError =
  GetTenantClusterVariableErrors[keyof GetTenantClusterVariableErrors];
```

---

## Type Alias: GetTenantClusterVariableErrors


```ts
type GetTenantClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Cluster variable not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetTenantClusterVariableResponse


```ts
type GetTenantClusterVariableResponse =
  GetTenantClusterVariableResponses[keyof GetTenantClusterVariableResponses];
```

---

## Type Alias: GetTenantClusterVariableResponses


```ts
type GetTenantClusterVariableResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableResult;
```

Cluster variable found

---

## Type Alias: GetTenantData


```ts
type GetTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}";
```

---

## Type Alias: GetTenantError


```ts
type GetTenantError = GetTenantErrors[keyof GetTenantErrors];
```

---

## Type Alias: GetTenantErrors


```ts
type GetTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Tenant not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetTenantResponse


```ts
type GetTenantResponse = GetTenantResponses[keyof GetTenantResponses];
```

---

## Type Alias: GetTenantResponses


```ts
type GetTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantResult;
```

The tenant was retrieved successfully.

---

## Type Alias: GetTopologyData


```ts
type GetTopologyData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/topology";
```

---

## Type Alias: GetTopologyError


```ts
type GetTopologyError = GetTopologyErrors[keyof GetTopologyErrors];
```

---

## Type Alias: GetTopologyErrors


```ts
type GetTopologyErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetTopologyResponse


```ts
type GetTopologyResponse = GetTopologyResponses[keyof GetTopologyResponses];
```

---

## Type Alias: GetTopologyResponses


```ts
type GetTopologyResponses = object;
```

## Properties

### 200

```ts
200: TopologyResponse;
```

Obtains the current topology of the cluster the gateway is part of.

---

## Type Alias: GetUsageMetricsData


```ts
type GetUsageMetricsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query

```ts
query: object;
```

#### endTime

```ts
endTime: string;
```

The end date for usage metrics, including this date. Value in ISO 8601 format.

#### startTime

```ts
startTime: string;
```

The start date for usage metrics, including this date. Value in ISO 8601 format.

#### tenantId?

```ts
optional tenantId?: TenantId;
```

Restrict results to a specific tenant ID. If not provided, results for all tenants are returned.

#### withTenants?

```ts
optional withTenants?: boolean;
```

Whether to return tenant metrics in addition to the total metrics or not. Default false.

---

### url

```ts
url: "/system/usage-metrics";
```

---

## Type Alias: GetUsageMetricsError


```ts
type GetUsageMetricsError = GetUsageMetricsErrors[keyof GetUsageMetricsErrors];
```

---

## Type Alias: GetUsageMetricsErrors


```ts
type GetUsageMetricsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetUsageMetricsResponse


```ts
type GetUsageMetricsResponse =
  GetUsageMetricsResponses[keyof GetUsageMetricsResponses];
```

---

## Type Alias: GetUsageMetricsResponses


```ts
type GetUsageMetricsResponses = object;
```

## Properties

### 200

```ts
200: UsageMetricsResponse;
```

The usage metrics search result.

---

## Type Alias: GetUserData


```ts
type GetUserData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### username

```ts
username: Username;
```

The username of the user.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/users/{username}";
```

---

## Type Alias: GetUserError


```ts
type GetUserError = GetUserErrors[keyof GetUserErrors];
```

---

## Type Alias: GetUserErrors


```ts
type GetUserErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The user with the given username was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetUserResponse


```ts
type GetUserResponse = GetUserResponses[keyof GetUserResponses];
```

---

## Type Alias: GetUserResponses


```ts
type GetUserResponses = object;
```

## Properties

### 200

```ts
200: UserResult;
```

The user is successfully returned.

---

## Type Alias: GetUserTaskData


```ts
type GetUserTaskData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The user task key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}";
```

---

## Type Alias: GetUserTaskError


```ts
type GetUserTaskError = GetUserTaskErrors[keyof GetUserTaskErrors];
```

---

## Type Alias: GetUserTaskErrors


```ts
type GetUserTaskErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The user task with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetUserTaskFormData


```ts
type GetUserTaskFormData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The user task key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}/form";
```

---

## Type Alias: GetUserTaskFormError


```ts
type GetUserTaskFormError = GetUserTaskFormErrors[keyof GetUserTaskFormErrors];
```

---

## Type Alias: GetUserTaskFormErrors


```ts
type GetUserTaskFormErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetUserTaskFormResponse


```ts
type GetUserTaskFormResponse =
  GetUserTaskFormResponses[keyof GetUserTaskFormResponses];
```

---

## Type Alias: GetUserTaskFormResponses


```ts
type GetUserTaskFormResponses = object;
```

## Properties

### 200

```ts
200: FormResult;
```

The form is successfully returned.

---

### 204

```ts
204: void;
```

The user task was found, but no form is associated with it.

---

## Type Alias: GetUserTaskResponse


```ts
type GetUserTaskResponse = GetUserTaskResponses[keyof GetUserTaskResponses];
```

---

## Type Alias: GetUserTaskResponses


```ts
type GetUserTaskResponses = object;
```

## Properties

### 200

```ts
200: UserTaskResult;
```

The user task is successfully returned.

---

## Type Alias: GetVariableData


```ts
type GetVariableData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### variableKey

```ts
variableKey: VariableKey;
```

The variable key.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/variables/{variableKey}";
```

---

## Type Alias: GetVariableError


```ts
type GetVariableError = GetVariableErrors[keyof GetVariableErrors];
```

---

## Type Alias: GetVariableErrors


```ts
type GetVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: GetVariableResponse


```ts
type GetVariableResponse = GetVariableResponses[keyof GetVariableResponses];
```

---

## Type Alias: GetVariableResponses


```ts
type GetVariableResponses = object;
```

## Properties

### 200

```ts
200: VariableResult;
```

The variable is successfully returned.

---

## Type Alias: GlobalJobStatisticsQueryResult


```ts
type GlobalJobStatisticsQueryResult = object;
```

Global job statistics query result.

## Properties

### completed

```ts
completed: StatusMetric;
```

---

### created

```ts
created: StatusMetric;
```

---

### failed

```ts
failed: StatusMetric;
```

---

### isIncomplete

```ts
isIncomplete: boolean;
```

True if some data is missing because internal limits were reached and some metrics were not recorded.

---

## Type Alias: GlobalListenerBase


```ts
type GlobalListenerBase = object;
```

## Properties

### afterNonGlobal?

```ts
optional afterNonGlobal?: boolean;
```

Whether the listener should run after model-level listeners.

---

### priority?

```ts
optional priority?: number;
```

The priority of the listener. Higher priority listeners are executed before lower priority ones.

---

### retries?

```ts
optional retries?: number;
```

Number of retries for the listener job.

---

### type?

```ts
optional type?: string;
```

The name of the job type, used as a reference to specify which job workers request the respective listener job.

---

## Type Alias: GlobalListenerId


```ts
type GlobalListenerId = CamundaKey<"GlobalListenerId">;
```

The user-defined id for the global listener

---

## Type Alias: GlobalListenerSourceEnum


```ts
type GlobalListenerSourceEnum =
  (typeof GlobalListenerSourceEnum)[keyof typeof GlobalListenerSourceEnum];
```

How the global listener was defined.

---

## Type Alias: GlobalListenerSourceExactMatch


```ts
type GlobalListenerSourceExactMatch = GlobalListenerSourceEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: GlobalListenerSourceFilterProperty


```ts
type GlobalListenerSourceFilterProperty =
  GlobalListenerSourceExactMatch | AdvancedGlobalListenerSourceFilter;
```

Global listener source property with full advanced search capabilities.

---

## Type Alias: GlobalTaskListenerBase


```ts
type GlobalTaskListenerBase = GlobalListenerBase & object;
```

## Type Declaration

### eventTypes?

```ts
optional eventTypes?: GlobalTaskListenerEventTypes;
```

---

## Type Alias: GlobalTaskListenerEventTypeEnum


```ts
type GlobalTaskListenerEventTypeEnum =
  (typeof GlobalTaskListenerEventTypeEnum)[keyof typeof GlobalTaskListenerEventTypeEnum];
```

The event type that triggers the user task listener.

---

## Type Alias: GlobalTaskListenerEventTypeExactMatch


```ts
type GlobalTaskListenerEventTypeExactMatch = GlobalTaskListenerEventTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: GlobalTaskListenerEventTypeFilterProperty


```ts
type GlobalTaskListenerEventTypeFilterProperty =
  | GlobalTaskListenerEventTypeExactMatch
  | AdvancedGlobalTaskListenerEventTypeFilter;
```

Global listener event type property with full advanced search capabilities.

---

## Type Alias: GlobalTaskListenerEventTypes


```ts
type GlobalTaskListenerEventTypes = GlobalTaskListenerEventTypeEnum[];
```

List of user task event types that trigger the listener.

---

## Type Alias: GlobalTaskListenerResult


```ts
type GlobalTaskListenerResult = GlobalTaskListenerBase & object;
```

## Type Declaration

### eventTypes

```ts
eventTypes: GlobalTaskListenerEventTypes;
```

### id

```ts
id: GlobalListenerId;
```

### source

```ts
source: GlobalListenerSourceEnum;
```

---

## Type Alias: GlobalTaskListenerSearchQueryFilterRequest


```ts
type GlobalTaskListenerSearchQueryFilterRequest = object;
```

Global listener filter request.

## Properties

### afterNonGlobal?

```ts
optional afterNonGlobal?: boolean;
```

Whether the listener runs after model-level listeners.

---

### eventTypes?

```ts
optional eventTypes?: GlobalTaskListenerEventTypeFilterProperty[];
```

Event types of the global listener.

---

### id?

```ts
optional id?: StringFilterProperty;
```

Id of the global listener.

---

### priority?

```ts
optional priority?: IntegerFilterProperty;
```

Priority of the global listener.

---

### retries?

```ts
optional retries?: IntegerFilterProperty;
```

Number of retries of the global listener.

---

### source?

```ts
optional source?: GlobalListenerSourceFilterProperty;
```

How the global listener was defined.

---

### type?

```ts
optional type?: StringFilterProperty;
```

Job type of the global listener.

---

## Type Alias: GlobalTaskListenerSearchQueryRequest


```ts
type GlobalTaskListenerSearchQueryRequest = SearchQueryRequest & object;
```

Global listener search query request.

## Type Declaration

### filter?

```ts
optional filter?: GlobalTaskListenerSearchQueryFilterRequest;
```

The global listener search filters.

### sort?

```ts
optional sort?: GlobalTaskListenerSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: GlobalTaskListenerSearchQueryResult


```ts
type GlobalTaskListenerSearchQueryResult = SearchQueryResponse & object;
```

Global listener search query response.

## Type Declaration

### items

```ts
items: GlobalTaskListenerResult[];
```

The matching global listeners.

---

## Type Alias: GlobalTaskListenerSearchQuerySortRequest


```ts
type GlobalTaskListenerSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "id" | "type" | "afterNonGlobal" | "priority" | "source";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: GroupClientResult


```ts
type GroupClientResult = object;
```

## Properties

### clientId

```ts
clientId: ClientId;
```

The ID of the client.

---

## Type Alias: GroupClientSearchQueryRequest


```ts
type GroupClientSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: GroupClientSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: GroupClientSearchQuerySortRequest


```ts
type GroupClientSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "clientId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: GroupClientSearchResult


```ts
type GroupClientSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: GroupClientResult[];
```

The matching client IDs.

---

## Type Alias: GroupCreateRequest


```ts
type GroupCreateRequest = object;
```

## Properties

### description?

```ts
optional description?: string;
```

The description of the new group.

---

### groupId

```ts
groupId: GroupId;
```

The ID of the new group.

---

### name

```ts
name: string;
```

The display name of the new group.

---

## Type Alias: GroupCreateResult


```ts
type GroupCreateResult = object;
```

## Properties

### description

```ts
description: string | null;
```

The description of the created group.

---

### groupId

```ts
groupId: GroupId;
```

The ID of the created group.

---

### name

```ts
name: string;
```

The display name of the created group.

---

## Type Alias: GroupFilter


```ts
type GroupFilter = object;
```

Group filter request

## Properties

### groupId?

```ts
optional groupId?: StringFilterProperty;
```

The group ID search filters.

---

### name?

```ts
optional name?: string;
```

The group name search filters.

---

## Type Alias: GroupId


```ts
type GroupId = CamundaKey<"GroupId">;
```

The unique identifier of a group.

---

## Type Alias: GroupMappingRuleSearchResult


```ts
type GroupMappingRuleSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: MappingRuleResult[];
```

The matching mapping rules.

---

## Type Alias: GroupResult


```ts
type GroupResult = object;
```

Group search response item.

## Properties

### description

```ts
description: string | null;
```

The group description.

---

### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### name

```ts
name: string;
```

The group name.

---

## Type Alias: GroupRoleSearchResult


```ts
type GroupRoleSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: RoleResult[];
```

The matching roles.

---

## Type Alias: GroupSearchQueryRequest


```ts
type GroupSearchQueryRequest = SearchQueryRequest & object;
```

Group search request.

## Type Declaration

### filter?

```ts
optional filter?: GroupFilter;
```

The group search filters.

### sort?

```ts
optional sort?: GroupSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: GroupSearchQueryResult


```ts
type GroupSearchQueryResult = SearchQueryResponse & object;
```

Group search response.

## Type Declaration

### items

```ts
items: GroupResult[];
```

The matching groups.

---

## Type Alias: GroupSearchQuerySortRequest


```ts
type GroupSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "name" | "groupId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: GroupUpdateRequest


```ts
type GroupUpdateRequest = object;
```

## Properties

### description?

```ts
optional description?: string;
```

The new description of the group.

---

### name

```ts
name: string;
```

The new name of the group.

---

## Type Alias: GroupUpdateResult


```ts
type GroupUpdateResult = object;
```

## Properties

### description

```ts
description: string | null;
```

The description of the group.

---

### groupId

```ts
groupId: GroupId;
```

The unique group ID.

---

### name

```ts
name: string;
```

The name of the group.

---

## Type Alias: GroupUserResult


```ts
type GroupUserResult = object;
```

## Properties

### username

```ts
username: Username;
```

---

## Type Alias: GroupUserSearchQueryRequest


```ts
type GroupUserSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: GroupUserSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: GroupUserSearchQuerySortRequest


```ts
type GroupUserSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "username";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: GroupUserSearchResult


```ts
type GroupUserSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: GroupUserResult[];
```

The matching members.

---

## Type Alias: IncidentErrorTypeEnum


```ts
type IncidentErrorTypeEnum =
  (typeof IncidentErrorTypeEnum)[keyof typeof IncidentErrorTypeEnum];
```

Incident error type with a defined set of values.

---

## Type Alias: IncidentErrorTypeExactMatch


```ts
type IncidentErrorTypeExactMatch = IncidentErrorTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: IncidentErrorTypeFilterProperty


```ts
type IncidentErrorTypeFilterProperty =
  IncidentErrorTypeExactMatch | AdvancedIncidentErrorTypeFilter;
```

IncidentErrorTypeEnum with full advanced search capabilities.

---

## Type Alias: IncidentFilter


```ts
type IncidentFilter = object;
```

Incident search filter.

## Properties

### creationTime?

```ts
optional creationTime?: DateTimeFilterProperty;
```

Date of incident creation.

---

### elementId?

```ts
optional elementId?: StringFilterProperty;
```

The element ID associated to this incident.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The element instance key associated to this incident.

---

### errorMessage?

```ts
optional errorMessage?: StringFilterProperty;
```

The error message of this incident.

---

### errorType?

```ts
optional errorType?: IncidentErrorTypeFilterProperty;
```

Incident error type with a defined set of values.

---

### incidentKey?

```ts
optional incidentKey?: BasicStringFilterProperty;
```

The assigned key, which acts as a unique identifier for this incident.

---

### jobKey?

```ts
optional jobKey?: JobKeyFilterProperty;
```

The job key, if exists, associated with this incident.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The process definition ID associated to this incident.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The process definition key associated to this incident.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The process instance key associated to this incident.

---

### state?

```ts
optional state?: IncidentStateFilterProperty;
```

State of this incident with a defined set of values.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The tenant ID of the incident.

---

## Type Alias: IncidentKey


```ts
type IncidentKey = CamundaKey<"IncidentKey">;
```

System-generated key for a incident.

---

## Type Alias: IncidentProcessInstanceStatisticsByDefinitionFilter


```ts
type IncidentProcessInstanceStatisticsByDefinitionFilter = object;
```

Filter for the incident process instance statistics by definition query.

## Properties

### errorHashCode

```ts
errorHashCode: number;
```

The error hash code of the incidents to filter the process instance statistics by.

---

## Type Alias: IncidentProcessInstanceStatisticsByDefinitionQuery


```ts
type IncidentProcessInstanceStatisticsByDefinitionQuery = object;
```

## Properties

### filter

```ts
filter: IncidentProcessInstanceStatisticsByDefinitionFilter;
```

Filter criteria for the aggregated process instance statistics.

---

### page?

```ts
optional page?: OffsetPagination;
```

Pagination parameters for the aggregated process instance statistics.

---

### sort?

```ts
optional sort?: IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest[];
```

Sorting criteria for process instance statistics grouped by process definition.

---

## Type Alias: IncidentProcessInstanceStatisticsByDefinitionQueryResult


```ts
type IncidentProcessInstanceStatisticsByDefinitionQueryResult =
  SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: IncidentProcessInstanceStatisticsByDefinitionResult[];
```

Statistics of active process instances with incidents, grouped by process
definition for the specified error hash code.

---

## Type Alias: IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest


```ts
type IncidentProcessInstanceStatisticsByDefinitionQuerySortRequest = object;
```

## Properties

### field

```ts
field: "activeInstancesWithErrorCount" | "processDefinitionKey" | "tenantId";
```

The aggregated field by which the process instance statistics are sorted.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: IncidentProcessInstanceStatisticsByDefinitionResult


```ts
type IncidentProcessInstanceStatisticsByDefinitionResult = object;
```

## Properties

### activeInstancesWithErrorCount

```ts
activeInstancesWithErrorCount: number;
```

The number of active process instances that currently have an incident
with the specified error hash code.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

---

### processDefinitionName

```ts
processDefinitionName: string;
```

The name of the process definition.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version of the process definition.

---

### tenantId

```ts
tenantId: TenantId;
```

---

## Type Alias: IncidentProcessInstanceStatisticsByErrorQuery


```ts
type IncidentProcessInstanceStatisticsByErrorQuery = object;
```

## Properties

### page?

```ts
optional page?: OffsetPagination;
```

Pagination parameters for process instance statistics grouped by incident error.

---

### sort?

```ts
optional sort?: IncidentProcessInstanceStatisticsByErrorQuerySortRequest[];
```

Sorting criteria for process instance statistics grouped by incident error.

---

## Type Alias: IncidentProcessInstanceStatisticsByErrorQueryResult


```ts
type IncidentProcessInstanceStatisticsByErrorQueryResult = SearchQueryResponse &
  object;
```

## Type Declaration

### items

```ts
items: IncidentProcessInstanceStatisticsByErrorResult[];
```

Statistics of active process instances grouped by incident error.

---

## Type Alias: IncidentProcessInstanceStatisticsByErrorQuerySortRequest


```ts
type IncidentProcessInstanceStatisticsByErrorQuerySortRequest = object;
```

## Properties

### field

```ts
field: "errorMessage" | "activeInstancesWithErrorCount";
```

The field to sort the incident error statistics by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: IncidentProcessInstanceStatisticsByErrorResult


```ts
type IncidentProcessInstanceStatisticsByErrorResult = object;
```

## Properties

### activeInstancesWithErrorCount

```ts
activeInstancesWithErrorCount: number;
```

The number of active process instances that currently have an active incident with this error.

---

### errorHashCode

```ts
errorHashCode: number;
```

The hash code identifying a specific incident error..

---

### errorMessage

```ts
errorMessage: string;
```

The error message associated with the incident error hash code.

---

## Type Alias: IncidentResolutionRequest


```ts
type IncidentResolutionRequest = object;
```

## Properties

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: IncidentResult


```ts
type IncidentResult = object;
```

## Properties

### creationTime

```ts
creationTime: string;
```

The creation time of the incident.

---

### elementId

```ts
elementId: ElementId;
```

The element ID associated to this incident.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The element instance key associated to this incident.

---

### errorMessage

```ts
errorMessage: string;
```

Error message which describes the error in more detail.

---

### errorType

```ts
errorType: IncidentErrorTypeEnum;
```

The type of the incident error.

---

### incidentKey

```ts
incidentKey: IncidentKey;
```

The assigned key, which acts as a unique identifier for this incident.

---

### jobKey

```ts
jobKey: JobKey | null;
```

The job key, if exists, associated with this incident.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition ID associated to this incident.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key associated to this incident.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The process instance key associated to this incident.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### state

```ts
state: IncidentStateEnum;
```

The incident state.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the incident.

---

## Type Alias: IncidentSearchQuery


```ts
type IncidentSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: IncidentFilter;
```

The incident search filters.

### sort?

```ts
optional sort?: IncidentSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: IncidentSearchQueryResult


```ts
type IncidentSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: IncidentResult[];
```

The matching incidents.

---

## Type Alias: IncidentSearchQuerySortRequest


```ts
type IncidentSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "incidentKey"
  | "processDefinitionKey"
  | "processDefinitionId"
  | "processInstanceKey"
  | "errorType"
  | "elementId"
  | "elementInstanceKey"
  | "creationTime"
  | "state"
  | "jobKey"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: IncidentStateEnum


```ts
type IncidentStateEnum =
  (typeof IncidentStateEnum)[keyof typeof IncidentStateEnum];
```

Incident states with a defined set of values.

---

## Type Alias: IncidentStateExactMatch


```ts
type IncidentStateExactMatch = IncidentStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: IncidentStateFilterProperty


```ts
type IncidentStateFilterProperty =
  IncidentStateExactMatch | AdvancedIncidentStateFilter;
```

IncidentStateEnum with full advanced search capabilities.

---

## Type Alias: InferredAncestorKeyInstruction


```ts
type InferredAncestorKeyInstruction = object;
```

Instructs the engine to derive the ancestor scope key from the source element's hierarchy. The engine traverses the source element's ancestry to find an instance that matches one of the target element's flow scopes, ensuring the target is activated in the correct scope.

## Properties

### ancestorScopeType

```ts
ancestorScopeType: string;
```

The type of ancestor scope instruction.

---

## Type Alias: IntegerFilterProperty


```ts
type IntegerFilterProperty = number | AdvancedIntegerFilter;
```

Integer property with advanced search capabilities.

---

## Type Alias: IterationId


```ts
type IterationId = number;
```

A client-provided sequential integer identifying a logical iteration: one LLM
call, its tool dispatches, and their results. Must be a positive integer,
increasing with each iteration. Established by the
connector when appending the first history item of an iteration.

---

## Type Alias: Job<In, Headers>

# Type Alias: Job\<In, Headers\>

```ts
type Job<In, Headers> = EnrichedActivatedJob & object;
```

## Type Declaration

### customHeaders

```ts
customHeaders: InferOrUnknown<Headers>;
```

### variables

```ts
variables: InferOrUnknown<In>;
```

## Type Parameters

### In

`In` _extends_ `z.ZodTypeAny` \| `undefined`

### Headers

`Headers` _extends_ `z.ZodTypeAny` \| `undefined`

---

## Type Alias: JobActionReceipt


```ts
type JobActionReceipt = typeof JobActionReceipt;
```

Unique receipt symbol returned by job action methods.

---

## Type Alias: JobActionReceipt(Type-aliases)


```ts
type JobActionReceipt = "JOB_ACTION_RECEIPT";
```

Unique receipt symbol returned by job action methods.

---

## Type Alias: JobActivationRequest


```ts
type JobActivationRequest = object;
```

## Properties

### fetchVariable?

```ts
optional fetchVariable?: string[];
```

A list of variables to fetch as the job variables; if empty, all visible variables at the time of activation for the scope of the job will be returned.

---

### maxJobsToActivate

```ts
maxJobsToActivate: number;
```

The maximum jobs to activate by this request.

---

### requestTimeout?

```ts
optional requestTimeout?: number;
```

The request will be completed when at least one job is activated or after the requestTimeout (in ms). If the requestTimeout = 0, a default timeout is used. If the requestTimeout < 0, long polling is disabled and the request is completed immediately, even when no job is activated.

---

### tenantFilter?

```ts
optional tenantFilter?: TenantFilterEnum;
```

The tenant filtering strategy - determines whether to use provided tenant IDs or assigned tenant IDs from the authenticated principal's authorized tenants.

---

### tenantIds?

```ts
optional tenantIds?: TenantId[];
```

A list of IDs of tenants for which to activate jobs.

---

### timeout

```ts
timeout: number;
```

A job returned after this call will not be activated by another call until the timeout (in ms) has been reached.

---

### type

```ts
type: string;
```

The job type, as defined in the BPMN process (e.g. <zeebe:taskDefinition type="payment-service" />)

---

### worker?

```ts
optional worker?: string;
```

The name of the worker activating the jobs, mostly used for logging purposes.

---

## Type Alias: JobActivationResult


```ts
type JobActivationResult = object;
```

The list of activated jobs

## Properties

### jobs

```ts
jobs: ActivatedJobResult[];
```

The activated jobs.

---

## Type Alias: JobBatchUpdateRequest


```ts
type JobBatchUpdateRequest = object;
```

The filter and changeset for a batch job update operation. The filter defines which jobs are updated; the changeset defines what to update. At least one changeset field must be non-null.

## Properties

### changeset

```ts
changeset: JobChangeset;
```

The fields to update. At least one field must be non-null.

---

### filter

```ts
filter: JobFilter;
```

The job filter. At least one dimension must be set.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: JobChangeset


```ts
type JobChangeset = object;
```

JSON object with changed job attribute values. The job cannot be completed or failed with this endpoint, use the complete job or fail job endpoints instead.

## Properties

### priority?

```ts
optional priority?: number | null;
```

The new priority for the job. Higher values indicate higher priority.

---

### retries?

```ts
optional retries?: number | null;
```

The new number of retries for the job.

---

### timeout?

```ts
optional timeout?: number | null;
```

The new timeout for the job in milliseconds.

---

## Type Alias: JobCompletionRequest


```ts
type JobCompletionRequest = object;
```

## Properties

### result?

```ts
optional result?: JobResult;
```

---

### variables?

```ts
optional variables?:
  | {
[key: string]: unknown;
}
  | null;
```

The variables to complete the job with.

---

## Type Alias: JobErrorRequest


```ts
type JobErrorRequest = object;
```

## Properties

### errorCode

```ts
errorCode: string;
```

The error code that will be matched with an error catch event.

---

### errorMessage?

```ts
optional errorMessage?: string | null;
```

An error message that provides additional context.

---

### variables?

```ts
optional variables?:
  | {
[key: string]: unknown;
}
  | null;
```

JSON object that will instantiate the variables at the local scope of the error catch event that catches the thrown error.

---

## Type Alias: JobErrorStatisticsFilter


```ts
type JobErrorStatisticsFilter = object;
```

Job error statistics search filter.

## Properties

### errorCode?

```ts
optional errorCode?: StringFilterProperty;
```

Optional error code filter with advanced search capabilities.

---

### errorMessage?

```ts
optional errorMessage?: StringFilterProperty;
```

Optional error message filter with advanced search capabilities.

---

### from

```ts
from: string;
```

Start of the time window to filter metrics. ISO 8601 date-time format.

---

### jobType

```ts
jobType: string;
```

Job type to return error metrics for.

---

### to

```ts
to: string;
```

End of the time window to filter metrics. ISO 8601 date-time format.

---

## Type Alias: JobErrorStatisticsItem


```ts
type JobErrorStatisticsItem = object;
```

Aggregated error metrics for a single error type and message combination.

## Properties

### errorCode

```ts
errorCode: string;
```

The error code identifier.

---

### errorMessage

```ts
errorMessage: string;
```

The error message.

---

### workers

```ts
workers: number;
```

Number of distinct workers that encountered this error.

---

## Type Alias: JobErrorStatisticsQuery


```ts
type JobErrorStatisticsQuery = object;
```

Job error statistics query.

## Properties

### filter

```ts
filter: JobErrorStatisticsFilter;
```

---

### page?

```ts
optional page?: CursorForwardPagination;
```

Search cursor pagination.

---

## Type Alias: JobErrorStatisticsQueryResult


```ts
type JobErrorStatisticsQueryResult = SearchQueryResponse & object;
```

Job error statistics query result.

## Type Declaration

### items

```ts
items: JobErrorStatisticsItem[];
```

The list of per-error statistics items.

### page

```ts
page: SearchQueryPageResponse;
```

---

## Type Alias: JobFailRequest


```ts
type JobFailRequest = object;
```

## Properties

### errorMessage?

```ts
optional errorMessage?: string;
```

An optional error message describing why the job failed; if not provided, an empty string is used.

---

### retries?

```ts
optional retries?: number;
```

The amount of retries the job should have left

---

### retryBackOff?

```ts
optional retryBackOff?: number;
```

An optional retry back off for the failed job. The job will not be retryable before the current time plus the back off time. The default is 0 which means the job is retryable immediately.

---

### variables?

```ts
optional variables?: object;
```

JSON object that will instantiate the variables at the local scope of the job's associated task.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: JobFilter


```ts
type JobFilter = object;
```

Job search filter.

## Properties

### creationTime?

```ts
optional creationTime?: DateTimeFilterProperty;
```

When the job was created. Field is present for jobs created after 8.9.

---

### deadline?

```ts
optional deadline?: DateTimeFilterProperty | null;
```

When the job can next be activated.

---

### deniedReason?

```ts
optional deniedReason?: StringFilterProperty;
```

The reason provided by the user task listener for denying the work.

---

### elementId?

```ts
optional elementId?: StringFilterProperty;
```

The element ID associated with the job.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The element instance key associated with the job.

---

### endTime?

```ts
optional endTime?: DateTimeFilterProperty;
```

When the job ended.

---

### errorCode?

```ts
optional errorCode?: StringFilterProperty;
```

The error code provided for the failed job.

---

### errorMessage?

```ts
optional errorMessage?: StringFilterProperty;
```

The error message that provides additional context for a failed job.

---

### hasFailedWithRetriesLeft?

```ts
optional hasFailedWithRetriesLeft?: boolean;
```

Indicates whether the job has failed with retries left.

---

### isDenied?

```ts
optional isDenied?: boolean | null;
```

Indicates whether the user task listener denies the work.

---

### jobKey?

```ts
optional jobKey?: JobKeyFilterProperty;
```

The key, a unique identifier for the job.

---

### kind?

```ts
optional kind?: JobKindFilterProperty;
```

The kind of the job.

---

### lastUpdateTime?

```ts
optional lastUpdateTime?: DateTimeFilterProperty;
```

When the job was last updated. Field is present for jobs created after 8.9.

---

### listenerEventType?

```ts
optional listenerEventType?: JobListenerEventTypeFilterProperty;
```

The listener event type of the job.

---

### priority?

```ts
optional priority?: IntegerFilterProperty;
```

The priority of the job. Jobs created before 8.10 have no stored priority and are excluded from results when this filter is applied.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The process definition ID associated with the job.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The process definition key associated with the job.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The process instance key associated with the job.

---

### retries?

```ts
optional retries?: IntegerFilterProperty;
```

The number of retries left.

---

### state?

```ts
optional state?: JobStateFilterProperty;
```

The state of the job.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The tenant ID.

---

### type?

```ts
optional type?: StringFilterProperty;
```

The type of the job.

---

### worker?

```ts
optional worker?: StringFilterProperty;
```

The name of the worker for this job.

---

## Type Alias: JobKey


```ts
type JobKey = CamundaKey<"JobKey">;
```

System-generated key for a job.

---

## Type Alias: JobKeyExactMatch


```ts
type JobKeyExactMatch = JobKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: JobKeyFilterProperty


```ts
type JobKeyFilterProperty = JobKeyExactMatch | AdvancedJobKeyFilter;
```

JobKey property with full advanced search capabilities.

---

## Type Alias: JobKindEnum


```ts
type JobKindEnum = (typeof JobKindEnum)[keyof typeof JobKindEnum];
```

The job kind.

---

## Type Alias: JobKindExactMatch


```ts
type JobKindExactMatch = JobKindEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: JobKindFilterProperty


```ts
type JobKindFilterProperty = JobKindExactMatch | AdvancedJobKindFilter;
```

JobKindEnum property with full advanced search capabilities.

---

## Type Alias: JobListenerEventTypeEnum


```ts
type JobListenerEventTypeEnum =
  (typeof JobListenerEventTypeEnum)[keyof typeof JobListenerEventTypeEnum];
```

The listener event type of the job.

---

## Type Alias: JobListenerEventTypeExactMatch


```ts
type JobListenerEventTypeExactMatch = JobListenerEventTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: JobListenerEventTypeFilterProperty


```ts
type JobListenerEventTypeFilterProperty =
  JobListenerEventTypeExactMatch | AdvancedJobListenerEventTypeFilter;
```

JobListenerEventTypeEnum property with full advanced search capabilities.

---

## Type Alias: JobMetricsConfigurationResponse


```ts
type JobMetricsConfigurationResponse = object;
```

Configuration for job metrics collection and export.

## Properties

### enabled

```ts
enabled: boolean;
```

Whether job metrics export is enabled.

---

### exportInterval

```ts
exportInterval: string;
```

The interval at which job metrics are exported, as an ISO 8601 duration.

---

### maxJobTypeLength

```ts
maxJobTypeLength: number;
```

The maximum length of the job type used in job metrics labels.

---

### maxTenantIdLength

```ts
maxTenantIdLength: number;
```

The maximum length of the tenant ID used in job metrics labels.

---

### maxUniqueKeys

```ts
maxUniqueKeys: number;
```

The maximum number of unique metric keys tracked for job metrics.

---

### maxWorkerNameLength

```ts
maxWorkerNameLength: number;
```

The maximum length of the worker name used in job metrics labels.

---

## Type Alias: JobResult


```ts
type JobResult =
  (object & JobResultUserTask) | (object & JobResultAdHocSubProcess);
```

The result of the completed job as determined by the worker.

---

## Type Alias: JobResultActivateElement


```ts
type JobResultActivateElement = object;
```

Instruction to activate a single BPMN element within an ad‑hoc sub‑process, optionally providing variables scoped to that element.

## Properties

### elementId?

```ts
optional elementId?: ElementId;
```

The element ID to activate.

---

### variables?

```ts
optional variables?:
  | {
[key: string]: unknown;
}
  | null;
```

Variables for the element.

---

## Type Alias: JobResultAdHocSubProcess


```ts
type JobResultAdHocSubProcess = {
  activateElements?: JobResultActivateElement[];
  isCancelRemainingInstances?: boolean;
  isCompletionConditionFulfilled?: boolean;
  type?: string;
} | null;
```

Job result details for an ad‑hoc sub‑process, including elements to activate and flags indicating completion or cancellation behavior.

## Union Members

### Type Literal

```ts
{
  activateElements?: JobResultActivateElement[];
  isCancelRemainingInstances?: boolean;
  isCompletionConditionFulfilled?: boolean;
  type?: string;
}
```

#### activateElements?

```ts
optional activateElements?: JobResultActivateElement[];
```

Indicates which elements need to be activated in the ad-hoc subprocess.

#### isCancelRemainingInstances?

```ts
optional isCancelRemainingInstances?: boolean;
```

Indicates whether the remaining instances of the ad-hoc subprocess should be canceled.

#### isCompletionConditionFulfilled?

```ts
optional isCompletionConditionFulfilled?: boolean;
```

Indicates whether the completion condition of the ad-hoc subprocess is fulfilled.

#### type?

```ts
optional type?: string;
```

Used to distinguish between different types of job results.

---

`null`

---

## Type Alias: JobResultCorrections


```ts
type JobResultCorrections = {
  assignee?: string | null;
  candidateGroups?: string[] | null;
  candidateUsers?: string[] | null;
  dueDate?: string | null;
  followUpDate?: string | null;
  priority?: number | null;
} | null;
```

JSON object with attributes that were corrected by the worker.

The following attributes can be corrected, additional attributes will be ignored:

- `assignee` - clear by providing an empty String
- `dueDate` - clear by providing an empty String
- `followUpDate` - clear by providing an empty String
- `candidateGroups` - clear by providing an empty list
- `candidateUsers` - clear by providing an empty list
- `priority` - minimum 0, maximum 100, default 50

Providing any of those attributes with a `null` value or omitting it preserves
the persisted attribute's value.

## Union Members

### Type Literal

```ts
{
  assignee?: string | null;
  candidateGroups?: string[] | null;
  candidateUsers?: string[] | null;
  dueDate?: string | null;
  followUpDate?: string | null;
  priority?: number | null;
}
```

#### assignee?

```ts
optional assignee?: string | null;
```

Assignee of the task.

#### candidateGroups?

```ts
optional candidateGroups?: string[] | null;
```

The list of candidate groups of the task.

#### candidateUsers?

```ts
optional candidateUsers?: string[] | null;
```

The list of candidate users of the task.

#### dueDate?

```ts
optional dueDate?: string | null;
```

The due date of the task.

#### followUpDate?

```ts
optional followUpDate?: string | null;
```

The follow-up date of the task.

#### priority?

```ts
optional priority?: number | null;
```

The priority of the task.

---

`null`

---

## Type Alias: JobResultUserTask


```ts
type JobResultUserTask = {
  corrections?: JobResultCorrections;
  denied?: boolean | null;
  deniedReason?: string | null;
  type?: string;
} | null;
```

Job result details for a user task completion, optionally including a denial reason and corrected task properties.

## Union Members

### Type Literal

```ts
{
  corrections?: JobResultCorrections;
  denied?: boolean | null;
  deniedReason?: string | null;
  type?: string;
}
```

#### corrections?

```ts
optional corrections?: JobResultCorrections;
```

#### denied?

```ts
optional denied?: boolean | null;
```

Indicates whether the worker denies the work, i.e. explicitly doesn't approve it. For example, a user task listener can deny the completion of a task by setting this flag to true. In this example, the completion of a task is represented by a job that the worker can complete as denied. As a result, the completion request is rejected and the task remains active. Defaults to false.

#### deniedReason?

```ts
optional deniedReason?: string | null;
```

The reason provided by the user task listener for denying the work.

#### type?

```ts
optional type?: string;
```

Used to distinguish between different types of job results.

---

`null`

---

## Type Alias: JobSearchQuery


```ts
type JobSearchQuery = SearchQueryRequest & object;
```

Job search request.

## Type Declaration

### filter?

```ts
optional filter?: JobFilter;
```

The job search filters.

### sort?

```ts
optional sort?: JobSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: JobSearchQueryResult


```ts
type JobSearchQueryResult = SearchQueryResponse & object;
```

Job search response.

## Type Declaration

### items

```ts
items: JobSearchResult[];
```

The matching jobs.

---

## Type Alias: JobSearchQuerySortRequest


```ts
type JobSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "deadline"
  | "deniedReason"
  | "elementId"
  | "elementInstanceKey"
  | "endTime"
  | "errorCode"
  | "errorMessage"
  | "hasFailedWithRetriesLeft"
  | "isDenied"
  | "jobKey"
  | "kind"
  | "listenerEventType"
  | "priority"
  | "processDefinitionId"
  | "processDefinitionKey"
  | "processInstanceKey"
  | "retries"
  | "state"
  | "tenantId"
  | "type"
  | "worker";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: JobSearchResult


```ts
type JobSearchResult = object;
```

## Properties

### businessId

```ts
businessId: BusinessId | null;
```

The business ID of the owning process instance, inherited when the job was created.
This is `null` for jobs created before version 8.10 and for jobs whose owning process
instance has no business ID.

---

### creationTime

```ts
creationTime: string | null;
```

When the job was created. Field is present for jobs created after 8.9.

---

### customHeaders

```ts
customHeaders: object;
```

A set of custom headers defined during modelling.

#### Index Signature

```ts
[key: string]: string
```

---

### deadline

```ts
deadline: string | null;
```

If the job has been activated, when it will next be available to be activated.

---

### deniedReason

```ts
deniedReason: string | null;
```

The reason provided by the user task listener for denying the work.

---

### elementId

```ts
elementId: ElementId | null;
```

The element ID associated with the job. May be missing on job failure.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The element instance key associated with the job.

---

### endTime

```ts
endTime: string | null;
```

End date of the job.
This is `null` if the job is not in an end state yet.

---

### errorCode

```ts
errorCode: string | null;
```

The error code provided for a failed job.

---

### errorMessage

```ts
errorMessage: string | null;
```

The error message that provides additional context for a failed job.

---

### hasFailedWithRetriesLeft

```ts
hasFailedWithRetriesLeft: boolean;
```

Indicates whether the job has failed with retries left.

---

### isDenied

```ts
isDenied: boolean | null;
```

Indicates whether the user task listener denies the work.

---

### jobKey

```ts
jobKey: JobKey;
```

The key, a unique identifier for the job.

---

### kind

```ts
kind: JobKindEnum;
```

---

### lastUpdateTime

```ts
lastUpdateTime: string | null;
```

When the job was last updated. Field is present for jobs created after 8.9.

---

### listenerEventType

```ts
listenerEventType: JobListenerEventTypeEnum;
```

---

### priority

```ts
priority: number;
```

The priority of the job. Higher values indicate higher priority. Jobs created before 8.10 have no stored priority; they appear last when sorting by this field and are excluded when filtering by this field. The API returns 0 for such jobs.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition ID associated with the job.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key associated with the job.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The process instance key associated with the job.

---

### retries

```ts
retries: number;
```

The amount of retries left to this job.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### state

```ts
state: JobStateEnum;
```

---

### tenantId

```ts
tenantId: TenantId;
```

---

### type

```ts
type: string;
```

The type of the job.

---

### worker

```ts
worker: string;
```

The name of the worker of this job.

---

## Type Alias: JobStateEnum


```ts
type JobStateEnum = (typeof JobStateEnum)[keyof typeof JobStateEnum];
```

The state of the job.

---

## Type Alias: JobStateExactMatch


```ts
type JobStateExactMatch = JobStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: JobStateFilterProperty


```ts
type JobStateFilterProperty = JobStateExactMatch | AdvancedJobStateFilter;
```

JobStateEnum property with full advanced search capabilities.

---

## Type Alias: JobTimeSeriesStatisticsFilter


```ts
type JobTimeSeriesStatisticsFilter = object;
```

Job time-series statistics search filter.

## Properties

### from

```ts
from: string;
```

Start of the time window to filter metrics. ISO 8601 date-time format.

---

### jobType

```ts
jobType: string;
```

Job type to return time-series metrics for.

---

### resolution?

```ts
optional resolution?: string;
```

Time bucket resolution as an ISO 8601 duration (for example `PT1M` for 1 minute,
`PT1H` for 1 hour). If omitted, the server chooses a sensible default.

---

### to

```ts
to: string;
```

End of the time window to filter metrics. ISO 8601 date-time format.

---

## Type Alias: JobTimeSeriesStatisticsItem


```ts
type JobTimeSeriesStatisticsItem = object;
```

Aggregated job metrics for a single time bucket.

## Properties

### completed

```ts
completed: StatusMetric;
```

---

### created

```ts
created: StatusMetric;
```

---

### failed

```ts
failed: StatusMetric;
```

---

### time

```ts
time: string;
```

ISO 8601 timestamp representing the start of this time bucket.

---

## Type Alias: JobTimeSeriesStatisticsQuery


```ts
type JobTimeSeriesStatisticsQuery = object;
```

Job time-series statistics query.

## Properties

### filter

```ts
filter: JobTimeSeriesStatisticsFilter;
```

---

### page?

```ts
optional page?: CursorForwardPagination;
```

Search cursor pagination.

---

## Type Alias: JobTimeSeriesStatisticsQueryResult


```ts
type JobTimeSeriesStatisticsQueryResult = SearchQueryResponse & object;
```

Job time-series statistics query result.

## Type Declaration

### items

```ts
items: JobTimeSeriesStatisticsItem[];
```

The list of time-bucketed statistics items, ordered ascending by time.

### page

```ts
page: SearchQueryPageResponse;
```

---

## Type Alias: JobTypeStatisticsFilter


```ts
type JobTypeStatisticsFilter = object;
```

Job type statistics search filter.

## Properties

### from

```ts
from: string;
```

Start of the time window to filter metrics. ISO 8601 date-time format.

---

### jobType?

```ts
optional jobType?: StringFilterProperty;
```

Optional job type filter with advanced search capabilities.
Supports exact match, pattern matching, and other operators.

---

### to

```ts
to: string;
```

End of the time window to filter metrics. ISO 8601 date-time format.

---

## Type Alias: JobTypeStatisticsItem


```ts
type JobTypeStatisticsItem = object;
```

Statistics for a single job type.

## Properties

### completed

```ts
completed: StatusMetric;
```

---

### created

```ts
created: StatusMetric;
```

---

### failed

```ts
failed: StatusMetric;
```

---

### jobType

```ts
jobType: string;
```

The job type identifier.

---

### workers

```ts
workers: number;
```

Number of distinct workers observed for this job type.

---

## Type Alias: JobTypeStatisticsQuery


```ts
type JobTypeStatisticsQuery = object;
```

Job type statistics query.

## Properties

### filter?

```ts
optional filter?: JobTypeStatisticsFilter;
```

---

### page?

```ts
optional page?: CursorForwardPagination;
```

Search cursor pagination.

---

## Type Alias: JobTypeStatisticsQueryResult


```ts
type JobTypeStatisticsQueryResult = SearchQueryResponse & object;
```

Job type statistics query result.

## Type Declaration

### items

```ts
items: JobTypeStatisticsItem[];
```

The list of job type statistics items.

### page

```ts
page: SearchQueryPageResponse;
```

---

## Type Alias: JobUpdateRequest


```ts
type JobUpdateRequest = object;
```

## Properties

### changeset

```ts
changeset: JobChangeset;
```

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: JobWaitStateDetails


```ts
type JobWaitStateDetails = BaseWaitStateDetails & object;
```

## Type Declaration

### jobKey

```ts
jobKey: JobKey;
```

The key of the job.

### jobKind

```ts
jobKind: JobKindEnum;
```

The kind of job.

### jobType

```ts
jobType: string;
```

The job type (worker subscription identifier).

### listenerEventType

```ts
listenerEventType: JobListenerEventTypeEnum | null;
```

The listener event type of the job (only set for execution listener and task listener jobs).

### retries

```ts
retries: number | null;
```

The number of retries remaining for the job.

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: JobWorkerStatisticsFilter


```ts
type JobWorkerStatisticsFilter = object;
```

Job worker statistics search filter.

## Properties

### from

```ts
from: string;
```

Start of the time window to filter metrics. ISO 8601 date-time format.

---

### jobType

```ts
jobType: string;
```

Job type to return worker metrics for.

---

### to

```ts
to: string;
```

End of the time window to filter metrics. ISO 8601 date-time format.

---

## Type Alias: JobWorkerStatisticsItem


```ts
type JobWorkerStatisticsItem = object;
```

Statistics for a single worker within a job type.

## Properties

### completed

```ts
completed: StatusMetric;
```

---

### created

```ts
created: StatusMetric;
```

---

### failed

```ts
failed: StatusMetric;
```

---

### worker

```ts
worker: string;
```

The name of the worker activating the jobs, mostly used for logging purposes.

---

## Type Alias: JobWorkerStatisticsQuery


```ts
type JobWorkerStatisticsQuery = object;
```

Job worker statistics query.

## Properties

### filter

```ts
filter: JobWorkerStatisticsFilter;
```

---

### page?

```ts
optional page?: CursorForwardPagination;
```

Search cursor pagination.

---

## Type Alias: JobWorkerStatisticsQueryResult


```ts
type JobWorkerStatisticsQueryResult = SearchQueryResponse & object;
```

Job worker statistics query result.

## Type Declaration

### items

```ts
items: JobWorkerStatisticsItem[];
```

The list of per-worker statistics items.

### page

```ts
page: SearchQueryPageResponse;
```

---

## Type Alias: LicenseResponse


```ts
type LicenseResponse = object;
```

The response of a license request.

## Properties

### expiresAt

```ts
expiresAt: string | null;
```

The date when the Camunda license expires

---

### isCommercial

```ts
isCommercial: boolean;
```

Will be false when a license contains a non-commerical=true property

---

### licenseType

```ts
licenseType: string;
```

Will return the license type property of the Camunda license

---

### validLicense

```ts
validLicense: boolean;
```

True if the Camunda license is valid, false if otherwise

---

## Type Alias: LikeFilter


```ts
type LikeFilter = string;
```

Checks if the property matches the provided like value.

Supported wildcard characters are:

- `*`: matches zero, one, or multiple characters.
- `?`: matches one, single character.

Wildcard characters can be escaped with backslash, for instance: `\*`.

---

## Type Alias: LimitPagination


```ts
type LimitPagination = object;
```

Limit-based pagination

## Properties

### limit?

```ts
optional limit?: number;
```

The maximum number of items to return in one request.

---

## Type Alias: LongKey


```ts
type LongKey = string;
```

Zeebe Engine resource key (Java long serialized as string)

---

## Type Alias: Loose<T>

# Type Alias: Loose\<T\>

```ts
type Loose<T> = IsBrandedKey<T> extends true ? string : T extends CancelablePromise<infer P> ? CancelablePromise<Loose> : T extends Promise<infer P> ? Promise<Loose> : T extends infer U[] ? Loose[] : T extends ReadonlyArray<infer U> ? ReadonlyArray<Loose> : T extends (...a) => infer R ? (...a) => Loose<R> : T extends object ? { [K in keyof T]: Loose<T[K]> } : T;
```

## Type Parameters

### T

`T`

---

## Type Alias: MappingRuleCreateRequest


```ts
type MappingRuleCreateRequest = MappingRuleCreateUpdateRequest & object;
```

## Type Declaration

### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The unique ID of the mapping rule.

---

## Type Alias: MappingRuleCreateResult


```ts
type MappingRuleCreateResult = MappingRuleCreateUpdateResult;
```

---

## Type Alias: MappingRuleCreateUpdateRequest


```ts
type MappingRuleCreateUpdateRequest = object;
```

## Properties

### claimName

```ts
claimName: string;
```

The name of the claim to map.

---

### claimValue

```ts
claimValue: string;
```

The value of the claim to map.

---

### name

```ts
name: string;
```

The name of the mapping rule.

---

## Type Alias: MappingRuleCreateUpdateResult


```ts
type MappingRuleCreateUpdateResult = object;
```

## Properties

### claimName

```ts
claimName: string;
```

The name of the claim to map.

---

### claimValue

```ts
claimValue: string;
```

The value of the claim to map.

---

### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The unique ID of the mapping rule.

---

### name

```ts
name: string;
```

The name of the mapping rule.

---

## Type Alias: MappingRuleFilter


```ts
type MappingRuleFilter = object;
```

Mapping rule search filter.

## Properties

### claimName?

```ts
optional claimName?: string;
```

The claim name to match against a token.

---

### claimValue?

```ts
optional claimValue?: string;
```

The value of the claim to match.

---

### mappingRuleId?

```ts
optional mappingRuleId?: MappingRuleId;
```

The ID of the mapping rule.

---

### name?

```ts
optional name?: string;
```

The name of the mapping rule.

---

## Type Alias: MappingRuleId


```ts
type MappingRuleId = CamundaKey<"MappingRuleId">;
```

The unique identifier of a mapping rule.

---

## Type Alias: MappingRuleResult


```ts
type MappingRuleResult = object;
```

## Properties

### claimName

```ts
claimName: string;
```

The name of the claim to map.

---

### claimValue

```ts
claimValue: string;
```

The value of the claim to map.

---

### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The ID of the mapping rule.

---

### name

```ts
name: string;
```

The name of the mapping rule.

---

## Type Alias: MappingRuleSearchQueryRequest


```ts
type MappingRuleSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: MappingRuleFilter;
```

The mapping rule search filters.

### sort?

```ts
optional sort?: MappingRuleSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: MappingRuleSearchQueryResult


```ts
type MappingRuleSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: MappingRuleResult[];
```

The matching mapping rules.

---

## Type Alias: MappingRuleSearchQuerySortRequest


```ts
type MappingRuleSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "mappingRuleId" | "claimName" | "claimValue" | "name";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: MappingRuleUpdateRequest


```ts
type MappingRuleUpdateRequest = MappingRuleCreateUpdateRequest;
```

---

## Type Alias: MappingRuleUpdateResult


```ts
type MappingRuleUpdateResult = MappingRuleCreateUpdateResult;
```

---

## Type Alias: MatchedDecisionRuleItem


```ts
type MatchedDecisionRuleItem = object;
```

A decision rule that matched within this decision evaluation.

## Properties

### evaluatedOutputs

```ts
evaluatedOutputs: EvaluatedDecisionOutputItem[];
```

The evaluated decision outputs.

---

### ruleId

```ts
ruleId: string;
```

The ID of the matched rule.

---

### ruleIndex

```ts
ruleIndex: number;
```

The index of the matched rule.

---

## Type Alias: MessageCorrelationRequest


```ts
type MessageCorrelationRequest = object;
```

## Properties

### businessId?

```ts
optional businessId?: BusinessId;
```

An optional business id used to enforce uniqueness of the process instance that a
message start event would create. If provided and uniqueness enforcement is enabled,
the engine rejects starting a new process instance when another root process instance
with the same business id is already active for the same process definition. It has no
effect when the message correlates to a catch, boundary, or intermediate event.

---

### correlationKey?

```ts
optional correlationKey?: string;
```

The correlation key of the message.

---

### name

```ts
name: string;
```

The message name as defined in the BPMN process

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

the tenant for which the message is published

---

### variables?

```ts
optional variables?: object;
```

The message variables as JSON document

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: MessageCorrelationResult


```ts
type MessageCorrelationResult = object;
```

The message key of the correlated message, as well as the first process instance key it
correlated with.

## Properties

### messageKey

```ts
messageKey: MessageKey;
```

The key of the correlated message.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the first process instance the message correlated with

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the correlated message

---

## Type Alias: MessageKey


```ts
type MessageKey = CamundaKey<"MessageKey">;
```

System-generated key for an message.

---

## Type Alias: MessagePublicationRequest


```ts
type MessagePublicationRequest = object;
```

## Properties

### businessId?

```ts
optional businessId?: BusinessId;
```

An optional business id used to enforce uniqueness of the process instance that a
message start event would create. If provided and uniqueness enforcement is enabled,
the engine rejects starting a new process instance when another root process instance
with the same business id is already active for the same process definition. It has no
effect when the message correlates to a catch, boundary, or intermediate event.

---

### correlationKey?

```ts
optional correlationKey?: string;
```

The correlation key of the message.

---

### messageId?

```ts
optional messageId?: string;
```

The unique ID of the message. This is used to ensure only one message with the given ID
will be published during the lifetime of the message (if `timeToLive` is set).

---

### name

```ts
name: string;
```

The name of the message.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant of the message sender.

---

### timeToLive?

```ts
optional timeToLive?: number;
```

Timespan (in ms) to buffer the message on the broker.

---

### variables?

```ts
optional variables?: object;
```

The message variables as JSON document.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: MessagePublicationResult


```ts
type MessagePublicationResult = object;
```

The message key of the published message.

## Properties

### messageKey

```ts
messageKey: MessageKey;
```

The key of the published message.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the message.

---

## Type Alias: MessageSubscriptionFilter


```ts
type MessageSubscriptionFilter = object;
```

Message subscription search filter.

## Properties

### correlationKey?

```ts
optional correlationKey?: StringFilterProperty;
```

The correlation key of the message subscription.

---

### elementId?

```ts
optional elementId?: StringFilterProperty;
```

The element ID associated with this message subscription.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKeyFilterProperty;
```

The element instance key associated with this message subscription.

---

### inboundConnectorType?

```ts
optional inboundConnectorType?: StringFilterProperty;
```

Filter by inbound connector type extracted from the `inbound.type` zeebe:property.

---

### lastUpdatedDate?

```ts
optional lastUpdatedDate?: DateTimeFilterProperty;
```

The last updated date of the message subscription.

---

### messageName?

```ts
optional messageName?: StringFilterProperty;
```

The name of the message associated with the message subscription.

---

### messageSubscriptionKey?

```ts
optional messageSubscriptionKey?: MessageSubscriptionKeyFilterProperty;
```

The message subscription key associated with this message subscription.

---

### messageSubscriptionState?

```ts
optional messageSubscriptionState?: MessageSubscriptionStateFilterProperty;
```

The message subscription state.

---

### messageSubscriptionType?

```ts
optional messageSubscriptionType?: MessageSubscriptionTypeFilterProperty;
```

The type of message subscription to filter by. When omitted, both
`START_EVENT` and `PROCESS_EVENT` are returned. Only available for data
created with Camunda 8.10 or later.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The process definition ID associated with this message subscription.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The process definition key associated with this correlated message subscription. This only works for data created with 8.9 and later.

---

### processDefinitionName?

```ts
optional processDefinitionName?: StringFilterProperty;
```

The name of the process definition associated with this message subscription.

---

### processDefinitionVersion?

```ts
optional processDefinitionVersion?: IntegerFilterProperty;
```

The version of the process definition associated with this message subscription.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The process instance key associated with this message subscription.

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

The unique external tenant ID.

---

### toolName?

```ts
optional toolName?: StringFilterProperty;
```

Filter by tool name extracted from the `io.camunda.tool:name` zeebe:property.

---

## Type Alias: MessageSubscriptionKey


```ts
type MessageSubscriptionKey = CamundaKey<"MessageSubscriptionKey">;
```

System-generated key for a message subscription.

---

## Type Alias: MessageSubscriptionKeyExactMatch


```ts
type MessageSubscriptionKeyExactMatch = MessageSubscriptionKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: MessageSubscriptionKeyFilterProperty


```ts
type MessageSubscriptionKeyFilterProperty =
  MessageSubscriptionKeyExactMatch | AdvancedMessageSubscriptionKeyFilter;
```

MessageSubscriptionKey property with full advanced search capabilities.

---

## Type Alias: MessageSubscriptionResult


```ts
type MessageSubscriptionResult = object;
```

## Properties

### correlationKey

```ts
correlationKey: string | null;
```

The correlation key of the message subscription.

---

### elementId

```ts
elementId: ElementId;
```

The element ID associated with this message subscription.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey | null;
```

The element instance key associated with this message subscription.
Only populated for intermediate event entities.

---

### inboundConnectorType

```ts
inboundConnectorType: string | null;
```

Inbound connector type extracted from the `inbound.type` zeebe:property.
Null when the property is absent.

---

### lastUpdatedDate

```ts
lastUpdatedDate: string;
```

The last updated date of the message subscription.

---

### messageName

```ts
messageName: string;
```

The name of the message associated with the message subscription.

---

### messageSubscriptionKey

```ts
messageSubscriptionKey: MessageSubscriptionKey;
```

The message subscription key associated with this message subscription.

---

### messageSubscriptionState

```ts
messageSubscriptionState: MessageSubscriptionStateEnum;
```

---

### messageSubscriptionType

```ts
messageSubscriptionType: MessageSubscriptionTypeEnum;
```

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition ID associated with this message subscription.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey | null;
```

The process definition key associated with this message subscription.

---

### processDefinitionName

```ts
processDefinitionName: string | null;
```

The name of the process definition associated with this message subscription.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number | null;
```

The version of the process definition associated with this message subscription.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey | null;
```

The process instance key associated with this message subscription.
Only populated for intermediate event entities.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### tenantId

```ts
tenantId: TenantId;
```

---

### toolName

```ts
toolName: string | null;
```

Tool name extracted from the `io.camunda.tool:name` zeebe:property.
Null when the property is absent.

---

### toolProperties

```ts
toolProperties: object;
```

The subset of `zeebe:properties` extension properties whose keys start with the
`io.camunda.tool:` prefix, extracted from the BPMN element associated with this
subscription. Empty object when no matching properties are defined.

#### Index Signature

```ts
[key: string]: string
```

---

## Type Alias: MessageSubscriptionSearchQuery


```ts
type MessageSubscriptionSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: MessageSubscriptionFilter;
```

The incident search filters.

### sort?

```ts
optional sort?: MessageSubscriptionSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: MessageSubscriptionSearchQueryResult


```ts
type MessageSubscriptionSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: MessageSubscriptionResult[];
```

The matching message subscriptions.

---

## Type Alias: MessageSubscriptionSearchQuerySortRequest


```ts
type MessageSubscriptionSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "messageSubscriptionKey"
  | "processDefinitionId"
  | "processDefinitionName"
  | "processDefinitionVersion"
  | "processInstanceKey"
  | "elementId"
  | "elementInstanceKey"
  | "messageSubscriptionState"
  | "messageSubscriptionType"
  | "lastUpdatedDate"
  | "messageName"
  | "correlationKey"
  | "tenantId"
  | "toolName"
  | "inboundConnectorType";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: MessageSubscriptionStateEnum


```ts
type MessageSubscriptionStateEnum =
  (typeof MessageSubscriptionStateEnum)[keyof typeof MessageSubscriptionStateEnum];
```

The state of message subscription.

**Note for `START_EVENT` subscriptions:** The `CORRELATED` and `MIGRATED` states are not
tracked for these subscriptions. To query correlation history for process start events,
use the `/correlated-message-subscriptions/search` endpoint.

---

## Type Alias: MessageSubscriptionStateExactMatch


```ts
type MessageSubscriptionStateExactMatch = MessageSubscriptionStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: MessageSubscriptionStateFilterProperty


```ts
type MessageSubscriptionStateFilterProperty =
  MessageSubscriptionStateExactMatch | AdvancedMessageSubscriptionStateFilter;
```

MessageSubscriptionStateEnum with full advanced search capabilities.

---

## Type Alias: MessageSubscriptionTypeEnum


```ts
type MessageSubscriptionTypeEnum =
  (typeof MessageSubscriptionTypeEnum)[keyof typeof MessageSubscriptionTypeEnum];
```

The type of message subscription.
`START_EVENT` is definition-scoped (process start events). Always has a value; only
captured from Camunda 8.10 onwards.
`PROCESS_EVENT` is instance-scoped (intermediate catch events). Pre-8.10 entries have
no value stored; the API returns `PROCESS_EVENT` as a default for those entries.

---

## Type Alias: MessageSubscriptionTypeExactMatch


```ts
type MessageSubscriptionTypeExactMatch = MessageSubscriptionTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: MessageSubscriptionTypeFilterProperty


```ts
type MessageSubscriptionTypeFilterProperty =
  MessageSubscriptionTypeExactMatch | AdvancedMessageSubscriptionTypeFilter;
```

MessageSubscriptionTypeEnum with full advanced search capabilities.

---

## Type Alias: MessageWaitStateDetails


```ts
type MessageWaitStateDetails = BaseWaitStateDetails & object;
```

## Type Declaration

### correlationKey

```ts
correlationKey: string | null;
```

The correlation key for the message subscription (null for start events).

### messageName

```ts
messageName: string;
```

The name of the message being awaited.

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: MigrateProcessInstanceData


```ts
type MigrateProcessInstanceData = object;
```

## Properties

### body

```ts
body: ProcessInstanceMigrationInstruction;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance that should be migrated.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/migration";
```

---

## Type Alias: MigrateProcessInstanceError


```ts
type MigrateProcessInstanceError =
  MigrateProcessInstanceErrors[keyof MigrateProcessInstanceErrors];
```

---

## Type Alias: MigrateProcessInstanceErrors


```ts
type MigrateProcessInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The process instance is not found.

---

### 409

```ts
409: ProblemDetail;
```

The process instance migration failed. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: MigrateProcessInstanceMappingInstruction


```ts
type MigrateProcessInstanceMappingInstruction = object;
```

The mapping instructions describe how to map elements from the source process definition to the target process definition.

## Properties

### sourceElementId

```ts
sourceElementId: ElementId;
```

The element id to migrate from.

---

### targetElementId

```ts
targetElementId: ElementId;
```

The element id to migrate into.

---

## Type Alias: MigrateProcessInstanceResponse


```ts
type MigrateProcessInstanceResponse =
  MigrateProcessInstanceResponses[keyof MigrateProcessInstanceResponses];
```

---

## Type Alias: MigrateProcessInstanceResponses


```ts
type MigrateProcessInstanceResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The process instance is migrated.

---

## Type Alias: MigrateProcessInstancesBatchOperationData


```ts
type MigrateProcessInstancesBatchOperationData = object;
```

## Properties

### body

```ts
body: ProcessInstanceMigrationBatchOperationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/migration";
```

---

## Type Alias: MigrateProcessInstancesBatchOperationError


```ts
type MigrateProcessInstancesBatchOperationError =
  MigrateProcessInstancesBatchOperationErrors[keyof MigrateProcessInstancesBatchOperationErrors];
```

---

## Type Alias: MigrateProcessInstancesBatchOperationErrors


```ts
type MigrateProcessInstancesBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The process instance batch operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: MigrateProcessInstancesBatchOperationResponse


```ts
type MigrateProcessInstancesBatchOperationResponse =
  MigrateProcessInstancesBatchOperationResponses[keyof MigrateProcessInstancesBatchOperationResponses];
```

---

## Type Alias: MigrateProcessInstancesBatchOperationResponses


```ts
type MigrateProcessInstancesBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request was created.

---

## Type Alias: ModifyProcessInstanceData


```ts
type ModifyProcessInstanceData = object;
```

## Properties

### body

```ts
body: ProcessInstanceModificationInstruction;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance that should be modified.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/modification";
```

---

## Type Alias: ModifyProcessInstanceError


```ts
type ModifyProcessInstanceError =
  ModifyProcessInstanceErrors[keyof ModifyProcessInstanceErrors];
```

---

## Type Alias: ModifyProcessInstanceErrors


```ts
type ModifyProcessInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The process instance is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ModifyProcessInstanceResponse


```ts
type ModifyProcessInstanceResponse =
  ModifyProcessInstanceResponses[keyof ModifyProcessInstanceResponses];
```

---

## Type Alias: ModifyProcessInstanceResponses


```ts
type ModifyProcessInstanceResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The process instance is modified.

---

## Type Alias: ModifyProcessInstanceVariableInstruction


```ts
type ModifyProcessInstanceVariableInstruction = object;
```

Instruction describing which variables to create or update.

## Properties

### scopeId?

```ts
optional scopeId?: string;
```

The id of the element in which scope the variables should be created.
Leave empty to create the variables in the global scope of the process instance.

---

### variables

```ts
variables: object;
```

JSON document that will instantiate the variables at the scope defined by the scopeId.
It must be a JSON object, as variables will be mapped in a key-value fashion.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: ModifyProcessInstancesBatchOperationData


```ts
type ModifyProcessInstancesBatchOperationData = object;
```

## Properties

### body

```ts
body: ProcessInstanceModificationBatchOperationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/modification";
```

---

## Type Alias: ModifyProcessInstancesBatchOperationError


```ts
type ModifyProcessInstancesBatchOperationError =
  ModifyProcessInstancesBatchOperationErrors[keyof ModifyProcessInstancesBatchOperationErrors];
```

---

## Type Alias: ModifyProcessInstancesBatchOperationErrors


```ts
type ModifyProcessInstancesBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The process instance batch operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: ModifyProcessInstancesBatchOperationResponse


```ts
type ModifyProcessInstancesBatchOperationResponse =
  ModifyProcessInstancesBatchOperationResponses[keyof ModifyProcessInstancesBatchOperationResponses];
```

---

## Type Alias: ModifyProcessInstancesBatchOperationResponses


```ts
type ModifyProcessInstancesBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request was created.

---

## Type Alias: OffsetPagination


```ts
type OffsetPagination = object;
```

Offset-based pagination

## Properties

### from?

```ts
optional from?: number;
```

The index of items to start searching from.

---

### limit?

```ts
optional limit?: number;
```

The maximum number of items to return in one request.

---

## Type Alias: OperationReference


```ts
type OperationReference = number;
```

A reference key chosen by the user that will be part of all records resulting from this operation.
Must be > 0 if provided.

---

## Type Alias: OperationTypeExactMatch


```ts
type OperationTypeExactMatch = AuditLogOperationTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: OperationTypeFilterProperty


```ts
type OperationTypeFilterProperty =
  OperationTypeExactMatch | AdvancedOperationTypeFilter;
```

AuditLogOperationTypeEnum property with full advanced search capabilities.

---

## Type Alias: OwnerTypeEnum


```ts
type OwnerTypeEnum = (typeof OwnerTypeEnum)[keyof typeof OwnerTypeEnum];
```

The type of the owner of permissions.

---

## Type Alias: Partition


```ts
type Partition = object;
```

Provides information on a partition within a broker node.

## Properties

### health

```ts
health: "healthy" | "unhealthy" | "dead";
```

Describes the current health of the partition.

---

### partitionId

```ts
partitionId: number;
```

The unique ID of this partition.

---

### role

```ts
role: "leader" | "follower" | "inactive";
```

Describes the Raft role of the broker for a given partition.

---

## Type Alias: PermissionTypeEnum


```ts
type PermissionTypeEnum =
  (typeof PermissionTypeEnum)[keyof typeof PermissionTypeEnum];
```

Specifies the type of permissions.

---

## Type Alias: PinClockData


```ts
type PinClockData = object;
```

## Properties

### body

```ts
body: ClockPinRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/clock";
```

---

## Type Alias: PinClockError


```ts
type PinClockError = PinClockErrors[keyof PinClockErrors];
```

---

## Type Alias: PinClockErrors


```ts
type PinClockErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: PinClockResponse


```ts
type PinClockResponse = PinClockResponses[keyof PinClockResponses];
```

---

## Type Alias: PinClockResponses


```ts
type PinClockResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The clock was successfully pinned.

---

## Type Alias: ProblemDetail


```ts
type ProblemDetail = object;
```

A Problem detail object as described in [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457). There may be additional properties specific to the problem type.

## Properties

### detail

```ts
detail: string;
```

An explanation of the problem in more detail.

---

### instance

```ts
instance: string;
```

A URI path identifying the origin of the problem.

---

### status

```ts
status: number;
```

The HTTP status code for this problem.

---

### title

```ts
title: string;
```

A summary of the problem type.

---

### type

```ts
type: string;
```

A URI identifying the problem type.

---

## Type Alias: ProcessDefinitionElementStatisticsQuery


```ts
type ProcessDefinitionElementStatisticsQuery = object;
```

Process definition element statistics request.

## Properties

### filter?

```ts
optional filter?: ProcessDefinitionStatisticsFilter;
```

The process definition statistics search filters.

---

## Type Alias: ProcessDefinitionElementStatisticsQueryResult


```ts
type ProcessDefinitionElementStatisticsQueryResult = object;
```

Process definition element statistics query response.

## Properties

### items

```ts
items: ProcessElementStatisticsResult[];
```

The element statistics.

---

## Type Alias: ProcessDefinitionFilter


```ts
type ProcessDefinitionFilter = object;
```

Process definition search filter.

## Properties

### hasStartForm?

```ts
optional hasStartForm?: boolean;
```

Indicates whether the start event of the process has an associated Form Key.

---

### isLatestVersion?

```ts
optional isLatestVersion?: boolean;
```

Whether to only return the latest version of each process definition.
When using this filter, pagination functionality is limited, you can only paginate forward using `after` and `limit`.
The response contains no `startCursor` in the `page`, and requests ignore the `from` and `before` in the `page`.
When using this filter, sorting is limited to `processDefinitionId` and `tenantId` fields only.

---

### name?

```ts
optional name?: StringFilterProperty;
```

Name of this process definition.

---

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

Process definition ID of this process definition.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKey;
```

The key for this process definition.

---

### resourceName?

```ts
optional resourceName?: string;
```

Resource name of this process definition.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

Tenant ID of this process definition.

---

### version?

```ts
optional version?: number;
```

Version of this process definition.

---

### versionTag?

```ts
optional versionTag?: string;
```

Version tag of this process definition.

---

## Type Alias: ProcessDefinitionId


```ts
type ProcessDefinitionId = CamundaKey<"ProcessDefinitionId">;
```

Id of a process definition, from the model. Only ids of process definitions that are deployed are useful.

---

## Type Alias: ProcessDefinitionIdExactMatch


```ts
type ProcessDefinitionIdExactMatch = ProcessDefinitionId;
```

Exact match

Matches the value exactly.

---

## Type Alias: ProcessDefinitionIdFilterProperty


```ts
type ProcessDefinitionIdFilterProperty =
  ProcessDefinitionIdExactMatch | AdvancedProcessDefinitionIdFilter;
```

ProcessDefinitionId property with full advanced search capabilities.

---

## Type Alias: ProcessDefinitionInstanceStatisticsQuery


```ts
type ProcessDefinitionInstanceStatisticsQuery = object;
```

## Properties

### page?

```ts
optional page?: OffsetPagination;
```

Search cursor pagination.

---

### sort?

```ts
optional sort?: ProcessDefinitionInstanceStatisticsQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ProcessDefinitionInstanceStatisticsQueryResult


```ts
type ProcessDefinitionInstanceStatisticsQueryResult = SearchQueryResponse &
  object;
```

## Type Declaration

### items

```ts
items: ProcessDefinitionInstanceStatisticsResult[];
```

The process definition instance statistics result.

---

## Type Alias: ProcessDefinitionInstanceStatisticsQuerySortRequest


```ts
type ProcessDefinitionInstanceStatisticsQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "processDefinitionId"
  | "activeInstancesWithIncidentCount"
  | "activeInstancesWithoutIncidentCount";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ProcessDefinitionInstanceStatisticsResult


```ts
type ProcessDefinitionInstanceStatisticsResult = object;
```

Process definition instance statistics response.

## Properties

### activeInstancesWithIncidentCount

```ts
activeInstancesWithIncidentCount: number;
```

Total number of currently active process instances of this definition that have at least one incident.

---

### activeInstancesWithoutIncidentCount

```ts
activeInstancesWithoutIncidentCount: number;
```

Total number of currently active process instances of this definition that do not have incidents.

---

### hasMultipleVersions

```ts
hasMultipleVersions: boolean;
```

Indicates whether multiple versions of this process definition instance are deployed.

---

### latestProcessDefinitionName

```ts
latestProcessDefinitionName: string | null;
```

Name of the latest deployed process definition instance version.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

---

### tenantId

```ts
tenantId: TenantId;
```

---

## Type Alias: ProcessDefinitionInstanceVersionStatisticsFilter


```ts
type ProcessDefinitionInstanceVersionStatisticsFilter = object;
```

Process definition instance version statistics search filter.

## Properties

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The ID of the process definition to retrieve version statistics for.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

Tenant ID of this process definition.

---

## Type Alias: ProcessDefinitionInstanceVersionStatisticsQuery


```ts
type ProcessDefinitionInstanceVersionStatisticsQuery = object;
```

## Properties

### filter

```ts
filter: ProcessDefinitionInstanceVersionStatisticsFilter;
```

The process definition instance version statistics search filters.

---

### page?

```ts
optional page?: OffsetPagination;
```

Pagination criteria.

---

### sort?

```ts
optional sort?: ProcessDefinitionInstanceVersionStatisticsQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ProcessDefinitionInstanceVersionStatisticsQueryResult


```ts
type ProcessDefinitionInstanceVersionStatisticsQueryResult =
  SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: ProcessDefinitionInstanceVersionStatisticsResult[];
```

The process definition instance version statistics result.

---

## Type Alias: ProcessDefinitionInstanceVersionStatisticsQuerySortRequest


```ts
type ProcessDefinitionInstanceVersionStatisticsQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "processDefinitionId"
  | "processDefinitionKey"
  | "processDefinitionName"
  | "processDefinitionVersion"
  | "activeInstancesWithIncidentCount"
  | "activeInstancesWithoutIncidentCount";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ProcessDefinitionInstanceVersionStatisticsResult


```ts
type ProcessDefinitionInstanceVersionStatisticsResult = object;
```

Process definition instance version statistics response.

## Properties

### activeInstancesWithIncidentCount

```ts
activeInstancesWithIncidentCount: number;
```

The number of active process instances for this version that currently have incidents.

---

### activeInstancesWithoutIncidentCount

```ts
activeInstancesWithoutIncidentCount: number;
```

The number of active process instances for this version that do not have any incidents.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The ID associated with the process definition.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The unique key of the process definition.

---

### processDefinitionName

```ts
processDefinitionName: string | null;
```

The name of the process definition.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version number of the process definition.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID associated with the process definition.

---

## Type Alias: ProcessDefinitionKey


```ts
type ProcessDefinitionKey = CamundaKey<"ProcessDefinitionKey">;
```

System-generated key for a deployed process definition.

---

## Type Alias: ProcessDefinitionKeyExactMatch


```ts
type ProcessDefinitionKeyExactMatch = ProcessDefinitionKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: ProcessDefinitionKeyFilterProperty


```ts
type ProcessDefinitionKeyFilterProperty =
  ProcessDefinitionKeyExactMatch | AdvancedProcessDefinitionKeyFilter;
```

ProcessDefinitionKey property with full advanced search capabilities.

---

## Type Alias: ProcessDefinitionMessageSubscriptionStatisticsQuery


```ts
type ProcessDefinitionMessageSubscriptionStatisticsQuery = object;
```

## Properties

### filter?

```ts
optional filter?: MessageSubscriptionFilter;
```

The message subscription filters.

---

### page?

```ts
optional page?: CursorForwardPagination;
```

Search cursor pagination.

---

## Type Alias: ProcessDefinitionMessageSubscriptionStatisticsQueryResult


```ts
type ProcessDefinitionMessageSubscriptionStatisticsQueryResult =
  SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: ProcessDefinitionMessageSubscriptionStatisticsResult[];
```

The matching process definition message subscription statistics.

---

## Type Alias: ProcessDefinitionMessageSubscriptionStatisticsResult


```ts
type ProcessDefinitionMessageSubscriptionStatisticsResult = object;
```

## Properties

### activeSubscriptions

```ts
activeSubscriptions: number;
```

The total number of active message subscriptions for this process definition key.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition ID associated with this message subscription.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key associated with this message subscription.

---

### processInstancesWithActiveSubscriptions

```ts
processInstancesWithActiveSubscriptions: number;
```

The number of process instances with active message subscriptions.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID associated with this message subscription.

---

## Type Alias: ProcessDefinitionResult


```ts
type ProcessDefinitionResult = object;
```

## Properties

### hasStartForm

```ts
hasStartForm: boolean;
```

Indicates whether the start event of the process has an associated Form Key.

---

### name

```ts
name: string | null;
```

Name of this process definition.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

Process definition ID of this process definition.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key for this process definition.

---

### resourceName

```ts
resourceName: string;
```

Resource name for this process definition.

---

### tenantId

```ts
tenantId: TenantId;
```

Tenant ID of this process definition.

---

### version

```ts
version: number;
```

Version of this process definition.

---

### versionTag

```ts
versionTag: string | null;
```

Version tag of this process definition.

---

## Type Alias: ProcessDefinitionSearchQuery


```ts
type ProcessDefinitionSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: ProcessDefinitionFilter;
```

The process definition search filters.

### sort?

```ts
optional sort?: ProcessDefinitionSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ProcessDefinitionSearchQueryResult


```ts
type ProcessDefinitionSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: ProcessDefinitionResult[];
```

The matching process definitions.

---

## Type Alias: ProcessDefinitionSearchQuerySortRequest


```ts
type ProcessDefinitionSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "processDefinitionKey"
  | "name"
  | "resourceName"
  | "version"
  | "versionTag"
  | "processDefinitionId"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ProcessDefinitionStatisticsFilter


```ts
type ProcessDefinitionStatisticsFilter = BaseProcessInstanceFilterFields &
  object;
```

Process definition statistics search filter.

## Type Declaration

### $or?

```ts
optional $or?: BaseProcessInstanceFilterFields[];
```

Defines a list of alternative filter groups combined using OR logic. Each object in the array is evaluated independently, and the filter matches if any one of them is satisfied.

Top-level fields and the `$or` clause are combined using AND logic — meaning: (top-level filters) AND (any of the `$or` filters) must match.

_Example:_

```json
{
  "state": "ACTIVE",
  "tenantId": 123,
  "$or": [
    { "processDefinitionId": "process_v1" },
    { "processDefinitionId": "process_v2", "hasIncident": true }
  ]
}
```

This matches process instances that:

- are in _ACTIVE_ state
- have tenant id equal to _123_
- and match either:

- `processDefinitionId` is _process_v1_, or
- `processDefinitionId` is _process_v2_ and `hasIncident` is _true_

Note: Using complex `$or` conditions may impact performance, use with caution in high-volume environments.

---

## Type Alias: ProcessElementStatisticsResult


```ts
type ProcessElementStatisticsResult = object;
```

Process element statistics response.

## Properties

### active

```ts
active: number;
```

The total number of active instances of the element.

---

### canceled

```ts
canceled: number;
```

The total number of canceled instances of the element.

---

### completed

```ts
completed: number;
```

The total number of completed instances of the element.

---

### elementId

```ts
elementId: ElementId;
```

The element ID for which the results are aggregated.

---

### incidents

```ts
incidents: number;
```

The total number of incidents for the element.

---

## Type Alias: ProcessInstanceCallHierarchyEntry


```ts
type ProcessInstanceCallHierarchyEntry = object;
```

## Properties

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the process definition.

---

### processDefinitionName

```ts
processDefinitionName: string;
```

The name of the process definition (fall backs to the process definition id if not available).

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance.

---

## Type Alias: ProcessInstanceCancellationBatchOperationRequest


```ts
type ProcessInstanceCancellationBatchOperationRequest = object;
```

The process instance filter that defines which process instances should be canceled.

## Properties

### filter

```ts
filter: ProcessInstanceFilter;
```

The process instance filter.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: ProcessInstanceCreationInstruction


```ts
type ProcessInstanceCreationInstruction =
  | ProcessInstanceCreationInstructionByKey
  | ProcessInstanceCreationInstructionById;
```

Instructions for creating a process instance. The process definition can be specified
either by id or by key.

---

## Type Alias: ProcessInstanceCreationInstructionById


```ts
type ProcessInstanceCreationInstructionById = object;
```

Process creation by id

## Properties

### awaitCompletion?

```ts
optional awaitCompletion?: boolean;
```

Wait for the process instance to complete. If the process instance does not complete
within the request timeout limit, a 504 response status will be returned. The process
instance will continue to run in the background regardless of the timeout. Disabled by
default.

---

### businessId?

```ts
optional businessId?: BusinessId;
```

---

### fetchVariables?

```ts
optional fetchVariables?: string[];
```

List of variables by name to be included in the response when awaitCompletion is set to true.
If empty, all visible variables in the root scope will be returned.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The BPMN process id of the process definition to start an instance of.

---

### processDefinitionVersion?

```ts
optional processDefinitionVersion?: number;
```

The version of the process. By default, the latest version of the process is used.

---

### requestTimeout?

```ts
optional requestTimeout?: number;
```

Timeout (in ms) the request waits for the process to complete. By default or
when set to 0, the generic request timeout configured in the cluster is applied.

---

### runtimeInstructions?

```ts
optional runtimeInstructions?: ProcessInstanceCreationRuntimeInstruction[];
```

Runtime instructions (alpha). List of instructions that affect the runtime behavior of
the process instance. Refer to specific instruction types for more details.

This parameter is an alpha feature and may be subject to change
in future releases.

---

### startInstructions?

```ts
optional startInstructions?: ProcessInstanceCreationStartInstruction[];
```

List of start instructions. By default, the process instance will start at
the start event. If provided, the process instance will apply start instructions
after it has been created.

---

### tags?

```ts
optional tags?: TagSet;
```

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant id of the process definition.
If multi-tenancy is enabled, provide the tenant id of the process definition to start a
process instance of. If multi-tenancy is disabled, don't provide this parameter.

---

### variables?

```ts
optional variables?: object;
```

JSON object that will instantiate the variables for the root variable scope
of the process instance.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: ProcessInstanceCreationInstructionByKey


```ts
type ProcessInstanceCreationInstructionByKey = object;
```

Process creation by key

## Properties

### awaitCompletion?

```ts
optional awaitCompletion?: boolean;
```

Wait for the process instance to complete. If the process instance does not complete
within the request timeout limit, a 504 response status will be returned. The process
instance will continue to run in the background regardless of the timeout. Disabled by
default.

---

### businessId?

```ts
optional businessId?: BusinessId;
```

---

### fetchVariables?

```ts
optional fetchVariables?: string[];
```

List of variables by name to be included in the response when awaitCompletion is set to true.
If empty, all visible variables in the root scope will be returned.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The unique key identifying the process definition, for example, returned for a process in the
deploy resources endpoint.

---

### processDefinitionVersion?

```ts
optional processDefinitionVersion?: number;
```

As the version is already identified by the `processDefinitionKey`, the value of this field is ignored.
It's here for backwards-compatibility only as previous releases accepted it in request bodies.

---

### requestTimeout?

```ts
optional requestTimeout?: number;
```

Timeout (in ms) the request waits for the process to complete. By default or
when set to 0, the generic request timeout configured in the cluster is applied.

---

### runtimeInstructions?

```ts
optional runtimeInstructions?: ProcessInstanceCreationRuntimeInstruction[];
```

Runtime instructions (alpha). List of instructions that affect the runtime behavior of
the process instance. Refer to specific instruction types for more details.

This parameter is an alpha feature and may be subject to change
in future releases.

---

### startInstructions?

```ts
optional startInstructions?: ProcessInstanceCreationStartInstruction[];
```

List of start instructions. By default, the process instance will start at
the start event. If provided, the process instance will apply start instructions
after it has been created.

---

### tags?

```ts
optional tags?: TagSet;
```

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The tenant id of the process definition.
If multi-tenancy is enabled, provide the tenant id of the process definition to start a
process instance of. If multi-tenancy is disabled, don't provide this parameter.

---

### variables?

```ts
optional variables?: object;
```

Set of variables as JSON object to instantiate in the root variable scope of the process
instance. Can include nested complex objects.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: ProcessInstanceCreationRuntimeInstruction


```ts
type ProcessInstanceCreationRuntimeInstruction = object &
  ProcessInstanceCreationTerminateInstruction;
```

## Type Declaration

### type

```ts
type: "TERMINATE_PROCESS_INSTANCE";
```

---

## Type Alias: ProcessInstanceCreationStartInstruction


```ts
type ProcessInstanceCreationStartInstruction = object;
```

## Properties

### elementId

```ts
elementId: ElementId;
```

Future extensions might include:

- different types of start instructions
- ability to set local variables for different flow scopes

For now, however, the start instruction is implicitly a "startBeforeElement" instruction

---

## Type Alias: ProcessInstanceCreationTerminateInstruction


```ts
type ProcessInstanceCreationTerminateInstruction = object;
```

Terminates the process instance after a specific BPMN element is completed or terminated.

## Properties

### afterElementId

```ts
afterElementId: ElementId;
```

The id of the element that, once completed or terminated, will cause the process to be terminated.

---

### type?

```ts
optional type?: string;
```

The type of the runtime instruction

---

## Type Alias: ProcessInstanceDeletionBatchOperationRequest


```ts
type ProcessInstanceDeletionBatchOperationRequest = object;
```

The process instance filter that defines which process instances should be deleted.

## Properties

### filter

```ts
filter: ProcessInstanceFilter;
```

The process instance filter.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: ProcessInstanceElementStatisticsQueryResult


```ts
type ProcessInstanceElementStatisticsQueryResult = object;
```

Process instance element statistics query response.

## Properties

### items

```ts
items: ProcessElementStatisticsResult[];
```

The element statistics.

---

## Type Alias: ProcessInstanceFilter


```ts
type ProcessInstanceFilter = ProcessInstanceFilterFields & object;
```

Process instance search filter.

## Type Declaration

### $or?

```ts
optional $or?: ProcessInstanceFilterFields[];
```

Defines a list of alternative filter groups combined using OR logic. Each object in the array is evaluated independently, and the filter matches if any one of them is satisfied.

Top-level fields and the `$or` clause are combined using AND logic — meaning: (top-level filters) AND (any of the `$or` filters) must match.

_Example:_

```json
{
  "state": "ACTIVE",
  "tenantId": 123,
  "$or": [
    { "processDefinitionId": "process_v1" },
    { "processDefinitionId": "process_v2", "hasIncident": true }
  ]
}
```

This matches process instances that:

- are in _ACTIVE_ state
- have tenant id equal to _123_
- and match either:

- `processDefinitionId` is _process_v1_, or
- `processDefinitionId` is _process_v2_ and `hasIncident` is _true_

Note: Using complex `$or` conditions may impact performance, use with caution in high-volume environments.

---

## Type Alias: ProcessInstanceFilterFields


```ts
type ProcessInstanceFilterFields = BaseProcessInstanceFilterFields & object;
```

Process instance search filter.

## Type Declaration

### processDefinitionId?

```ts
optional processDefinitionId?: StringFilterProperty;
```

The process definition id.

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The process definition key.

### processDefinitionName?

```ts
optional processDefinitionName?: StringFilterProperty;
```

The process definition name.

### processDefinitionVersion?

```ts
optional processDefinitionVersion?: IntegerFilterProperty;
```

The process definition version.

### processDefinitionVersionTag?

```ts
optional processDefinitionVersionTag?: StringFilterProperty;
```

The process definition version tag.

---

## Type Alias: ProcessInstanceIncidentResolutionBatchOperationRequest


```ts
type ProcessInstanceIncidentResolutionBatchOperationRequest = object;
```

The process instance filter that defines which process instances should have their incidents resolved.

## Properties

### filter

```ts
filter: ProcessInstanceFilter;
```

The process instance filter.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: ProcessInstanceKey


```ts
type ProcessInstanceKey = CamundaKey<"ProcessInstanceKey">;
```

System-generated key for a process instance.

---

## Type Alias: ProcessInstanceKeyExactMatch


```ts
type ProcessInstanceKeyExactMatch = ProcessInstanceKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: ProcessInstanceKeyFilterProperty


```ts
type ProcessInstanceKeyFilterProperty =
  ProcessInstanceKeyExactMatch | AdvancedProcessInstanceKeyFilter;
```

ProcessInstanceKey property with full advanced search capabilities.

---

## Type Alias: ProcessInstanceMigrationBatchOperationPlan


```ts
type ProcessInstanceMigrationBatchOperationPlan = object;
```

The migration instructions describe how to migrate a process instance from one process definition to another.

## Properties

### mappingInstructions

```ts
mappingInstructions: MigrateProcessInstanceMappingInstruction[];
```

The mapping instructions.

---

### targetProcessDefinitionKey

```ts
targetProcessDefinitionKey: ProcessDefinitionKey;
```

The target process definition key.

---

## Type Alias: ProcessInstanceMigrationBatchOperationRequest


```ts
type ProcessInstanceMigrationBatchOperationRequest = object;
```

## Properties

### filter

```ts
filter: ProcessInstanceFilter;
```

The process instance filter.

---

### migrationPlan

```ts
migrationPlan: ProcessInstanceMigrationBatchOperationPlan;
```

The migration plan.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: ProcessInstanceMigrationInstruction


```ts
type ProcessInstanceMigrationInstruction = object;
```

The migration instructions describe how to migrate a process instance from one process definition to another.

## Properties

### mappingInstructions

```ts
mappingInstructions: MigrateProcessInstanceMappingInstruction[];
```

Element mappings from the source process instance to the target process instance.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

### targetProcessDefinitionKey

```ts
targetProcessDefinitionKey: ProcessDefinitionKey;
```

The key of process definition to migrate the process instance to.

---

## Type Alias: ProcessInstanceModificationActivateInstruction


```ts
type ProcessInstanceModificationActivateInstruction = object;
```

Instruction describing an element to activate.

## Properties

### ancestorElementInstanceKey?

```ts
optional ancestorElementInstanceKey?: ElementInstanceKey;
```

The key of the ancestor scope the element instance should be created in.
Set to -1 to create the new element instance within an existing element instance of the
flow scope. If multiple instances of the target element's flow scope exist, choose one
specifically with this property by providing its key.

---

### elementId

```ts
elementId: ElementId;
```

The id of the element to activate.

---

### variableInstructions?

```ts
optional variableInstructions?: ModifyProcessInstanceVariableInstruction[];
```

Instructions describing which variables to create or update.

---

## Type Alias: ProcessInstanceModificationBatchOperationRequest


```ts
type ProcessInstanceModificationBatchOperationRequest = object;
```

The process instance filter to define on which process instances tokens should be moved,
and new element instances should be activated or terminated.

## Properties

### filter

```ts
filter: ProcessInstanceFilter;
```

The process instance filter.

---

### moveInstructions

```ts
moveInstructions: ProcessInstanceModificationMoveBatchOperationInstruction[];
```

Instructions for moving tokens between elements.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

## Type Alias: ProcessInstanceModificationInstruction


```ts
type ProcessInstanceModificationInstruction = object;
```

## Properties

### activateInstructions?

```ts
optional activateInstructions?: ProcessInstanceModificationActivateInstruction[];
```

Instructions describing which elements to activate in which scopes and which variables to create or update.

---

### moveInstructions?

```ts
optional moveInstructions?: ProcessInstanceModificationMoveInstruction[];
```

Instructions describing which elements to move from one scope to another.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

### terminateInstructions?

```ts
optional terminateInstructions?: ProcessInstanceModificationTerminateInstruction[];
```

Instructions describing which elements to terminate.

---

## Type Alias: ProcessInstanceModificationMoveBatchOperationInstruction


```ts
type ProcessInstanceModificationMoveBatchOperationInstruction = object;
```

Instructions describing a move operation. This instruction will terminate all active
element instances at `sourceElementId` and activate a new element instance for each
terminated one at `targetElementId`. The new element instances are created in the parent
scope of the source element instances.

## Properties

### sourceElementId

```ts
sourceElementId: ElementId;
```

The source element ID.

---

### targetElementId

```ts
targetElementId: ElementId;
```

The target element ID.

---

## Type Alias: ProcessInstanceModificationMoveInstruction


```ts
type ProcessInstanceModificationMoveInstruction = object;
```

Instruction describing a move operation. This instruction will terminate active element
instances based on the sourceElementInstruction and activate a new element instance for each terminated
one at targetElementId. Note that, for multi-instance activities, only the multi-instance
body instances will activate new element instances at the target id.

## Properties

### ancestorScopeInstruction?

```ts
optional ancestorScopeInstruction?: AncestorScopeInstruction;
```

---

### sourceElementInstruction

```ts
sourceElementInstruction: SourceElementInstruction;
```

---

### targetElementId

```ts
targetElementId: ElementId;
```

The target element id.

---

### variableInstructions?

```ts
optional variableInstructions?: ModifyProcessInstanceVariableInstruction[];
```

Instructions describing which variables to create or update.

---

## Type Alias: ProcessInstanceModificationTerminateByIdInstruction


```ts
type ProcessInstanceModificationTerminateByIdInstruction = object;
```

Instruction describing which elements to terminate. The element instances are determined
at runtime by the given id.

## Properties

### elementId

```ts
elementId: ElementId;
```

The id of the elements to terminate. The element instances are determined at runtime.

---

## Type Alias: ProcessInstanceModificationTerminateByKeyInstruction


```ts
type ProcessInstanceModificationTerminateByKeyInstruction = object;
```

Instruction providing the key of the element instance to terminate.

## Properties

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the element instance to terminate.

---

## Type Alias: ProcessInstanceModificationTerminateInstruction


```ts
type ProcessInstanceModificationTerminateInstruction =
  | ProcessInstanceModificationTerminateByIdInstruction
  | ProcessInstanceModificationTerminateByKeyInstruction;
```

Instruction describing which elements to terminate.

---

## Type Alias: ProcessInstanceReference


```ts
type ProcessInstanceReference = object;
```

## Properties

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the process definition.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the created process instance.

---

## Type Alias: ProcessInstanceResult


```ts
type ProcessInstanceResult = object;
```

Process instance search response item.

## Properties

### businessId

```ts
businessId: BusinessId | null;
```

The business id associated with this process instance.

---

### endDate

```ts
endDate: string | null;
```

The completion or termination time of the process instance.

---

### hasIncident

```ts
hasIncident: boolean;
```

Whether this process instance has a related incident or not.

---

### parentElementInstanceKey

```ts
parentElementInstanceKey: ElementInstanceKey | null;
```

The parent element instance key.

---

### parentProcessInstanceKey

```ts
parentProcessInstanceKey: ProcessInstanceKey | null;
```

The parent process instance key.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key.

---

### processDefinitionName

```ts
processDefinitionName: string | null;
```

The process definition name.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The process definition version.

---

### processDefinitionVersionTag

```ts
processDefinitionVersionTag: string | null;
```

The process definition version tag.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of this process instance.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### startDate

```ts
startDate: string;
```

The start time of the process instance.

---

### state

```ts
state: ProcessInstanceStateEnum;
```

---

### tags

```ts
tags: TagSet;
```

---

### tenantId

```ts
tenantId: TenantId;
```

---

## Type Alias: ProcessInstanceSearchQuery


```ts
type ProcessInstanceSearchQuery = SearchQueryRequest & object;
```

Process instance search request.

## Type Declaration

### filter?

```ts
optional filter?: ProcessInstanceFilter;
```

The process instance search filters.

### sort?

```ts
optional sort?: ProcessInstanceSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ProcessInstanceSearchQueryResult


```ts
type ProcessInstanceSearchQueryResult = SearchQueryResponse & object;
```

Process instance search response.

## Type Declaration

### items

```ts
items: ProcessInstanceResult[];
```

The matching process instances.

---

## Type Alias: ProcessInstanceSearchQuerySortRequest


```ts
type ProcessInstanceSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "processInstanceKey"
  | "processDefinitionId"
  | "processDefinitionName"
  | "processDefinitionVersion"
  | "processDefinitionVersionTag"
  | "processDefinitionKey"
  | "parentProcessInstanceKey"
  | "parentElementInstanceKey"
  | "startDate"
  | "endDate"
  | "state"
  | "hasIncident"
  | "tenantId"
  | "businessId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ProcessInstanceSequenceFlowResult


```ts
type ProcessInstanceSequenceFlowResult = object;
```

Process instance sequence flow result.

## Properties

### elementId

```ts
elementId: ElementId;
```

The element id for this sequence flow, as provided in the BPMN process.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The process definition id.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The process definition key.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of this process instance.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### sequenceFlowId

```ts
sequenceFlowId: string;
```

The sequence flow id.

---

### tenantId

```ts
tenantId: TenantId;
```

---

## Type Alias: ProcessInstanceSequenceFlowsQueryResult


```ts
type ProcessInstanceSequenceFlowsQueryResult = object;
```

Process instance sequence flows query response.

## Properties

### items

```ts
items: ProcessInstanceSequenceFlowResult[];
```

The sequence flows.

---

## Type Alias: ProcessInstanceStateEnum


```ts
type ProcessInstanceStateEnum =
  (typeof ProcessInstanceStateEnum)[keyof typeof ProcessInstanceStateEnum];
```

Process instance states

---

## Type Alias: ProcessInstanceStateExactMatch


```ts
type ProcessInstanceStateExactMatch = ProcessInstanceStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: ProcessInstanceStateFilterProperty


```ts
type ProcessInstanceStateFilterProperty =
  ProcessInstanceStateExactMatch | AdvancedProcessInstanceStateFilter;
```

ProcessInstanceStateEnum property with full advanced search capabilities.

---

## Type Alias: ProcessInstanceWaitStateStatisticsQueryResult


```ts
type ProcessInstanceWaitStateStatisticsQueryResult = object;
```

Process instance wait state statistics query response.

## Properties

### items

```ts
items: ProcessInstanceWaitStateStatisticsResult[];
```

The wait state statistics.

---

## Type Alias: ProcessInstanceWaitStateStatisticsResult


```ts
type ProcessInstanceWaitStateStatisticsResult = object;
```

Process instance wait state statistics response item.

## Properties

### elementId

```ts
elementId: ElementId;
```

The element id for which the wait states are aggregated.

---

### waitingCount

```ts
waitingCount: number;
```

The total number of waiting instances of the element.

---

## Type Alias: PublishMessageData


```ts
type PublishMessageData = object;
```

## Properties

### body

```ts
body: MessagePublicationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/messages/publication";
```

---

## Type Alias: PublishMessageError


```ts
type PublishMessageError = PublishMessageErrors[keyof PublishMessageErrors];
```

---

## Type Alias: PublishMessageErrors


```ts
type PublishMessageErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: PublishMessageResponse


```ts
type PublishMessageResponse =
  PublishMessageResponses[keyof PublishMessageResponses];
```

---

## Type Alias: PublishMessageResponses


```ts
type PublishMessageResponses = object;
```

## Properties

### 200

```ts
200: MessagePublicationResult;
```

The message was published.

---

## Type Alias: ResetClockData


```ts
type ResetClockData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/clock/reset";
```

---

## Type Alias: ResetClockError


```ts
type ResetClockError = ResetClockErrors[keyof ResetClockErrors];
```

---

## Type Alias: ResetClockErrors


```ts
type ResetClockErrors = object;
```

## Properties

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ResetClockResponse


```ts
type ResetClockResponse = ResetClockResponses[keyof ResetClockResponses];
```

---

## Type Alias: ResetClockResponses


```ts
type ResetClockResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The clock was successfully reset to the system time.

---

## Type Alias: ResolveIncidentData


```ts
type ResolveIncidentData = object;
```

## Properties

### body?

```ts
optional body?: IncidentResolutionRequest;
```

---

### path

```ts
path: object;
```

#### incidentKey

```ts
incidentKey: IncidentKey;
```

Key of the incident to resolve.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/incidents/{incidentKey}/resolution";
```

---

## Type Alias: ResolveIncidentError


```ts
type ResolveIncidentError = ResolveIncidentErrors[keyof ResolveIncidentErrors];
```

---

## Type Alias: ResolveIncidentErrors


```ts
type ResolveIncidentErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The incident with the incidentKey is not found.

---

### 409

```ts
409: ProblemDetail;
```

The incident cannot be resolved due to an invalid state.
For example, the associated job may have no retries left.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ResolveIncidentResponse


```ts
type ResolveIncidentResponse =
  ResolveIncidentResponses[keyof ResolveIncidentResponses];
```

---

## Type Alias: ResolveIncidentResponses


```ts
type ResolveIncidentResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The incident is marked as resolved.

---

## Type Alias: ResolveIncidentsBatchOperationData


```ts
type ResolveIncidentsBatchOperationData = object;
```

## Properties

### body?

```ts
optional body?: ProcessInstanceIncidentResolutionBatchOperationRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/incident-resolution";
```

---

## Type Alias: ResolveIncidentsBatchOperationError


```ts
type ResolveIncidentsBatchOperationError =
  ResolveIncidentsBatchOperationErrors[keyof ResolveIncidentsBatchOperationErrors];
```

---

## Type Alias: ResolveIncidentsBatchOperationErrors


```ts
type ResolveIncidentsBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The process instance batch operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: ResolveIncidentsBatchOperationResponse


```ts
type ResolveIncidentsBatchOperationResponse =
  ResolveIncidentsBatchOperationResponses[keyof ResolveIncidentsBatchOperationResponses];
```

---

## Type Alias: ResolveIncidentsBatchOperationResponses


```ts
type ResolveIncidentsBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request was created.

---

## Type Alias: ResolveProcessInstanceIncidentsData


```ts
type ResolveProcessInstanceIncidentsData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance to resolve incidents for.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/incident-resolution";
```

---

## Type Alias: ResolveProcessInstanceIncidentsError


```ts
type ResolveProcessInstanceIncidentsError =
  ResolveProcessInstanceIncidentsErrors[keyof ResolveProcessInstanceIncidentsErrors];
```

---

## Type Alias: ResolveProcessInstanceIncidentsErrors


```ts
type ResolveProcessInstanceIncidentsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The process instance is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ResolveProcessInstanceIncidentsResponse


```ts
type ResolveProcessInstanceIncidentsResponse =
  ResolveProcessInstanceIncidentsResponses[keyof ResolveProcessInstanceIncidentsResponses];
```

---

## Type Alias: ResolveProcessInstanceIncidentsResponses


```ts
type ResolveProcessInstanceIncidentsResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation request for incident resolution was created.

---

## Type Alias: ResourceFilter


```ts
type ResourceFilter = object;
```

Resource search filter.

## Properties

### deploymentKey?

```ts
optional deploymentKey?: DeploymentKeyFilterProperty;
```

Deployment key of this resource.

---

### resourceId?

```ts
optional resourceId?: StringFilterProperty;
```

Resource ID of this resource.

---

### resourceKey?

```ts
optional resourceKey?: ResourceKeyFilterProperty;
```

The key for this resource.

---

### resourceName?

```ts
optional resourceName?: StringFilterProperty;
```

Resource name of this resource.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

Tenant ID of this resource.

---

### version?

```ts
optional version?: IntegerFilterProperty;
```

Version of this resource.

---

### versionTag?

```ts
optional versionTag?: StringFilterProperty;
```

Version tag of this resource.

---

## Type Alias: ResourceKey


```ts
type ResourceKey =
  | ProcessDefinitionKey
  | DecisionRequirementsKey
  | FormKey
  | DecisionDefinitionKey;
```

The system-assigned key for this resource.

---

## Type Alias: ResourceKeyExactMatch


```ts
type ResourceKeyExactMatch = ResourceKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: ResourceKeyFilterProperty


```ts
type ResourceKeyFilterProperty =
  ResourceKeyExactMatch | AdvancedResourceKeyFilter;
```

ResourceKey property with full advanced search capabilities.

---

## Type Alias: ResourceResult


```ts
type ResourceResult = object;
```

## Properties

### resourceId

```ts
resourceId: string;
```

The resource ID of this resource.

---

### resourceKey

```ts
resourceKey: ResourceKey;
```

The unique key of this resource.

---

### resourceName

```ts
resourceName: string;
```

The resource name from which this resource was parsed.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of this resource.

---

### version

```ts
version: number;
```

The assigned resource version.

---

### versionTag

```ts
versionTag: string | null;
```

The version tag of this resource.

---

## Type Alias: ResourceSearchQuery


```ts
type ResourceSearchQuery = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: ResourceFilter;
```

The resource search filters.

### sort?

```ts
optional sort?: ResourceSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: ResourceSearchQueryResult


```ts
type ResourceSearchQueryResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: ResourceResult[];
```

The matching resources.

---

## Type Alias: ResourceSearchQuerySortRequest


```ts
type ResourceSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "resourceKey"
  | "resourceName"
  | "resourceId"
  | "version"
  | "versionTag"
  | "deploymentKey"
  | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: ResourceTypeEnum


```ts
type ResourceTypeEnum =
  (typeof ResourceTypeEnum)[keyof typeof ResourceTypeEnum];
```

The type of resource to add/remove permissions to/from.

---

## Type Alias: Result<T, E>

# Type Alias: Result\<T, E\>

```ts
type Result<T, E> =
  | {
      ok: true;
      value: T;
    }
  | {
      error: E;
      ok: false;
    };
```

## Type Parameters

### T

`T`

### E

`E` = `unknown`

---

## Type Alias: ResumeBatchOperationData


```ts
type ResumeBatchOperationData = object;
```

## Properties

### body?

```ts
optional body?: unknown;
```

---

### path

```ts
path: object;
```

#### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

The key (or operate legacy ID) of the batch operation.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/batch-operations/{batchOperationKey}/resumption";
```

---

## Type Alias: ResumeBatchOperationError


```ts
type ResumeBatchOperationError =
  ResumeBatchOperationErrors[keyof ResumeBatchOperationErrors];
```

---

## Type Alias: ResumeBatchOperationErrors


```ts
type ResumeBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The batch operation was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ResumeBatchOperationResponse


```ts
type ResumeBatchOperationResponse =
  ResumeBatchOperationResponses[keyof ResumeBatchOperationResponses];
```

---

## Type Alias: ResumeBatchOperationResponses


```ts
type ResumeBatchOperationResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The batch operation resume request was created.

---

## Type Alias: RoleClientResult


```ts
type RoleClientResult = object;
```

## Properties

### clientId

```ts
clientId: ClientId;
```

The ID of the client.

---

## Type Alias: RoleClientSearchQueryRequest


```ts
type RoleClientSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: RoleClientSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: RoleClientSearchQuerySortRequest


```ts
type RoleClientSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "clientId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: RoleClientSearchResult


```ts
type RoleClientSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: RoleClientResult[];
```

The matching clients.

---

## Type Alias: RoleCreateRequest


```ts
type RoleCreateRequest = object;
```

## Properties

### description?

```ts
optional description?: string;
```

The description of the new role.

---

### name

```ts
name: string;
```

The display name of the new role.

---

### roleId

```ts
roleId: RoleId;
```

The ID of the new role.

---

## Type Alias: RoleCreateResult


```ts
type RoleCreateResult = object;
```

## Properties

### description

```ts
description: string | null;
```

The description of the created role.

---

### name

```ts
name: string;
```

The display name of the created role.

---

### roleId

```ts
roleId: RoleId;
```

The ID of the created role.

---

## Type Alias: RoleFilter


```ts
type RoleFilter = object;
```

Role filter request

## Properties

### name?

```ts
optional name?: string;
```

The role name search filters.

---

### roleId?

```ts
optional roleId?: RoleId;
```

The role ID search filters.

---

## Type Alias: RoleGroupResult


```ts
type RoleGroupResult = object;
```

## Properties

### groupId

```ts
groupId: GroupId;
```

The id of the group.

---

## Type Alias: RoleGroupSearchQueryRequest


```ts
type RoleGroupSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: RoleGroupSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: RoleGroupSearchQuerySortRequest


```ts
type RoleGroupSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "groupId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: RoleGroupSearchResult


```ts
type RoleGroupSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: RoleGroupResult[];
```

The matching groups.

---

## Type Alias: RoleId


```ts
type RoleId = CamundaKey<"RoleId">;
```

The unique identifier of a role.

---

## Type Alias: RoleMappingRuleSearchResult


```ts
type RoleMappingRuleSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: MappingRuleResult[];
```

The matching mapping rules.

---

## Type Alias: RoleResult


```ts
type RoleResult = object;
```

Role search response item.

## Properties

### description

```ts
description: string | null;
```

The description of the role.

---

### name

```ts
name: string;
```

The role name.

---

### roleId

```ts
roleId: RoleId;
```

The role id.

---

## Type Alias: RoleSearchQueryRequest


```ts
type RoleSearchQueryRequest = SearchQueryRequest & object;
```

Role search request.

## Type Declaration

### filter?

```ts
optional filter?: RoleFilter;
```

The role search filters.

### sort?

```ts
optional sort?: RoleSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: RoleSearchQueryResult


```ts
type RoleSearchQueryResult = SearchQueryResponse & object;
```

Role search response.

## Type Declaration

### items

```ts
items: RoleResult[];
```

The matching roles.

---

## Type Alias: RoleSearchQuerySortRequest


```ts
type RoleSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "name" | "roleId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: RoleUpdateRequest


```ts
type RoleUpdateRequest = object;
```

## Properties

### description?

```ts
optional description?: string;
```

The description of the new role.

---

### name

```ts
name: string;
```

The display name of the new role.

---

## Type Alias: RoleUpdateResult


```ts
type RoleUpdateResult = object;
```

## Properties

### description

```ts
description: string | null;
```

The description of the updated role.

---

### name

```ts
name: string;
```

The display name of the updated role.

---

### roleId

```ts
roleId: RoleId;
```

The ID of the updated role.

---

## Type Alias: RoleUserResult


```ts
type RoleUserResult = object;
```

## Properties

### username

```ts
username: Username;
```

---

## Type Alias: RoleUserSearchQueryRequest


```ts
type RoleUserSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: RoleUserSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: RoleUserSearchQuerySortRequest


```ts
type RoleUserSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "username";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: RoleUserSearchResult


```ts
type RoleUserSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: RoleUserResult[];
```

The matching users.

---

## Type Alias: ScopeKey


```ts
type ScopeKey = ProcessInstanceKey | ElementInstanceKey;
```

System-generated key for a scope. A scope can hold variables and represents either an
element instance in a BPMN process or the process instance itself.

---

## Type Alias: ScopeKeyExactMatch


```ts
type ScopeKeyExactMatch = ScopeKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: ScopeKeyFilterProperty


```ts
type ScopeKeyFilterProperty = ScopeKeyExactMatch | AdvancedScopeKeyFilter;
```

ScopeKey property with full advanced search capabilities. Filter by the key of the
element instance or process instance that defines the scope of a variable.

---

## Type Alias: SdkError


```ts
type SdkError =
  | HttpSdkError
  | ValidationSdkError
  | AuthSdkError
  | NetworkSdkError
  | CancelSdkError;
```

---

## Type Alias: SearchAgentInstanceHistoryData


```ts
type SearchAgentInstanceHistoryData = object;
```

## Properties

### body?

```ts
optional body?: AgentInstanceHistorySearchQuery;
```

---

### path

```ts
path: object;
```

#### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The key of the agent instance whose history to search.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/agent-instances/{agentInstanceKey}/history/search";
```

---

## Type Alias: SearchAgentInstanceHistoryError


```ts
type SearchAgentInstanceHistoryError =
  SearchAgentInstanceHistoryErrors[keyof SearchAgentInstanceHistoryErrors];
```

---

## Type Alias: SearchAgentInstanceHistoryErrors


```ts
type SearchAgentInstanceHistoryErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The agent instance with the given key was not found.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchAgentInstanceHistoryResponse


```ts
type SearchAgentInstanceHistoryResponse =
  SearchAgentInstanceHistoryResponses[keyof SearchAgentInstanceHistoryResponses];
```

---

## Type Alias: SearchAgentInstanceHistoryResponses


```ts
type SearchAgentInstanceHistoryResponses = object;
```

## Properties

### 200

```ts
200: AgentInstanceHistorySearchQueryResult;
```

The agent instance history search result.

---

## Type Alias: SearchAgentInstancesData


```ts
type SearchAgentInstancesData = object;
```

## Properties

### body?

```ts
optional body?: AgentInstanceSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/agent-instances/search";
```

---

## Type Alias: SearchAgentInstancesError


```ts
type SearchAgentInstancesError =
  SearchAgentInstancesErrors[keyof SearchAgentInstancesErrors];
```

---

## Type Alias: SearchAgentInstancesErrors


```ts
type SearchAgentInstancesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchAgentInstancesResponse


```ts
type SearchAgentInstancesResponse =
  SearchAgentInstancesResponses[keyof SearchAgentInstancesResponses];
```

---

## Type Alias: SearchAgentInstancesResponses


```ts
type SearchAgentInstancesResponses = object;
```

## Properties

### 200

```ts
200: AgentInstanceSearchQueryResult;
```

The agent instance search result.

---

## Type Alias: SearchAuditLogsData


```ts
type SearchAuditLogsData = object;
```

## Properties

### body?

```ts
optional body?: AuditLogSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/audit-logs/search";
```

---

## Type Alias: SearchAuditLogsError


```ts
type SearchAuditLogsError = SearchAuditLogsErrors[keyof SearchAuditLogsErrors];
```

---

## Type Alias: SearchAuditLogsErrors


```ts
type SearchAuditLogsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: unknown;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchAuditLogsResponse


```ts
type SearchAuditLogsResponse =
  SearchAuditLogsResponses[keyof SearchAuditLogsResponses];
```

---

## Type Alias: SearchAuditLogsResponses


```ts
type SearchAuditLogsResponses = object;
```

## Properties

### 200

```ts
200: AuditLogSearchQueryResult;
```

The audit logs search result.

---

## Type Alias: SearchAuthorizationsData


```ts
type SearchAuthorizationsData = object;
```

## Properties

### body?

```ts
optional body?: AuthorizationSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/authorizations/search";
```

---

## Type Alias: SearchAuthorizationsError


```ts
type SearchAuthorizationsError =
  SearchAuthorizationsErrors[keyof SearchAuthorizationsErrors];
```

---

## Type Alias: SearchAuthorizationsErrors


```ts
type SearchAuthorizationsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchAuthorizationsResponse


```ts
type SearchAuthorizationsResponse =
  SearchAuthorizationsResponses[keyof SearchAuthorizationsResponses];
```

---

## Type Alias: SearchAuthorizationsResponses


```ts
type SearchAuthorizationsResponses = object;
```

## Properties

### 200

```ts
200: AuthorizationSearchResult;
```

The authorization search result.

---

## Type Alias: SearchBatchOperationItemsData


```ts
type SearchBatchOperationItemsData = object;
```

## Properties

### body?

```ts
optional body?: BatchOperationItemSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/batch-operation-items/search";
```

---

## Type Alias: SearchBatchOperationItemsError


```ts
type SearchBatchOperationItemsError =
  SearchBatchOperationItemsErrors[keyof SearchBatchOperationItemsErrors];
```

---

## Type Alias: SearchBatchOperationItemsErrors


```ts
type SearchBatchOperationItemsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchBatchOperationItemsResponse


```ts
type SearchBatchOperationItemsResponse =
  SearchBatchOperationItemsResponses[keyof SearchBatchOperationItemsResponses];
```

---

## Type Alias: SearchBatchOperationItemsResponses


```ts
type SearchBatchOperationItemsResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationItemSearchQueryResult;
```

The batch operation search result.

---

## Type Alias: SearchBatchOperationsData


```ts
type SearchBatchOperationsData = object;
```

## Properties

### body?

```ts
optional body?: BatchOperationSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/batch-operations/search";
```

---

## Type Alias: SearchBatchOperationsError


```ts
type SearchBatchOperationsError =
  SearchBatchOperationsErrors[keyof SearchBatchOperationsErrors];
```

---

## Type Alias: SearchBatchOperationsErrors


```ts
type SearchBatchOperationsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchBatchOperationsResponse


```ts
type SearchBatchOperationsResponse =
  SearchBatchOperationsResponses[keyof SearchBatchOperationsResponses];
```

---

## Type Alias: SearchBatchOperationsResponses


```ts
type SearchBatchOperationsResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationSearchQueryResult;
```

The batch operation search result.

---

## Type Alias: SearchClientsForGroupData


```ts
type SearchClientsForGroupData = object;
```

## Properties

### body?

```ts
optional body?: GroupClientSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/clients/search";
```

---

## Type Alias: SearchClientsForGroupError


```ts
type SearchClientsForGroupError =
  SearchClientsForGroupErrors[keyof SearchClientsForGroupErrors];
```

---

## Type Alias: SearchClientsForGroupErrors


```ts
type SearchClientsForGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchClientsForGroupResponse


```ts
type SearchClientsForGroupResponse =
  SearchClientsForGroupResponses[keyof SearchClientsForGroupResponses];
```

---

## Type Alias: SearchClientsForGroupResponses


```ts
type SearchClientsForGroupResponses = object;
```

## Properties

### 200

```ts
200: GroupClientSearchResult;
```

The clients assigned to the group.

---

## Type Alias: SearchClientsForRoleData


```ts
type SearchClientsForRoleData = object;
```

## Properties

### body?

```ts
optional body?: RoleClientSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/clients/search";
```

---

## Type Alias: SearchClientsForRoleError


```ts
type SearchClientsForRoleError =
  SearchClientsForRoleErrors[keyof SearchClientsForRoleErrors];
```

---

## Type Alias: SearchClientsForRoleErrors


```ts
type SearchClientsForRoleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchClientsForRoleResponse


```ts
type SearchClientsForRoleResponse =
  SearchClientsForRoleResponses[keyof SearchClientsForRoleResponses];
```

---

## Type Alias: SearchClientsForRoleResponses


```ts
type SearchClientsForRoleResponses = object;
```

## Properties

### 200

```ts
200: RoleClientSearchResult;
```

The clients with the assigned role.

---

## Type Alias: SearchClientsForTenantData


```ts
type SearchClientsForTenantData = object;
```

## Properties

### body?

```ts
optional body?: TenantClientSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/clients/search";
```

---

## Type Alias: SearchClientsForTenantResponse


```ts
type SearchClientsForTenantResponse =
  SearchClientsForTenantResponses[keyof SearchClientsForTenantResponses];
```

---

## Type Alias: SearchClientsForTenantResponses


```ts
type SearchClientsForTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantClientSearchResult;
```

The search result of users for the tenant.

---

## Type Alias: SearchClusterVariablesData


```ts
type SearchClusterVariablesData = object;
```

## Properties

### body?

```ts
optional body?: ClusterVariableSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: object;
```

#### truncateValues?

```ts
optional truncateValues?: boolean;
```

When true (default), long variable values in the response are truncated. When false, full variable values are returned.

---

### url

```ts
url: "/cluster-variables/search";
```

---

## Type Alias: SearchClusterVariablesError


```ts
type SearchClusterVariablesError =
  SearchClusterVariablesErrors[keyof SearchClusterVariablesErrors];
```

---

## Type Alias: SearchClusterVariablesErrors


```ts
type SearchClusterVariablesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchClusterVariablesResponse


```ts
type SearchClusterVariablesResponse =
  SearchClusterVariablesResponses[keyof SearchClusterVariablesResponses];
```

---

## Type Alias: SearchClusterVariablesResponses


```ts
type SearchClusterVariablesResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableSearchQueryResult;
```

The cluster variable search result.

---

## Type Alias: SearchCorrelatedMessageSubscriptionsData


```ts
type SearchCorrelatedMessageSubscriptionsData = object;
```

## Properties

### body?

```ts
optional body?: CorrelatedMessageSubscriptionSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/correlated-message-subscriptions/search";
```

---

## Type Alias: SearchCorrelatedMessageSubscriptionsError


```ts
type SearchCorrelatedMessageSubscriptionsError =
  SearchCorrelatedMessageSubscriptionsErrors[keyof SearchCorrelatedMessageSubscriptionsErrors];
```

---

## Type Alias: SearchCorrelatedMessageSubscriptionsErrors


```ts
type SearchCorrelatedMessageSubscriptionsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchCorrelatedMessageSubscriptionsResponse


```ts
type SearchCorrelatedMessageSubscriptionsResponse =
  SearchCorrelatedMessageSubscriptionsResponses[keyof SearchCorrelatedMessageSubscriptionsResponses];
```

---

## Type Alias: SearchCorrelatedMessageSubscriptionsResponses


```ts
type SearchCorrelatedMessageSubscriptionsResponses = object;
```

## Properties

### 200

```ts
200: CorrelatedMessageSubscriptionSearchQueryResult;
```

The correlated message subscriptions search result.

---

## Type Alias: SearchDecisionDefinitionsData


```ts
type SearchDecisionDefinitionsData = object;
```

## Properties

### body?

```ts
optional body?: DecisionDefinitionSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-definitions/search";
```

---

## Type Alias: SearchDecisionDefinitionsError


```ts
type SearchDecisionDefinitionsError =
  SearchDecisionDefinitionsErrors[keyof SearchDecisionDefinitionsErrors];
```

---

## Type Alias: SearchDecisionDefinitionsErrors


```ts
type SearchDecisionDefinitionsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchDecisionDefinitionsResponse


```ts
type SearchDecisionDefinitionsResponse =
  SearchDecisionDefinitionsResponses[keyof SearchDecisionDefinitionsResponses];
```

---

## Type Alias: SearchDecisionDefinitionsResponses


```ts
type SearchDecisionDefinitionsResponses = object;
```

## Properties

### 200

```ts
200: DecisionDefinitionSearchQueryResult;
```

The decision definition search result.

---

## Type Alias: SearchDecisionInstancesData


```ts
type SearchDecisionInstancesData = object;
```

## Properties

### body?

```ts
optional body?: DecisionInstanceSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-instances/search";
```

---

## Type Alias: SearchDecisionInstancesError


```ts
type SearchDecisionInstancesError =
  SearchDecisionInstancesErrors[keyof SearchDecisionInstancesErrors];
```

---

## Type Alias: SearchDecisionInstancesErrors


```ts
type SearchDecisionInstancesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchDecisionInstancesResponse


```ts
type SearchDecisionInstancesResponse =
  SearchDecisionInstancesResponses[keyof SearchDecisionInstancesResponses];
```

---

## Type Alias: SearchDecisionInstancesResponses


```ts
type SearchDecisionInstancesResponses = object;
```

## Properties

### 200

```ts
200: DecisionInstanceSearchQueryResult;
```

The decision instance search result.

---

## Type Alias: SearchDecisionRequirementsData


```ts
type SearchDecisionRequirementsData = object;
```

## Properties

### body?

```ts
optional body?: DecisionRequirementsSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/decision-requirements/search";
```

---

## Type Alias: SearchDecisionRequirementsError


```ts
type SearchDecisionRequirementsError =
  SearchDecisionRequirementsErrors[keyof SearchDecisionRequirementsErrors];
```

---

## Type Alias: SearchDecisionRequirementsErrors


```ts
type SearchDecisionRequirementsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchDecisionRequirementsResponse


```ts
type SearchDecisionRequirementsResponse =
  SearchDecisionRequirementsResponses[keyof SearchDecisionRequirementsResponses];
```

---

## Type Alias: SearchDecisionRequirementsResponses


```ts
type SearchDecisionRequirementsResponses = object;
```

## Properties

### 200

```ts
200: DecisionRequirementsSearchQueryResult;
```

The decision requirements search result.

---

## Type Alias: SearchElementInstanceIncidentsData


```ts
type SearchElementInstanceIncidentsData = object;
```

## Properties

### body

```ts
body: IncidentSearchQuery;
```

---

### path

```ts
path: object;
```

#### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The unique key of the element instance to search incidents for.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/element-instances/{elementInstanceKey}/incidents/search";
```

---

## Type Alias: SearchElementInstanceIncidentsError


```ts
type SearchElementInstanceIncidentsError =
  SearchElementInstanceIncidentsErrors[keyof SearchElementInstanceIncidentsErrors];
```

---

## Type Alias: SearchElementInstanceIncidentsErrors


```ts
type SearchElementInstanceIncidentsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The element instance with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchElementInstanceIncidentsResponse


```ts
type SearchElementInstanceIncidentsResponse =
  SearchElementInstanceIncidentsResponses[keyof SearchElementInstanceIncidentsResponses];
```

---

## Type Alias: SearchElementInstanceIncidentsResponses


```ts
type SearchElementInstanceIncidentsResponses = object;
```

## Properties

### 200

```ts
200: IncidentSearchQueryResult;
```

The element instance incident search result.

---

## Type Alias: SearchElementInstanceWaitStatesData


```ts
type SearchElementInstanceWaitStatesData = object;
```

## Properties

### body?

```ts
optional body?: ElementInstanceWaitStateQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/element-instances/wait-states/search";
```

---

## Type Alias: SearchElementInstanceWaitStatesError


```ts
type SearchElementInstanceWaitStatesError =
  SearchElementInstanceWaitStatesErrors[keyof SearchElementInstanceWaitStatesErrors];
```

---

## Type Alias: SearchElementInstanceWaitStatesErrors


```ts
type SearchElementInstanceWaitStatesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchElementInstanceWaitStatesResponse


```ts
type SearchElementInstanceWaitStatesResponse =
  SearchElementInstanceWaitStatesResponses[keyof SearchElementInstanceWaitStatesResponses];
```

---

## Type Alias: SearchElementInstanceWaitStatesResponses


```ts
type SearchElementInstanceWaitStatesResponses = object;
```

## Properties

### 200

```ts
200: ElementInstanceWaitStateQueryResult;
```

The element instance wait state search result.

---

## Type Alias: SearchElementInstancesData


```ts
type SearchElementInstancesData = object;
```

## Properties

### body?

```ts
optional body?: ElementInstanceSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/element-instances/search";
```

---

## Type Alias: SearchElementInstancesError


```ts
type SearchElementInstancesError =
  SearchElementInstancesErrors[keyof SearchElementInstancesErrors];
```

---

## Type Alias: SearchElementInstancesErrors


```ts
type SearchElementInstancesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchElementInstancesResponse


```ts
type SearchElementInstancesResponse =
  SearchElementInstancesResponses[keyof SearchElementInstancesResponses];
```

---

## Type Alias: SearchElementInstancesResponses


```ts
type SearchElementInstancesResponses = object;
```

## Properties

### 200

```ts
200: ElementInstanceSearchQueryResult;
```

The element instance search result.

---

## Type Alias: SearchGlobalTaskListenersData


```ts
type SearchGlobalTaskListenersData = object;
```

## Properties

### body?

```ts
optional body?: GlobalTaskListenerSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/global-task-listeners/search";
```

---

## Type Alias: SearchGlobalTaskListenersError


```ts
type SearchGlobalTaskListenersError =
  SearchGlobalTaskListenersErrors[keyof SearchGlobalTaskListenersErrors];
```

---

## Type Alias: SearchGlobalTaskListenersErrors


```ts
type SearchGlobalTaskListenersErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchGlobalTaskListenersResponse


```ts
type SearchGlobalTaskListenersResponse =
  SearchGlobalTaskListenersResponses[keyof SearchGlobalTaskListenersResponses];
```

---

## Type Alias: SearchGlobalTaskListenersResponses


```ts
type SearchGlobalTaskListenersResponses = object;
```

## Properties

### 200

```ts
200: GlobalTaskListenerSearchQueryResult;
```

The global user task listener search result.

---

## Type Alias: SearchGroupIdsForTenantData


```ts
type SearchGroupIdsForTenantData = object;
```

## Properties

### body?

```ts
optional body?: TenantGroupSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/groups/search";
```

---

## Type Alias: SearchGroupIdsForTenantResponse


```ts
type SearchGroupIdsForTenantResponse =
  SearchGroupIdsForTenantResponses[keyof SearchGroupIdsForTenantResponses];
```

---

## Type Alias: SearchGroupIdsForTenantResponses


```ts
type SearchGroupIdsForTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantGroupSearchResult;
```

The search result of groups for the tenant.

---

## Type Alias: SearchGroupsData


```ts
type SearchGroupsData = object;
```

## Properties

### body?

```ts
optional body?: GroupSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/search";
```

---

## Type Alias: SearchGroupsError


```ts
type SearchGroupsError = SearchGroupsErrors[keyof SearchGroupsErrors];
```

---

## Type Alias: SearchGroupsErrors


```ts
type SearchGroupsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchGroupsForRoleData


```ts
type SearchGroupsForRoleData = object;
```

## Properties

### body?

```ts
optional body?: RoleGroupSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/groups/search";
```

---

## Type Alias: SearchGroupsForRoleError


```ts
type SearchGroupsForRoleError =
  SearchGroupsForRoleErrors[keyof SearchGroupsForRoleErrors];
```

---

## Type Alias: SearchGroupsForRoleErrors


```ts
type SearchGroupsForRoleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchGroupsForRoleResponse


```ts
type SearchGroupsForRoleResponse =
  SearchGroupsForRoleResponses[keyof SearchGroupsForRoleResponses];
```

---

## Type Alias: SearchGroupsForRoleResponses


```ts
type SearchGroupsForRoleResponses = object;
```

## Properties

### 200

```ts
200: RoleGroupSearchResult;
```

The groups with assigned role.

---

## Type Alias: SearchGroupsResponse


```ts
type SearchGroupsResponse = SearchGroupsResponses[keyof SearchGroupsResponses];
```

---

## Type Alias: SearchGroupsResponses


```ts
type SearchGroupsResponses = object;
```

## Properties

### 200

```ts
200: GroupSearchQueryResult;
```

The groups search result.

---

## Type Alias: SearchIncidentsData


```ts
type SearchIncidentsData = object;
```

## Properties

### body?

```ts
optional body?: IncidentSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/incidents/search";
```

---

## Type Alias: SearchIncidentsError


```ts
type SearchIncidentsError = SearchIncidentsErrors[keyof SearchIncidentsErrors];
```

---

## Type Alias: SearchIncidentsErrors


```ts
type SearchIncidentsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchIncidentsResponse


```ts
type SearchIncidentsResponse =
  SearchIncidentsResponses[keyof SearchIncidentsResponses];
```

---

## Type Alias: SearchIncidentsResponses


```ts
type SearchIncidentsResponses = object;
```

## Properties

### 200

```ts
200: IncidentSearchQueryResult;
```

The incident search result.

---

## Type Alias: SearchJobsData


```ts
type SearchJobsData = object;
```

## Properties

### body?

```ts
optional body?: JobSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/search";
```

---

## Type Alias: SearchJobsError


```ts
type SearchJobsError = SearchJobsErrors[keyof SearchJobsErrors];
```

---

## Type Alias: SearchJobsErrors


```ts
type SearchJobsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchJobsResponse


```ts
type SearchJobsResponse = SearchJobsResponses[keyof SearchJobsResponses];
```

---

## Type Alias: SearchJobsResponses


```ts
type SearchJobsResponses = object;
```

## Properties

### 200

```ts
200: JobSearchQueryResult;
```

The job search result.

---

## Type Alias: SearchMappingRuleData


```ts
type SearchMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: MappingRuleSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/mapping-rules/search";
```

---

## Type Alias: SearchMappingRuleError


```ts
type SearchMappingRuleError =
  SearchMappingRuleErrors[keyof SearchMappingRuleErrors];
```

---

## Type Alias: SearchMappingRuleErrors


```ts
type SearchMappingRuleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchMappingRuleResponse


```ts
type SearchMappingRuleResponse =
  SearchMappingRuleResponses[keyof SearchMappingRuleResponses];
```

---

## Type Alias: SearchMappingRuleResponses


```ts
type SearchMappingRuleResponses = object;
```

## Properties

### 200

```ts
200: MappingRuleSearchQueryResult;
```

The mapping rule search result.

---

## Type Alias: SearchMappingRulesForGroupData


```ts
type SearchMappingRulesForGroupData = object;
```

## Properties

### body?

```ts
optional body?: MappingRuleSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/mapping-rules/search";
```

---

## Type Alias: SearchMappingRulesForGroupError


```ts
type SearchMappingRulesForGroupError =
  SearchMappingRulesForGroupErrors[keyof SearchMappingRulesForGroupErrors];
```

---

## Type Alias: SearchMappingRulesForGroupErrors


```ts
type SearchMappingRulesForGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchMappingRulesForGroupResponse


```ts
type SearchMappingRulesForGroupResponse =
  SearchMappingRulesForGroupResponses[keyof SearchMappingRulesForGroupResponses];
```

---

## Type Alias: SearchMappingRulesForGroupResponses


```ts
type SearchMappingRulesForGroupResponses = object;
```

## Properties

### 200

```ts
200: GroupMappingRuleSearchResult;
```

The mapping rules assigned to the group.

---

## Type Alias: SearchMappingRulesForRoleData


```ts
type SearchMappingRulesForRoleData = object;
```

## Properties

### body?

```ts
optional body?: MappingRuleSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/mapping-rules/search";
```

---

## Type Alias: SearchMappingRulesForRoleError


```ts
type SearchMappingRulesForRoleError =
  SearchMappingRulesForRoleErrors[keyof SearchMappingRulesForRoleErrors];
```

---

## Type Alias: SearchMappingRulesForRoleErrors


```ts
type SearchMappingRulesForRoleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchMappingRulesForRoleResponse


```ts
type SearchMappingRulesForRoleResponse =
  SearchMappingRulesForRoleResponses[keyof SearchMappingRulesForRoleResponses];
```

---

## Type Alias: SearchMappingRulesForRoleResponses


```ts
type SearchMappingRulesForRoleResponses = object;
```

## Properties

### 200

```ts
200: RoleMappingRuleSearchResult;
```

The mapping rules with assigned role.

---

## Type Alias: SearchMappingRulesForTenantData


```ts
type SearchMappingRulesForTenantData = object;
```

## Properties

### body?

```ts
optional body?: MappingRuleSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/mapping-rules/search";
```

---

## Type Alias: SearchMappingRulesForTenantResponse


```ts
type SearchMappingRulesForTenantResponse =
  SearchMappingRulesForTenantResponses[keyof SearchMappingRulesForTenantResponses];
```

---

## Type Alias: SearchMappingRulesForTenantResponses


```ts
type SearchMappingRulesForTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantMappingRuleSearchResult;
```

The search result of MappingRules for the tenant.

---

## Type Alias: SearchMessageSubscriptionsData


```ts
type SearchMessageSubscriptionsData = object;
```

## Properties

### body?

```ts
optional body?: MessageSubscriptionSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/message-subscriptions/search";
```

---

## Type Alias: SearchMessageSubscriptionsError


```ts
type SearchMessageSubscriptionsError =
  SearchMessageSubscriptionsErrors[keyof SearchMessageSubscriptionsErrors];
```

---

## Type Alias: SearchMessageSubscriptionsErrors


```ts
type SearchMessageSubscriptionsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchMessageSubscriptionsResponse


```ts
type SearchMessageSubscriptionsResponse =
  SearchMessageSubscriptionsResponses[keyof SearchMessageSubscriptionsResponses];
```

---

## Type Alias: SearchMessageSubscriptionsResponses


```ts
type SearchMessageSubscriptionsResponses = object;
```

## Properties

### 200

```ts
200: MessageSubscriptionSearchQueryResult;
```

The message subscription search result.

---

## Type Alias: SearchProcessDefinitionsData


```ts
type SearchProcessDefinitionsData = object;
```

## Properties

### body?

```ts
optional body?: ProcessDefinitionSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-definitions/search";
```

---

## Type Alias: SearchProcessDefinitionsError


```ts
type SearchProcessDefinitionsError =
  SearchProcessDefinitionsErrors[keyof SearchProcessDefinitionsErrors];
```

---

## Type Alias: SearchProcessDefinitionsErrors


```ts
type SearchProcessDefinitionsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchProcessDefinitionsResponse


```ts
type SearchProcessDefinitionsResponse =
  SearchProcessDefinitionsResponses[keyof SearchProcessDefinitionsResponses];
```

---

## Type Alias: SearchProcessDefinitionsResponses


```ts
type SearchProcessDefinitionsResponses = object;
```

## Properties

### 200

```ts
200: ProcessDefinitionSearchQueryResult;
```

The process definition search result.

---

## Type Alias: SearchProcessInstanceIncidentsData


```ts
type SearchProcessInstanceIncidentsData = object;
```

## Properties

### body?

```ts
optional body?: IncidentSearchQuery;
```

---

### path

```ts
path: object;
```

#### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The assigned key of the process instance, which acts as a unique identifier for this process instance.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/{processInstanceKey}/incidents/search";
```

---

## Type Alias: SearchProcessInstanceIncidentsError


```ts
type SearchProcessInstanceIncidentsError =
  SearchProcessInstanceIncidentsErrors[keyof SearchProcessInstanceIncidentsErrors];
```

---

## Type Alias: SearchProcessInstanceIncidentsErrors


```ts
type SearchProcessInstanceIncidentsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The process instance with the given key was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchProcessInstanceIncidentsResponse


```ts
type SearchProcessInstanceIncidentsResponse =
  SearchProcessInstanceIncidentsResponses[keyof SearchProcessInstanceIncidentsResponses];
```

---

## Type Alias: SearchProcessInstanceIncidentsResponses


```ts
type SearchProcessInstanceIncidentsResponses = object;
```

## Properties

### 200

```ts
200: IncidentSearchQueryResult;
```

The process instance search result.

---

## Type Alias: SearchProcessInstancesData


```ts
type SearchProcessInstancesData = object;
```

## Properties

### body?

```ts
optional body?: ProcessInstanceSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/process-instances/search";
```

---

## Type Alias: SearchProcessInstancesError


```ts
type SearchProcessInstancesError =
  SearchProcessInstancesErrors[keyof SearchProcessInstancesErrors];
```

---

## Type Alias: SearchProcessInstancesErrors


```ts
type SearchProcessInstancesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchProcessInstancesResponse


```ts
type SearchProcessInstancesResponse =
  SearchProcessInstancesResponses[keyof SearchProcessInstancesResponses];
```

---

## Type Alias: SearchProcessInstancesResponses


```ts
type SearchProcessInstancesResponses = object;
```

## Properties

### 200

```ts
200: ProcessInstanceSearchQueryResult;
```

The process instance search result.

---

## Type Alias: SearchQueryPageRequest


```ts
type SearchQueryPageRequest =
  | LimitPagination
  | OffsetPagination
  | CursorForwardPagination
  | CursorBackwardPagination;
```

Pagination criteria. Can use offset-based pagination (from/limit) OR cursor-based pagination (after/before + limit), but not both.

---

## Type Alias: SearchQueryPageResponse


```ts
type SearchQueryPageResponse = object;
```

Pagination information about the search results.

## Properties

### endCursor

```ts
endCursor: EndCursor | null;
```

The cursor value for getting the next page of results. Use this in the `after` field of an ensuing request.

---

### hasMoreTotalItems

```ts
hasMoreTotalItems: boolean;
```

Indicates whether the `totalItems` value has been capped due to system limits. When true, `totalItems` is a lower bound and the actual number of matching items is greater than the reported value.

---

### startCursor

```ts
startCursor: StartCursor | null;
```

The cursor value for getting the previous page of results. Use this in the `before` field of an ensuing request.

---

### totalItems

```ts
totalItems: number;
```

Total items matching the criteria.

---

## Type Alias: SearchQueryRequest


```ts
type SearchQueryRequest = object;
```

## Properties

### page?

```ts
optional page?: SearchQueryPageRequest;
```

Pagination criteria.

---

## Type Alias: SearchQueryResponse


```ts
type SearchQueryResponse = object;
```

## Properties

### page

```ts
page: SearchQueryPageResponse;
```

---

## Type Alias: SearchResourcesData


```ts
type SearchResourcesData = object;
```

## Properties

### body?

```ts
optional body?: ResourceSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/resources/search";
```

---

## Type Alias: SearchResourcesError


```ts
type SearchResourcesError = SearchResourcesErrors[keyof SearchResourcesErrors];
```

---

## Type Alias: SearchResourcesErrors


```ts
type SearchResourcesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchResourcesResponse


```ts
type SearchResourcesResponse =
  SearchResourcesResponses[keyof SearchResourcesResponses];
```

---

## Type Alias: SearchResourcesResponses


```ts
type SearchResourcesResponses = object;
```

## Properties

### 200

```ts
200: ResourceSearchQueryResult;
```

The resource search result.

---

## Type Alias: SearchRolesData


```ts
type SearchRolesData = object;
```

## Properties

### body?

```ts
optional body?: RoleSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/search";
```

---

## Type Alias: SearchRolesError


```ts
type SearchRolesError = SearchRolesErrors[keyof SearchRolesErrors];
```

---

## Type Alias: SearchRolesErrors


```ts
type SearchRolesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchRolesForGroupData


```ts
type SearchRolesForGroupData = object;
```

## Properties

### body?

```ts
optional body?: RoleSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/roles/search";
```

---

## Type Alias: SearchRolesForGroupError


```ts
type SearchRolesForGroupError =
  SearchRolesForGroupErrors[keyof SearchRolesForGroupErrors];
```

---

## Type Alias: SearchRolesForGroupErrors


```ts
type SearchRolesForGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchRolesForGroupResponse


```ts
type SearchRolesForGroupResponse =
  SearchRolesForGroupResponses[keyof SearchRolesForGroupResponses];
```

---

## Type Alias: SearchRolesForGroupResponses


```ts
type SearchRolesForGroupResponses = object;
```

## Properties

### 200

```ts
200: GroupRoleSearchResult;
```

The roles assigned to the group.

---

## Type Alias: SearchRolesForTenantData


```ts
type SearchRolesForTenantData = object;
```

## Properties

### body?

```ts
optional body?: RoleSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/roles/search";
```

---

## Type Alias: SearchRolesForTenantResponse


```ts
type SearchRolesForTenantResponse =
  SearchRolesForTenantResponses[keyof SearchRolesForTenantResponses];
```

---

## Type Alias: SearchRolesForTenantResponses


```ts
type SearchRolesForTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantRoleSearchResult;
```

The search result of roles for the tenant.

---

## Type Alias: SearchRolesResponse


```ts
type SearchRolesResponse = SearchRolesResponses[keyof SearchRolesResponses];
```

---

## Type Alias: SearchRolesResponses


```ts
type SearchRolesResponses = object;
```

## Properties

### 200

```ts
200: RoleSearchQueryResult;
```

The roles search result.

---

## Type Alias: SearchTenantsData


```ts
type SearchTenantsData = object;
```

## Properties

### body?

```ts
optional body?: TenantSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/search";
```

---

## Type Alias: SearchTenantsError


```ts
type SearchTenantsError = SearchTenantsErrors[keyof SearchTenantsErrors];
```

---

## Type Alias: SearchTenantsErrors


```ts
type SearchTenantsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchTenantsResponse


```ts
type SearchTenantsResponse =
  SearchTenantsResponses[keyof SearchTenantsResponses];
```

---

## Type Alias: SearchTenantsResponses


```ts
type SearchTenantsResponses = object;
```

## Properties

### 200

```ts
200: TenantSearchQueryResult;
```

The tenants search result

---

## Type Alias: SearchUserTaskAuditLogsData


```ts
type SearchUserTaskAuditLogsData = object;
```

## Properties

### body?

```ts
optional body?: UserTaskAuditLogSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}/audit-logs/search";
```

---

## Type Alias: SearchUserTaskAuditLogsError


```ts
type SearchUserTaskAuditLogsError =
  SearchUserTaskAuditLogsErrors[keyof SearchUserTaskAuditLogsErrors];
```

---

## Type Alias: SearchUserTaskAuditLogsErrors


```ts
type SearchUserTaskAuditLogsErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUserTaskAuditLogsResponse


```ts
type SearchUserTaskAuditLogsResponse =
  SearchUserTaskAuditLogsResponses[keyof SearchUserTaskAuditLogsResponses];
```

---

## Type Alias: SearchUserTaskAuditLogsResponses


```ts
type SearchUserTaskAuditLogsResponses = object;
```

## Properties

### 200

```ts
200: AuditLogSearchQueryResult;
```

The user task audit log search result.

---

## Type Alias: SearchUserTaskEffectiveVariablesData


```ts
type SearchUserTaskEffectiveVariablesData = object;
```

## Properties

### body?

```ts
optional body?: UserTaskEffectiveVariableSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task.

---

### query?

```ts
optional query?: object;
```

#### truncateValues?

```ts
optional truncateValues?: boolean;
```

When true (default), long variable values in the response are truncated. When false, full variable values are returned.

---

### url

```ts
url: "/user-tasks/{userTaskKey}/effective-variables/search";
```

---

## Type Alias: SearchUserTaskEffectiveVariablesError


```ts
type SearchUserTaskEffectiveVariablesError =
  SearchUserTaskEffectiveVariablesErrors[keyof SearchUserTaskEffectiveVariablesErrors];
```

---

## Type Alias: SearchUserTaskEffectiveVariablesErrors


```ts
type SearchUserTaskEffectiveVariablesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUserTaskEffectiveVariablesResponse


```ts
type SearchUserTaskEffectiveVariablesResponse =
  SearchUserTaskEffectiveVariablesResponses[keyof SearchUserTaskEffectiveVariablesResponses];
```

---

## Type Alias: SearchUserTaskEffectiveVariablesResponses


```ts
type SearchUserTaskEffectiveVariablesResponses = object;
```

## Properties

### 200

```ts
200: VariableSearchQueryResult;
```

The user task effective variable search result.

---

## Type Alias: SearchUserTaskVariablesData


```ts
type SearchUserTaskVariablesData = object;
```

## Properties

### body?

```ts
optional body?: UserTaskVariableSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task.

---

### query?

```ts
optional query?: object;
```

#### truncateValues?

```ts
optional truncateValues?: boolean;
```

When true (default), long variable values in the response are truncated. When false, full variable values are returned.

---

### url

```ts
url: "/user-tasks/{userTaskKey}/variables/search";
```

---

## Type Alias: SearchUserTaskVariablesError


```ts
type SearchUserTaskVariablesError =
  SearchUserTaskVariablesErrors[keyof SearchUserTaskVariablesErrors];
```

---

## Type Alias: SearchUserTaskVariablesErrors


```ts
type SearchUserTaskVariablesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUserTaskVariablesResponse


```ts
type SearchUserTaskVariablesResponse =
  SearchUserTaskVariablesResponses[keyof SearchUserTaskVariablesResponses];
```

---

## Type Alias: SearchUserTaskVariablesResponses


```ts
type SearchUserTaskVariablesResponses = object;
```

## Properties

### 200

```ts
200: VariableSearchQueryResult;
```

The user task variable search result.

---

## Type Alias: SearchUserTasksData


```ts
type SearchUserTasksData = object;
```

## Properties

### body?

```ts
optional body?: UserTaskSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/search";
```

---

## Type Alias: SearchUserTasksError


```ts
type SearchUserTasksError = SearchUserTasksErrors[keyof SearchUserTasksErrors];
```

---

## Type Alias: SearchUserTasksErrors


```ts
type SearchUserTasksErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUserTasksResponse


```ts
type SearchUserTasksResponse =
  SearchUserTasksResponses[keyof SearchUserTasksResponses];
```

---

## Type Alias: SearchUserTasksResponses


```ts
type SearchUserTasksResponses = object;
```

## Properties

### 200

```ts
200: UserTaskSearchQueryResult;
```

The user task search result.

---

## Type Alias: SearchUsersData


```ts
type SearchUsersData = object;
```

## Properties

### body?

```ts
optional body?: UserSearchQueryRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/users/search";
```

---

## Type Alias: SearchUsersError


```ts
type SearchUsersError = SearchUsersErrors[keyof SearchUsersErrors];
```

---

## Type Alias: SearchUsersErrors


```ts
type SearchUsersErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUsersForGroupData


```ts
type SearchUsersForGroupData = object;
```

## Properties

### body?

```ts
optional body?: GroupUserSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/users/search";
```

---

## Type Alias: SearchUsersForGroupError


```ts
type SearchUsersForGroupError =
  SearchUsersForGroupErrors[keyof SearchUsersForGroupErrors];
```

---

## Type Alias: SearchUsersForGroupErrors


```ts
type SearchUsersForGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUsersForGroupResponse


```ts
type SearchUsersForGroupResponse =
  SearchUsersForGroupResponses[keyof SearchUsersForGroupResponses];
```

---

## Type Alias: SearchUsersForGroupResponses


```ts
type SearchUsersForGroupResponses = object;
```

## Properties

### 200

```ts
200: GroupUserSearchResult;
```

The users assigned to the group.

---

## Type Alias: SearchUsersForRoleData


```ts
type SearchUsersForRoleData = object;
```

## Properties

### body?

```ts
optional body?: RoleUserSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/users/search";
```

---

## Type Alias: SearchUsersForRoleError


```ts
type SearchUsersForRoleError =
  SearchUsersForRoleErrors[keyof SearchUsersForRoleErrors];
```

---

## Type Alias: SearchUsersForRoleErrors


```ts
type SearchUsersForRoleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchUsersForRoleResponse


```ts
type SearchUsersForRoleResponse =
  SearchUsersForRoleResponses[keyof SearchUsersForRoleResponses];
```

---

## Type Alias: SearchUsersForRoleResponses


```ts
type SearchUsersForRoleResponses = object;
```

## Properties

### 200

```ts
200: RoleUserSearchResult;
```

The users with the assigned role.

---

## Type Alias: SearchUsersForTenantData


```ts
type SearchUsersForTenantData = object;
```

## Properties

### body?

```ts
optional body?: TenantUserSearchQueryRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/users/search";
```

---

## Type Alias: SearchUsersForTenantResponse


```ts
type SearchUsersForTenantResponse =
  SearchUsersForTenantResponses[keyof SearchUsersForTenantResponses];
```

---

## Type Alias: SearchUsersForTenantResponses


```ts
type SearchUsersForTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantUserSearchResult;
```

The search result of users for the tenant.

---

## Type Alias: SearchUsersResponse


```ts
type SearchUsersResponse = SearchUsersResponses[keyof SearchUsersResponses];
```

---

## Type Alias: SearchUsersResponses


```ts
type SearchUsersResponses = object;
```

## Properties

### 200

```ts
200: UserSearchResult;
```

The user search result.

---

## Type Alias: SearchVariablesData


```ts
type SearchVariablesData = object;
```

## Properties

### body?

```ts
optional body?: VariableSearchQuery;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: object;
```

#### truncateValues?

```ts
optional truncateValues?: boolean;
```

When true (default), long variable values in the response are truncated. When false, full variable values are returned.

---

### url

```ts
url: "/variables/search";
```

---

## Type Alias: SearchVariablesError


```ts
type SearchVariablesError = SearchVariablesErrors[keyof SearchVariablesErrors];
```

---

## Type Alias: SearchVariablesErrors


```ts
type SearchVariablesErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: SearchVariablesResponse


```ts
type SearchVariablesResponse =
  SearchVariablesResponses[keyof SearchVariablesResponses];
```

---

## Type Alias: SearchVariablesResponses


```ts
type SearchVariablesResponses = object;
```

## Properties

### 200

```ts
200: VariableSearchQueryResult;
```

The variable search result.

---

## Type Alias: SetVariableRequest


```ts
type SetVariableRequest = object;
```

## Properties

### local?

```ts
optional local?: boolean;
```

If set to `true`, the variables are merged strictly into the local scope (as specified
by the `elementInstanceKey`). Otherwise, the variables are propagated to upper scopes
and set at the outermost one.

Let's consider the following example:
There are two scopes '1' and '2'. Scope '1' is the parent scope of '2'. The effective
variables of the scopes are:
1 => { "foo" : 2 }
2 => { "bar" : 1 }

An update request with elementInstanceKey as '2', variables { "foo": 5 }, and local set
to `true` leaves scope '1' unchanged and adjusts scope '2' to { "bar": 1, "foo": 5 }. By
default, with local set to `false`, scope '1' will be { "foo": 5 } and scope '2' will be
{ "bar": 1 }.

---

### operationReference?

```ts
optional operationReference?: OperationReference;
```

---

### variables

```ts
variables: object;
```

JSON object representing the variables to set in the element’s scope.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: SignalBroadcastRequest


```ts
type SignalBroadcastRequest = object;
```

## Properties

### signalName

```ts
signalName: string;
```

The name of the signal to broadcast.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The ID of the tenant that owns the signal.

---

### variables?

```ts
optional variables?: object;
```

The signal variables as a JSON object.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: SignalBroadcastResult


```ts
type SignalBroadcastResult = object;
```

## Properties

### signalKey

```ts
signalKey: SignalKey;
```

The key of the broadcasted signal.

---

### tenantId

```ts
tenantId: TenantId;
```

The tenant ID of the signal that was broadcast.

---

## Type Alias: SignalKey


```ts
type SignalKey = CamundaKey<"SignalKey">;
```

System-generated key for an signal.

---

## Type Alias: SignalWaitStateDetails


```ts
type SignalWaitStateDetails = BaseWaitStateDetails & object;
```

## Type Declaration

### signalName

```ts
signalName: string;
```

The name of the signal being awaited.

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: SortOrderEnum


```ts
type SortOrderEnum = (typeof SortOrderEnum)[keyof typeof SortOrderEnum];
```

The order in which to sort the related field.

---

## Type Alias: SourceElementIdInstruction


```ts
type SourceElementIdInstruction = object;
```

Defines an instruction with a sourceElementId. The move instruction with this sourceType will terminate all active element
instances with the sourceElementId and activate a new element instance for each terminated
one at targetElementId.

## Properties

### sourceElementId

```ts
sourceElementId: ElementId;
```

The id of the source element for the move instruction.

---

### sourceType

```ts
sourceType: string;
```

The type of source element instruction.

---

## Type Alias: SourceElementInstanceKeyInstruction


```ts
type SourceElementInstanceKeyInstruction = object;
```

Defines an instruction with a sourceElementInstanceKey. The move instruction with this sourceType will terminate one active element
instance with the sourceElementInstanceKey and activate a new element instance at targetElementId.

## Properties

### sourceElementInstanceKey

```ts
sourceElementInstanceKey: ElementInstanceKey;
```

The source element instance key for the move instruction.

---

### sourceType

```ts
sourceType: string;
```

The type of source element instruction.

---

## Type Alias: SourceElementInstruction


```ts
type SourceElementInstruction =
  | (object & SourceElementIdInstruction)
  | (object & SourceElementInstanceKeyInstruction);
```

Defines the source element identifier for the move instruction. It can either be a sourceElementId, or sourceElementInstanceKey.

---

## Type Alias: StartCursor


```ts
type StartCursor = CamundaKey<"StartCursor">;
```

The start cursor in a search query result set.

---

## Type Alias: StatusMetric


```ts
type StatusMetric = object;
```

Metric for a single job status.

## Properties

### count

```ts
count: number;
```

Number of jobs in this status.

---

### lastUpdatedAt

```ts
lastUpdatedAt: string | null;
```

ISO 8601 timestamp of the last update for this status.

---

## Type Alias: StringFilterProperty


```ts
type StringFilterProperty = string | AdvancedStringFilter;
```

String property with full advanced search capabilities.

---

## Type Alias: SuspendBatchOperationData


```ts
type SuspendBatchOperationData = object;
```

## Properties

### body?

```ts
optional body?: unknown;
```

---

### path

```ts
path: object;
```

#### batchOperationKey

```ts
batchOperationKey: BatchOperationKey;
```

The key (or operate legacy ID) of the batch operation.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/batch-operations/{batchOperationKey}/suspension";
```

---

## Type Alias: SuspendBatchOperationError


```ts
type SuspendBatchOperationError =
  SuspendBatchOperationErrors[keyof SuspendBatchOperationErrors];
```

---

## Type Alias: SuspendBatchOperationErrors


```ts
type SuspendBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The batch operation was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: SuspendBatchOperationResponse


```ts
type SuspendBatchOperationResponse =
  SuspendBatchOperationResponses[keyof SuspendBatchOperationResponses];
```

---

## Type Alias: SuspendBatchOperationResponses


```ts
type SuspendBatchOperationResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The batch operation pause request was created.

---

## Type Alias: SystemConfigurationResponse


```ts
type SystemConfigurationResponse = object;
```

Envelope for all system configuration sections. Each property
represents a feature area.

## Properties

### authentication

```ts
authentication: AuthenticationConfigurationResponse;
```

---

### cloud

```ts
cloud: CloudConfigurationResponse;
```

---

### components

```ts
components: ComponentsConfigurationResponse;
```

---

### deployment

```ts
deployment: DeploymentConfigurationResponse;
```

---

### jobMetrics

```ts
jobMetrics: JobMetricsConfigurationResponse;
```

---

## Type Alias: Tag


```ts
type Tag = CamundaKey<"Tag">;
```

A tag. Needs to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.

---

## Type Alias: TagSet


```ts
type TagSet = Tag[] & object;
```

List of tags. Tags need to start with a letter; then alphanumerics, `_`, `-`, `:`, or `.`; length ≤ 100.

## Type Declaration

### length

```ts
readonly length: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
```

---

## Type Alias: TenantClientResult


```ts
type TenantClientResult = object;
```

## Properties

### clientId

```ts
clientId: ClientId;
```

The ID of the client.

---

## Type Alias: TenantClientSearchQueryRequest


```ts
type TenantClientSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: TenantClientSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: TenantClientSearchQuerySortRequest


```ts
type TenantClientSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "clientId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: TenantClientSearchResult


```ts
type TenantClientSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: TenantClientResult[];
```

The matching clients.

---

## Type Alias: TenantCreateRequest


```ts
type TenantCreateRequest = object;
```

## Properties

### description?

```ts
optional description?: string;
```

The description of the tenant.

---

### name

```ts
name: string;
```

The name of the tenant.

---

### tenantId

```ts
tenantId: TenantId;
```

The unique ID for the tenant. Must be 31 characters or less and match
`^[\w.-]{1,31}$` (word characters, `.`, `-`). The literal
`<default>` is also accepted as the default-tenant alias.

---

## Type Alias: TenantCreateResult


```ts
type TenantCreateResult = object;
```

## Properties

### description

```ts
description: string | null;
```

The description of the tenant.

---

### name

```ts
name: string;
```

The name of the tenant.

---

### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the created tenant.

---

## Type Alias: TenantFilter


```ts
type TenantFilter = object;
```

Tenant filter request

## Properties

### name?

```ts
optional name?: string;
```

The name of the tenant.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

The unique identifier of the tenant.

---

## Type Alias: TenantFilterEnum


```ts
type TenantFilterEnum =
  (typeof TenantFilterEnum)[keyof typeof TenantFilterEnum];
```

The tenant filtering strategy for job activation. Determines whether to use tenant IDs provided in the request or tenant IDs assigned to the authenticated principal.

---

## Type Alias: TenantGroupResult


```ts
type TenantGroupResult = object;
```

## Properties

### groupId

```ts
groupId: GroupId;
```

The group ID.

---

## Type Alias: TenantGroupSearchQueryRequest


```ts
type TenantGroupSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: TenantGroupSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: TenantGroupSearchQuerySortRequest


```ts
type TenantGroupSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "groupId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: TenantGroupSearchResult


```ts
type TenantGroupSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: TenantGroupResult[];
```

The matching groups.

---

## Type Alias: TenantId


```ts
type TenantId = CamundaKey<"TenantId">;
```

The unique identifier of the tenant.

---

## Type Alias: TenantMappingRuleSearchResult


```ts
type TenantMappingRuleSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: MappingRuleResult[];
```

The matching mapping rules.

---

## Type Alias: TenantResult


```ts
type TenantResult = object;
```

Tenant search response item.

## Properties

### description

```ts
description: string | null;
```

The tenant description.

---

### name

```ts
name: string;
```

The tenant name.

---

### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

## Type Alias: TenantRoleSearchResult


```ts
type TenantRoleSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: RoleResult[];
```

The matching roles.

---

## Type Alias: TenantSearchQueryRequest


```ts
type TenantSearchQueryRequest = SearchQueryRequest & object;
```

Tenant search request

## Type Declaration

### filter?

```ts
optional filter?: TenantFilter;
```

The tenant search filters.

### sort?

```ts
optional sort?: TenantSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: TenantSearchQueryResult


```ts
type TenantSearchQueryResult = SearchQueryResponse & object;
```

Tenant search response.

## Type Declaration

### items

```ts
items: TenantResult[];
```

The matching tenants.

---

## Type Alias: TenantSearchQuerySortRequest


```ts
type TenantSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "key" | "name" | "tenantId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: TenantUpdateRequest


```ts
type TenantUpdateRequest = object;
```

## Properties

### description?

```ts
optional description?: string;
```

The new description of the tenant.

---

### name

```ts
name: string;
```

The new name of the tenant.

---

## Type Alias: TenantUpdateResult


```ts
type TenantUpdateResult = object;
```

## Properties

### description

```ts
description: string | null;
```

The description of the tenant.

---

### name

```ts
name: string;
```

The name of the tenant.

---

### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the updated tenant.

---

## Type Alias: TenantUserResult


```ts
type TenantUserResult = object;
```

## Properties

### username

```ts
username: Username;
```

---

## Type Alias: TenantUserSearchQueryRequest


```ts
type TenantUserSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### sort?

```ts
optional sort?: TenantUserSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: TenantUserSearchQuerySortRequest


```ts
type TenantUserSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "username";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: TenantUserSearchResult


```ts
type TenantUserSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: TenantUserResult[];
```

The matching users.

---

## Type Alias: ThreadedJob


```ts
type ThreadedJob = Omit<EnrichedActivatedJob, "log">;
```

The job object received by a threaded handler.
Same shape as EnrichedActivatedJob but without the logger (not available across threads).

---

## Type Alias: ThreadedJobHandler


```ts
type ThreadedJobHandler = (
  job,
  client
) => Promise<JobActionReceipt> | JobActionReceipt;
```

Handler function signature for threaded job workers.

Import this type in your handler module for full intellisense on `job` and `client`:

```ts

const handler: ThreadedJobHandler = async (job, client) => {
  // full intellisense for job.variables, job.complete(), client.publishMessage(), etc.
  return job.complete({ result: "done" });
};
export default handler;
```

## Parameters

### job

[`ThreadedJob`](ThreadedJob.md)

### client

[`CamundaClient`](../classes/CamundaClient.md)

## Returns

\| `Promise`\<[`JobActionReceipt`](JobActionReceipt.md)\>
\| [`JobActionReceipt`](JobActionReceipt.md)

---

## Type Alias: ThrowJobErrorData


```ts
type ThrowJobErrorData = object;
```

## Properties

### body

```ts
body: JobErrorRequest;
```

---

### path

```ts
path: object;
```

#### jobKey

```ts
jobKey: JobKey;
```

The key of the job.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/{jobKey}/error";
```

---

## Type Alias: ThrowJobErrorError


```ts
type ThrowJobErrorError = ThrowJobErrorErrors[keyof ThrowJobErrorErrors];
```

---

## Type Alias: ThrowJobErrorErrors


```ts
type ThrowJobErrorErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The job with the given key was not found or is not activated.

---

### 409

```ts
409: ProblemDetail;
```

The job with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: ThrowJobErrorResponse


```ts
type ThrowJobErrorResponse =
  ThrowJobErrorResponses[keyof ThrowJobErrorResponses];
```

---

## Type Alias: ThrowJobErrorResponses


```ts
type ThrowJobErrorResponses = object;
```

## Properties

### 204

```ts
204: void;
```

An error is thrown for the job.

---

## Type Alias: TimerWaitStateDetails


```ts
type TimerWaitStateDetails = BaseWaitStateDetails & object;
```

## Type Declaration

### dueDate

```ts
dueDate: number | null;
```

When the timer is due, as a UNIX epoch timestamp in milliseconds.

### repetitions

```ts
repetitions: number | null;
```

The number of remaining timer repetitions (-1 for infinite, 0 for non-repeating).

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: TopologyResponse


```ts
type TopologyResponse = object;
```

The response of a topology request.

## Properties

### brokers

```ts
brokers: BrokerInfo[];
```

A list of brokers that are part of this cluster.

---

### clusterId

```ts
clusterId: string | null;
```

The cluster Id.

---

### clusterSize

```ts
clusterSize: number;
```

The number of brokers in the cluster.

---

### gatewayVersion

```ts
gatewayVersion: string;
```

The version of the Zeebe Gateway.

---

### lastCompletedChangeId

```ts
lastCompletedChangeId: string;
```

ID of the last completed change

---

### partitionsCount

```ts
partitionsCount: number;
```

The number of partitions are spread across the cluster.

---

### replicationFactor

```ts
replicationFactor: number;
```

The configured replication factor for this cluster.

---

## Type Alias: UnassignClientFromGroupData


```ts
type UnassignClientFromGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### clientId

```ts
clientId: ClientId;
```

The client ID.

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/clients/{clientId}";
```

---

## Type Alias: UnassignClientFromGroupError


```ts
type UnassignClientFromGroupError =
  UnassignClientFromGroupErrors[keyof UnassignClientFromGroupErrors];
```

---

## Type Alias: UnassignClientFromGroupErrors


```ts
type UnassignClientFromGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found, or the client is not assigned to this group.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignClientFromGroupResponse


```ts
type UnassignClientFromGroupResponse =
  UnassignClientFromGroupResponses[keyof UnassignClientFromGroupResponses];
```

---

## Type Alias: UnassignClientFromGroupResponses


```ts
type UnassignClientFromGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The client was unassigned successfully from the group.

---

## Type Alias: UnassignClientFromTenantData


```ts
type UnassignClientFromTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### clientId

```ts
clientId: ClientId;
```

The unique identifier of the application.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/clients/{clientId}";
```

---

## Type Alias: UnassignClientFromTenantError


```ts
type UnassignClientFromTenantError =
  UnassignClientFromTenantErrors[keyof UnassignClientFromTenantErrors];
```

---

## Type Alias: UnassignClientFromTenantErrors


```ts
type UnassignClientFromTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The tenant does not exist or the client was not assigned to it.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignClientFromTenantResponse


```ts
type UnassignClientFromTenantResponse =
  UnassignClientFromTenantResponses[keyof UnassignClientFromTenantResponses];
```

---

## Type Alias: UnassignClientFromTenantResponses


```ts
type UnassignClientFromTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The client was successfully unassigned from the tenant.

---

## Type Alias: UnassignGroupFromTenantData


```ts
type UnassignGroupFromTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The unique identifier of the group.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/groups/{groupId}";
```

---

## Type Alias: UnassignGroupFromTenantError


```ts
type UnassignGroupFromTenantError =
  UnassignGroupFromTenantErrors[keyof UnassignGroupFromTenantErrors];
```

---

## Type Alias: UnassignGroupFromTenantErrors


```ts
type UnassignGroupFromTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or group was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignGroupFromTenantResponse


```ts
type UnassignGroupFromTenantResponse =
  UnassignGroupFromTenantResponses[keyof UnassignGroupFromTenantResponses];
```

---

## Type Alias: UnassignGroupFromTenantResponses


```ts
type UnassignGroupFromTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The group was successfully unassigned from the tenant.

---

## Type Alias: UnassignMappingRuleFromGroupData


```ts
type UnassignMappingRuleFromGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The mapping rule ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: UnassignMappingRuleFromGroupError


```ts
type UnassignMappingRuleFromGroupError =
  UnassignMappingRuleFromGroupErrors[keyof UnassignMappingRuleFromGroupErrors];
```

---

## Type Alias: UnassignMappingRuleFromGroupErrors


```ts
type UnassignMappingRuleFromGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group or mapping rule with the given ID was not found, or the mapping rule is not assigned to this group.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignMappingRuleFromGroupResponse


```ts
type UnassignMappingRuleFromGroupResponse =
  UnassignMappingRuleFromGroupResponses[keyof UnassignMappingRuleFromGroupResponses];
```

---

## Type Alias: UnassignMappingRuleFromGroupResponses


```ts
type UnassignMappingRuleFromGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The mapping rule was unassigned successfully from the group.

---

## Type Alias: UnassignMappingRuleFromTenantData


```ts
type UnassignMappingRuleFromTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The unique identifier of the mapping rule.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: UnassignMappingRuleFromTenantError


```ts
type UnassignMappingRuleFromTenantError =
  UnassignMappingRuleFromTenantErrors[keyof UnassignMappingRuleFromTenantErrors];
```

---

## Type Alias: UnassignMappingRuleFromTenantErrors


```ts
type UnassignMappingRuleFromTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or mapping rule was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignMappingRuleFromTenantResponse


```ts
type UnassignMappingRuleFromTenantResponse =
  UnassignMappingRuleFromTenantResponses[keyof UnassignMappingRuleFromTenantResponses];
```

---

## Type Alias: UnassignMappingRuleFromTenantResponses


```ts
type UnassignMappingRuleFromTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The mapping rule was successfully unassigned from the tenant.

---

## Type Alias: UnassignRoleFromClientData


```ts
type UnassignRoleFromClientData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### clientId

```ts
clientId: ClientId;
```

The client ID.

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/clients/{clientId}";
```

---

## Type Alias: UnassignRoleFromClientError


```ts
type UnassignRoleFromClientError =
  UnassignRoleFromClientErrors[keyof UnassignRoleFromClientErrors];
```

---

## Type Alias: UnassignRoleFromClientErrors


```ts
type UnassignRoleFromClientErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or client with the given ID or username was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignRoleFromClientResponse


```ts
type UnassignRoleFromClientResponse =
  UnassignRoleFromClientResponses[keyof UnassignRoleFromClientResponses];
```

---

## Type Alias: UnassignRoleFromClientResponses


```ts
type UnassignRoleFromClientResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was unassigned successfully from the client.

---

## Type Alias: UnassignRoleFromGroupData


```ts
type UnassignRoleFromGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/groups/{groupId}";
```

---

## Type Alias: UnassignRoleFromGroupError


```ts
type UnassignRoleFromGroupError =
  UnassignRoleFromGroupErrors[keyof UnassignRoleFromGroupErrors];
```

---

## Type Alias: UnassignRoleFromGroupErrors


```ts
type UnassignRoleFromGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignRoleFromGroupResponse


```ts
type UnassignRoleFromGroupResponse =
  UnassignRoleFromGroupResponses[keyof UnassignRoleFromGroupResponses];
```

---

## Type Alias: UnassignRoleFromGroupResponses


```ts
type UnassignRoleFromGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was unassigned successfully from the group.

---

## Type Alias: UnassignRoleFromMappingRuleData


```ts
type UnassignRoleFromMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The mapping rule ID.

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: UnassignRoleFromMappingRuleError


```ts
type UnassignRoleFromMappingRuleError =
  UnassignRoleFromMappingRuleErrors[keyof UnassignRoleFromMappingRuleErrors];
```

---

## Type Alias: UnassignRoleFromMappingRuleErrors


```ts
type UnassignRoleFromMappingRuleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or mapping rule with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignRoleFromMappingRuleResponse


```ts
type UnassignRoleFromMappingRuleResponse =
  UnassignRoleFromMappingRuleResponses[keyof UnassignRoleFromMappingRuleResponses];
```

---

## Type Alias: UnassignRoleFromMappingRuleResponses


```ts
type UnassignRoleFromMappingRuleResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was unassigned successfully from the mapping rule.

---

## Type Alias: UnassignRoleFromTenantData


```ts
type UnassignRoleFromTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The unique identifier of the role.

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/roles/{roleId}";
```

---

## Type Alias: UnassignRoleFromTenantError


```ts
type UnassignRoleFromTenantError =
  UnassignRoleFromTenantErrors[keyof UnassignRoleFromTenantErrors];
```

---

## Type Alias: UnassignRoleFromTenantErrors


```ts
type UnassignRoleFromTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or role was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignRoleFromTenantResponse


```ts
type UnassignRoleFromTenantResponse =
  UnassignRoleFromTenantResponses[keyof UnassignRoleFromTenantResponses];
```

---

## Type Alias: UnassignRoleFromTenantResponses


```ts
type UnassignRoleFromTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was successfully unassigned from the tenant.

---

## Type Alias: UnassignRoleFromUserData


```ts
type UnassignRoleFromUserData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

#### username

```ts
username: Username;
```

The user username.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}/users/{username}";
```

---

## Type Alias: UnassignRoleFromUserError


```ts
type UnassignRoleFromUserError =
  UnassignRoleFromUserErrors[keyof UnassignRoleFromUserErrors];
```

---

## Type Alias: UnassignRoleFromUserErrors


```ts
type UnassignRoleFromUserErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The role or user with the given ID or username was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignRoleFromUserResponse


```ts
type UnassignRoleFromUserResponse =
  UnassignRoleFromUserResponses[keyof UnassignRoleFromUserResponses];
```

---

## Type Alias: UnassignRoleFromUserResponses


```ts
type UnassignRoleFromUserResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The role was unassigned successfully from the user.

---

## Type Alias: UnassignUserFromGroupData


```ts
type UnassignUserFromGroupData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

#### username

```ts
username: Username;
```

The user username.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}/users/{username}";
```

---

## Type Alias: UnassignUserFromGroupError


```ts
type UnassignUserFromGroupError =
  UnassignUserFromGroupErrors[keyof UnassignUserFromGroupErrors];
```

---

## Type Alias: UnassignUserFromGroupErrors


```ts
type UnassignUserFromGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The group or user with the given ID was not found, or the user is not assigned to this group.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignUserFromGroupResponse


```ts
type UnassignUserFromGroupResponse =
  UnassignUserFromGroupResponses[keyof UnassignUserFromGroupResponses];
```

---

## Type Alias: UnassignUserFromGroupResponses


```ts
type UnassignUserFromGroupResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user was unassigned successfully from the group.

---

## Type Alias: UnassignUserFromTenantData


```ts
type UnassignUserFromTenantData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

#### username

```ts
username: Username;
```

The unique identifier of the user.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}/users/{username}";
```

---

## Type Alias: UnassignUserFromTenantError


```ts
type UnassignUserFromTenantError =
  UnassignUserFromTenantErrors[keyof UnassignUserFromTenantErrors];
```

---

## Type Alias: UnassignUserFromTenantErrors


```ts
type UnassignUserFromTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant or user was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UnassignUserFromTenantResponse


```ts
type UnassignUserFromTenantResponse =
  UnassignUserFromTenantResponses[keyof UnassignUserFromTenantResponses];
```

---

## Type Alias: UnassignUserFromTenantResponses


```ts
type UnassignUserFromTenantResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user was successfully unassigned from the tenant.

---

## Type Alias: UnassignUserTaskData


```ts
type UnassignUserTaskData = object;
```

## Properties

### body?

```ts
optional body?: never;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}/assignee";
```

---

## Type Alias: UnassignUserTaskError


```ts
type UnassignUserTaskError =
  UnassignUserTaskErrors[keyof UnassignUserTaskErrors];
```

---

## Type Alias: UnassignUserTaskErrors


```ts
type UnassignUserTaskErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The user task with the given key was not found.

---

### 409

```ts
409: ProblemDetail;
```

The user task with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response.
Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists

---

## Type Alias: UnassignUserTaskResponse


```ts
type UnassignUserTaskResponse =
  UnassignUserTaskResponses[keyof UnassignUserTaskResponses];
```

---

## Type Alias: UnassignUserTaskResponses


```ts
type UnassignUserTaskResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user task was unassigned successfully.

---

## Type Alias: UpdateAgentInstanceData


```ts
type UpdateAgentInstanceData = object;
```

## Properties

### body

```ts
body: AgentInstanceUpdateRequest;
```

---

### path

```ts
path: object;
```

#### agentInstanceKey

```ts
agentInstanceKey: AgentInstanceKey;
```

The key of the agent instance to update.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/agent-instances/{agentInstanceKey}";
```

---

## Type Alias: UpdateAgentInstanceError


```ts
type UpdateAgentInstanceError =
  UpdateAgentInstanceErrors[keyof UpdateAgentInstanceErrors];
```

---

## Type Alias: UpdateAgentInstanceErrors


```ts
type UpdateAgentInstanceErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The agent instance with the given key was not found.
More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: UpdateAgentInstanceResponse


```ts
type UpdateAgentInstanceResponse =
  UpdateAgentInstanceResponses[keyof UpdateAgentInstanceResponses];
```

---

## Type Alias: UpdateAgentInstanceResponses


```ts
type UpdateAgentInstanceResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The agent instance was updated successfully.

---

## Type Alias: UpdateAuthorizationData


```ts
type UpdateAuthorizationData = object;
```

## Properties

### body

```ts
body: AuthorizationRequest;
```

---

### path

```ts
path: object;
```

#### authorizationKey

```ts
authorizationKey: AuthorizationKey;
```

The key of the authorization to delete.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/authorizations/{authorizationKey}";
```

---

## Type Alias: UpdateAuthorizationError


```ts
type UpdateAuthorizationError =
  UpdateAuthorizationErrors[keyof UpdateAuthorizationErrors];
```

---

## Type Alias: UpdateAuthorizationErrors


```ts
type UpdateAuthorizationErrors = object;
```

## Properties

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The authorization with the authorizationKey was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateAuthorizationResponse


```ts
type UpdateAuthorizationResponse =
  UpdateAuthorizationResponses[keyof UpdateAuthorizationResponses];
```

---

## Type Alias: UpdateAuthorizationResponses


```ts
type UpdateAuthorizationResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The authorization was updated successfully.

---

## Type Alias: UpdateClusterVariableRequest


```ts
type UpdateClusterVariableRequest = object;
```

## Properties

### value

```ts
value: object;
```

The new value of the cluster variable. Can be any JSON object or primitive value. Will be serialized as a JSON string in responses.

#### Index Signature

```ts
[key: string]: unknown
```

---

## Type Alias: UpdateGlobalClusterVariableData


```ts
type UpdateGlobalClusterVariableData = object;
```

## Properties

### body

```ts
body: UpdateClusterVariableRequest;
```

---

### path

```ts
path: object;
```

#### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/global/{name}";
```

---

## Type Alias: UpdateGlobalClusterVariableError


```ts
type UpdateGlobalClusterVariableError =
  UpdateGlobalClusterVariableErrors[keyof UpdateGlobalClusterVariableErrors];
```

---

## Type Alias: UpdateGlobalClusterVariableErrors


```ts
type UpdateGlobalClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Cluster variable not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: UpdateGlobalClusterVariableResponse


```ts
type UpdateGlobalClusterVariableResponse =
  UpdateGlobalClusterVariableResponses[keyof UpdateGlobalClusterVariableResponses];
```

---

## Type Alias: UpdateGlobalClusterVariableResponses


```ts
type UpdateGlobalClusterVariableResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableResult;
```

Cluster variable updated successfully

---

## Type Alias: UpdateGlobalTaskListenerData


```ts
type UpdateGlobalTaskListenerData = object;
```

## Properties

### body

```ts
body: UpdateGlobalTaskListenerRequest;
```

---

### path

```ts
path: object;
```

#### id

```ts
id: GlobalListenerId;
```

The id of the global user task listener to update.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/global-task-listeners/{id}";
```

---

## Type Alias: UpdateGlobalTaskListenerError


```ts
type UpdateGlobalTaskListenerError =
  UpdateGlobalTaskListenerErrors[keyof UpdateGlobalTaskListenerErrors];
```

---

## Type Alias: UpdateGlobalTaskListenerErrors


```ts
type UpdateGlobalTaskListenerErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The global user task listener was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateGlobalTaskListenerRequest


```ts
type UpdateGlobalTaskListenerRequest = GlobalTaskListenerBase;
```

---

## Type Alias: UpdateGlobalTaskListenerResponse


```ts
type UpdateGlobalTaskListenerResponse =
  UpdateGlobalTaskListenerResponses[keyof UpdateGlobalTaskListenerResponses];
```

---

## Type Alias: UpdateGlobalTaskListenerResponses


```ts
type UpdateGlobalTaskListenerResponses = object;
```

## Properties

### 200

```ts
200: GlobalTaskListenerResult;
```

The global listener was updated successfully.

---

## Type Alias: UpdateGroupData


```ts
type UpdateGroupData = object;
```

## Properties

### body

```ts
body: GroupUpdateRequest;
```

---

### path

```ts
path: object;
```

#### groupId

```ts
groupId: GroupId;
```

The group ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/groups/{groupId}";
```

---

## Type Alias: UpdateGroupError


```ts
type UpdateGroupError = UpdateGroupErrors[keyof UpdateGroupErrors];
```

---

## Type Alias: UpdateGroupErrors


```ts
type UpdateGroupErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The group with the given ID was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateGroupResponse


```ts
type UpdateGroupResponse = UpdateGroupResponses[keyof UpdateGroupResponses];
```

---

## Type Alias: UpdateGroupResponses


```ts
type UpdateGroupResponses = object;
```

## Properties

### 200

```ts
200: GroupUpdateResult;
```

The group was updated successfully.

---

## Type Alias: UpdateJobData


```ts
type UpdateJobData = object;
```

## Properties

### body

```ts
body: JobUpdateRequest;
```

---

### path

```ts
path: object;
```

#### jobKey

```ts
jobKey: JobKey;
```

The key of the job to update.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/{jobKey}";
```

---

## Type Alias: UpdateJobError


```ts
type UpdateJobError = UpdateJobErrors[keyof UpdateJobErrors];
```

---

## Type Alias: UpdateJobErrors


```ts
type UpdateJobErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The job with the jobKey is not found.

---

### 409

```ts
409: ProblemDetail;
```

The job with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateJobResponse


```ts
type UpdateJobResponse = UpdateJobResponses[keyof UpdateJobResponses];
```

---

## Type Alias: UpdateJobResponses


```ts
type UpdateJobResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The job was updated successfully.

---

## Type Alias: UpdateJobsBatchOperationData


```ts
type UpdateJobsBatchOperationData = object;
```

## Properties

### body

```ts
body: JobBatchUpdateRequest;
```

---

### path?

```ts
optional path?: never;
```

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/jobs/batch-update";
```

---

## Type Alias: UpdateJobsBatchOperationError


```ts
type UpdateJobsBatchOperationError =
  UpdateJobsBatchOperationErrors[keyof UpdateJobsBatchOperationErrors];
```

---

## Type Alias: UpdateJobsBatchOperationErrors


```ts
type UpdateJobsBatchOperationErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The job batch update operation failed. More details are provided in the response body.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: UpdateJobsBatchOperationResponse


```ts
type UpdateJobsBatchOperationResponse =
  UpdateJobsBatchOperationResponses[keyof UpdateJobsBatchOperationResponses];
```

---

## Type Alias: UpdateJobsBatchOperationResponses


```ts
type UpdateJobsBatchOperationResponses = object;
```

## Properties

### 200

```ts
200: BatchOperationCreatedResult;
```

The batch operation was created.

---

## Type Alias: UpdateMappingRuleData


```ts
type UpdateMappingRuleData = object;
```

## Properties

### body?

```ts
optional body?: MappingRuleUpdateRequest;
```

---

### path

```ts
path: object;
```

#### mappingRuleId

```ts
mappingRuleId: MappingRuleId;
```

The ID of the mapping rule to update.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/mapping-rules/{mappingRuleId}";
```

---

## Type Alias: UpdateMappingRuleError


```ts
type UpdateMappingRuleError =
  UpdateMappingRuleErrors[keyof UpdateMappingRuleErrors];
```

---

## Type Alias: UpdateMappingRuleErrors


```ts
type UpdateMappingRuleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

The request to update a mapping rule was denied.
More details are provided in the response body.

---

### 404

```ts
404: ProblemDetail;
```

The request to update a mapping rule was denied.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateMappingRuleResponse


```ts
type UpdateMappingRuleResponse =
  UpdateMappingRuleResponses[keyof UpdateMappingRuleResponses];
```

---

## Type Alias: UpdateMappingRuleResponses


```ts
type UpdateMappingRuleResponses = object;
```

## Properties

### 200

```ts
200: MappingRuleUpdateResult;
```

The mapping rule was updated successfully.

---

## Type Alias: UpdateRoleData


```ts
type UpdateRoleData = object;
```

## Properties

### body

```ts
body: RoleUpdateRequest;
```

---

### path

```ts
path: object;
```

#### roleId

```ts
roleId: RoleId;
```

The role ID.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/roles/{roleId}";
```

---

## Type Alias: UpdateRoleError


```ts
type UpdateRoleError = UpdateRoleErrors[keyof UpdateRoleErrors];
```

---

## Type Alias: UpdateRoleErrors


```ts
type UpdateRoleErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 404

```ts
404: ProblemDetail;
```

The role with the ID is not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateRoleResponse


```ts
type UpdateRoleResponse = UpdateRoleResponses[keyof UpdateRoleResponses];
```

---

## Type Alias: UpdateRoleResponses


```ts
type UpdateRoleResponses = object;
```

## Properties

### 200

```ts
200: RoleUpdateResult;
```

The role was updated successfully.

---

## Type Alias: UpdateTenantClusterVariableData


```ts
type UpdateTenantClusterVariableData = object;
```

## Properties

### body

```ts
body: UpdateClusterVariableRequest;
```

---

### path

```ts
path: object;
```

#### name

```ts
name: ClusterVariableName;
```

The name of the cluster variable

#### tenantId

```ts
tenantId: TenantId;
```

The tenant ID

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/cluster-variables/tenants/{tenantId}/{name}";
```

---

## Type Alias: UpdateTenantClusterVariableError


```ts
type UpdateTenantClusterVariableError =
  UpdateTenantClusterVariableErrors[keyof UpdateTenantClusterVariableErrors];
```

---

## Type Alias: UpdateTenantClusterVariableErrors


```ts
type UpdateTenantClusterVariableErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 401

```ts
401: ProblemDetail;
```

The request lacks valid authentication credentials.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Cluster variable not found

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

## Type Alias: UpdateTenantClusterVariableResponse


```ts
type UpdateTenantClusterVariableResponse =
  UpdateTenantClusterVariableResponses[keyof UpdateTenantClusterVariableResponses];
```

---

## Type Alias: UpdateTenantClusterVariableResponses


```ts
type UpdateTenantClusterVariableResponses = object;
```

## Properties

### 200

```ts
200: ClusterVariableResult;
```

Cluster variable updated successfully

---

## Type Alias: UpdateTenantData


```ts
type UpdateTenantData = object;
```

## Properties

### body

```ts
body: TenantUpdateRequest;
```

---

### path

```ts
path: object;
```

#### tenantId

```ts
tenantId: TenantId;
```

The unique identifier of the tenant.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/tenants/{tenantId}";
```

---

## Type Alias: UpdateTenantError


```ts
type UpdateTenantError = UpdateTenantErrors[keyof UpdateTenantErrors];
```

---

## Type Alias: UpdateTenantErrors


```ts
type UpdateTenantErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

Not found. The tenant was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateTenantResponse


```ts
type UpdateTenantResponse = UpdateTenantResponses[keyof UpdateTenantResponses];
```

---

## Type Alias: UpdateTenantResponses


```ts
type UpdateTenantResponses = object;
```

## Properties

### 200

```ts
200: TenantUpdateResult;
```

The tenant was updated successfully.

---

## Type Alias: UpdateUserData


```ts
type UpdateUserData = object;
```

## Properties

### body

```ts
body: UserUpdateRequest;
```

---

### path

```ts
path: object;
```

#### username

```ts
username: Username;
```

The username of the user to update.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/users/{username}";
```

---

## Type Alias: UpdateUserError


```ts
type UpdateUserError = UpdateUserErrors[keyof UpdateUserErrors];
```

---

## Type Alias: UpdateUserErrors


```ts
type UpdateUserErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 403

```ts
403: ProblemDetail;
```

Forbidden. The request is not allowed.

---

### 404

```ts
404: ProblemDetail;
```

The user was not found.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

## Type Alias: UpdateUserResponse


```ts
type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
```

---

## Type Alias: UpdateUserResponses


```ts
type UpdateUserResponses = object;
```

## Properties

### 200

```ts
200: UserUpdateResult;
```

The user was updated successfully.

---

## Type Alias: UpdateUserTaskData


```ts
type UpdateUserTaskData = object;
```

## Properties

### body?

```ts
optional body?: UserTaskUpdateRequest;
```

---

### path

```ts
path: object;
```

#### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task to update.

---

### query?

```ts
optional query?: never;
```

---

### url

```ts
url: "/user-tasks/{userTaskKey}";
```

---

## Type Alias: UpdateUserTaskError


```ts
type UpdateUserTaskError = UpdateUserTaskErrors[keyof UpdateUserTaskErrors];
```

---

## Type Alias: UpdateUserTaskErrors


```ts
type UpdateUserTaskErrors = object;
```

## Properties

### 400

```ts
400: ProblemDetail;
```

The provided data is not valid.

---

### 404

```ts
404: ProblemDetail;
```

The user task with the given key was not found.

---

### 409

```ts
409: ProblemDetail;
```

The user task with the given key is in the wrong state currently. More details are provided in the response body.

---

### 500

```ts
500: ProblemDetail;
```

An internal error occurred while processing the request.

---

### 503

```ts
503: ProblemDetail;
```

The service is currently unavailable. This may happen only on some requests where the system creates backpressure to prevent the server's compute resources from being exhausted, avoiding more severe failures. In this case, the title of the error object contains `RESOURCE_EXHAUSTED`. Clients are recommended to eventually retry those requests after a backoff period. You can learn more about the backpressure mechanism here: https://docs.camunda.io/docs/components/zeebe/technical-concepts/internal-processing/#handling-backpressure .

---

### 504

```ts
504: ProblemDetail;
```

The request timed out between the gateway and the broker. For these endpoints, this often happens when user task listeners are configured and the corresponding listener job is not completed within the request timeout. Common causes include no available job workers for the listener type, busy or crashed job workers, or delayed job completion. As with any gateway timeout, general timeout causes (for example transient network issues) can also result in a 504 response.
Troubleshooting: - verify that job workers for the listener type are running and healthy - check worker logs for crashes, retries, and completion failures - check network connectivity between workers, gateway, and broker - retry with backoff after transient failures - fail without retries if a problem persists

---

## Type Alias: UpdateUserTaskResponse


```ts
type UpdateUserTaskResponse =
  UpdateUserTaskResponses[keyof UpdateUserTaskResponses];
```

---

## Type Alias: UpdateUserTaskResponses


```ts
type UpdateUserTaskResponses = object;
```

## Properties

### 204

```ts
204: void;
```

The user task was updated successfully.

---

## Type Alias: UsageMetricsResponse


```ts
type UsageMetricsResponse = UsageMetricsResponseItem & object;
```

## Type Declaration

### activeTenants

```ts
activeTenants: number;
```

The amount of active tenants.

### tenants

```ts
tenants: object;
```

The usage metrics by tenants. Only available if request `withTenants` query parameter was `true`.

#### Index Signature

```ts
[key: string]: UsageMetricsResponseItem
```

---

## Type Alias: UsageMetricsResponseItem


```ts
type UsageMetricsResponseItem = object;
```

## Properties

### assignees

```ts
assignees: number;
```

The amount of unique active task users.

---

### decisionInstances

```ts
decisionInstances: number;
```

The amount of executed decision instances.

---

### processInstances

```ts
processInstances: number;
```

The amount of created root process instances.

---

## Type Alias: UseSourceParentKeyInstruction


```ts
type UseSourceParentKeyInstruction = object;
```

Instructs the engine to use the source's direct parent key as the ancestor scope key for the target element. This is a simpler alternative to `inferred` that skips hierarchy traversal and directly uses the source's parent key. This is useful when the source and target elements are siblings within the same flow scope.

## Properties

### ancestorScopeType

```ts
ancestorScopeType: string;
```

The type of ancestor scope instruction.

---

## Type Alias: UserCreateResult


```ts
type UserCreateResult = object;
```

## Properties

### email

```ts
email: string | null;
```

The email of the user.

---

### name

```ts
name: string | null;
```

The name of the user.

---

### username

```ts
username: Username;
```

The username of the created user.

---

## Type Alias: UserFilter


```ts
type UserFilter = object;
```

User search filter.

## Properties

### email?

```ts
optional email?: StringFilterProperty;
```

The email of the user.

---

### name?

```ts
optional name?: StringFilterProperty;
```

The name of the user.

---

### username?

```ts
optional username?: StringFilterProperty;
```

The username of the user.

---

## Type Alias: UserRequest


```ts
type UserRequest = object;
```

## Properties

### email?

```ts
optional email?: string;
```

The email of the user.

---

### name?

```ts
optional name?: string;
```

The name of the user.

---

### password

```ts
password: string;
```

The password of the user.

---

### username

```ts
username: Username;
```

The username of the new user.

---

## Type Alias: UserResult


```ts
type UserResult = object;
```

## Properties

### email

```ts
email: string | null;
```

The email of the user.

---

### name

```ts
name: string | null;
```

The name of the user.

---

### username

```ts
username: Username;
```

The username of the user.

---

## Type Alias: UserSearchQueryRequest


```ts
type UserSearchQueryRequest = SearchQueryRequest & object;
```

## Type Declaration

### filter?

```ts
optional filter?: UserFilter;
```

The user search filters.

### sort?

```ts
optional sort?: UserSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: UserSearchQuerySortRequest


```ts
type UserSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field: "username" | "name" | "email";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: UserSearchResult


```ts
type UserSearchResult = SearchQueryResponse & object;
```

## Type Declaration

### items

```ts
items: UserResult[];
```

The matching users.

---

## Type Alias: UserTaskAssignmentRequest


```ts
type UserTaskAssignmentRequest = object;
```

## Properties

### action?

```ts
optional action?: string | null;
```

A custom action value that will be accessible from user task events resulting from this endpoint invocation. If not provided, it will default to "assign".

---

### allowOverride?

```ts
optional allowOverride?: boolean | null;
```

By default, the task is reassigned if it was already assigned. Set this to `false` to return an error in such cases. The task must then first be unassigned to be assigned again. Use this when you have users picking from group task queues to prevent race conditions.

---

### assignee?

```ts
optional assignee?: string;
```

The assignee for the user task. The assignee must not be empty or `null`.

---

## Type Alias: UserTaskAuditLogFilter


```ts
type UserTaskAuditLogFilter = object;
```

The user task audit log search filters.

## Properties

### actorId?

```ts
optional actorId?: StringFilterProperty;
```

The actor ID search filter.

---

### actorType?

```ts
optional actorType?: AuditLogActorTypeFilterProperty;
```

The actor type search filter.

---

### operationType?

```ts
optional operationType?: OperationTypeFilterProperty;
```

The audit log operation type search filter.

---

### result?

```ts
optional result?: AuditLogResultFilterProperty;
```

The audit log result search filter.

---

### timestamp?

```ts
optional timestamp?: DateTimeFilterProperty;
```

The audit log timestamp filter.

---

## Type Alias: UserTaskAuditLogSearchQueryRequest


```ts
type UserTaskAuditLogSearchQueryRequest = SearchQueryRequest & object;
```

User task search query request.

## Type Declaration

### filter?

```ts
optional filter?: UserTaskAuditLogFilter;
```

### sort?

```ts
optional sort?: AuditLogSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: UserTaskCompletionRequest


```ts
type UserTaskCompletionRequest = object;
```

## Properties

### action?

```ts
optional action?: string | null;
```

A custom action value that will be accessible from user task events resulting from this endpoint invocation. If not provided, it will default to "complete".

---

### variables?

```ts
optional variables?:
  | {
[key: string]: unknown;
}
  | null;
```

The variables to complete the user task with.

---

## Type Alias: UserTaskEffectiveVariableSearchQueryRequest


```ts
type UserTaskEffectiveVariableSearchQueryRequest = object;
```

User task effective variable search query request. Uses offset-based pagination only.

## Properties

### filter?

```ts
optional filter?: UserTaskVariableFilter;
```

The user task variable search filters.

---

### page?

```ts
optional page?: OffsetPagination;
```

Pagination parameters.

---

### sort?

```ts
optional sort?: UserTaskVariableSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: UserTaskFilter


```ts
type UserTaskFilter = object;
```

User task filter request.

## Properties

### assignee?

```ts
optional assignee?: StringFilterProperty;
```

The assignee of the user task.

---

### businessId?

```ts
optional businessId?: StringFilterProperty;
```

The business ID of the owning process instance the user task belongs to. This only works for user tasks created with 8.10 and onwards. Tasks from prior versions don't contain this data and cannot be found.

---

### candidateGroup?

```ts
optional candidateGroup?: StringFilterProperty;
```

The candidate group for this user task.

---

### candidateUser?

```ts
optional candidateUser?: StringFilterProperty;
```

The candidate user for this user task.

---

### completionDate?

```ts
optional completionDate?: DateTimeFilterProperty;
```

The user task completion date.

---

### creationDate?

```ts
optional creationDate?: DateTimeFilterProperty;
```

The user task creation date.

---

### dueDate?

```ts
optional dueDate?: DateTimeFilterProperty;
```

The user task due date.

---

### elementId?

```ts
optional elementId?: ElementId;
```

The element ID of the user task.

---

### elementInstanceKey?

```ts
optional elementInstanceKey?: ElementInstanceKey;
```

The key of the element instance.

---

### followUpDate?

```ts
optional followUpDate?: DateTimeFilterProperty;
```

The user task follow-up date.

---

### localVariables?

```ts
optional localVariables?: VariableValueFilterProperty[];
```

The local variables of the user task.

---

### name?

```ts
optional name?: StringFilterProperty;
```

The task name. This only works for data created with 8.8 and onwards. Instances from prior versions don't contain this data and cannot be found.

---

### priority?

```ts
optional priority?: IntegerFilterProperty;
```

The priority of the user task.

---

### processDefinitionId?

```ts
optional processDefinitionId?: ProcessDefinitionIdFilterProperty;
```

The ID of the process definition.

---

### processDefinitionKey?

```ts
optional processDefinitionKey?: ProcessDefinitionKeyFilterProperty;
```

The key of the process definition.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The key of the process instance.

---

### processInstanceVariables?

```ts
optional processInstanceVariables?: VariableValueFilterProperty[];
```

The variables of the process instance.

---

### state?

```ts
optional state?: UserTaskStateFilterProperty;
```

The user task state.

---

### tags?

```ts
optional tags?: TagSet;
```

---

### tenantId?

```ts
optional tenantId?: StringFilterProperty;
```

Tenant ID of this user task.

---

### userTaskKey?

```ts
optional userTaskKey?: UserTaskKey;
```

The key for this user task.

---

## Type Alias: UserTaskKey


```ts
type UserTaskKey = CamundaKey<"UserTaskKey">;
```

System-generated key for a user task.

---

## Type Alias: UserTaskProperties


```ts
type UserTaskProperties = object;
```

Contains properties of a user task.

## Properties

### action

```ts
action: string;
```

The action performed on the user task.

---

### assignee

```ts
assignee: string | null;
```

The user assigned to the task.

---

### candidateGroups

```ts
candidateGroups: string[];
```

The groups eligible to claim the task.

---

### candidateUsers

```ts
candidateUsers: string[];
```

The users eligible to claim the task.

---

### changedAttributes

```ts
changedAttributes: string[];
```

The attributes that were changed in the task.

---

### dueDate

```ts
dueDate: string | null;
```

The due date of the user task in ISO 8601 format.

---

### followUpDate

```ts
followUpDate: string | null;
```

The follow-up date of the user task in ISO 8601 format.

---

### formKey

```ts
formKey: FormKey | null;
```

The key of the form associated with the user task.

---

### priority

```ts
priority: number | null;
```

The priority of the user task.

---

### userTaskKey

```ts
userTaskKey: UserTaskKey | null;
```

The unique key identifying the user task.

---

## Type Alias: UserTaskResult


```ts
type UserTaskResult = object;
```

## Properties

### assignee

```ts
assignee: string | null;
```

The assignee of the user task.

---

### businessId

```ts
businessId: BusinessId | null;
```

The business ID of the owning process instance, inherited when the user task was
created. This is `null` for user tasks created before version 8.10, and for user tasks
whose owning process instance has no business ID.

---

### candidateGroups

```ts
candidateGroups: string[];
```

The candidate groups for this user task.

---

### candidateUsers

```ts
candidateUsers: string[];
```

The candidate users for this user task.

---

### completionDate

```ts
completionDate: string | null;
```

The completion date of a user task.

---

### creationDate

```ts
creationDate: string;
```

The creation date of a user task.

---

### customHeaders

```ts
customHeaders: object;
```

Custom headers for the user task.

#### Index Signature

```ts
[key: string]: string
```

---

### dueDate

```ts
dueDate: string | null;
```

The due date of a user task.

---

### elementId

```ts
elementId: ElementId;
```

The element ID of the user task.

---

### elementInstanceKey

```ts
elementInstanceKey: ElementInstanceKey;
```

The key of the element instance.

---

### externalFormReference

```ts
externalFormReference: string | null;
```

The external form reference.

---

### followUpDate

```ts
followUpDate: string | null;
```

The follow date of a user task.

---

### formKey

```ts
formKey: FormKey | null;
```

The key of the form.

---

### name

```ts
name: string | null;
```

The name for this user task.

---

### priority

```ts
priority: number;
```

The priority of a user task. The higher the value the higher the priority.

---

### processDefinitionId

```ts
processDefinitionId: ProcessDefinitionId;
```

The ID of the process definition.

---

### processDefinitionKey

```ts
processDefinitionKey: ProcessDefinitionKey;
```

The key of the process definition.

---

### processDefinitionVersion

```ts
processDefinitionVersion: number;
```

The version of the process definition.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance.

---

### processName

```ts
processName: string | null;
```

The name of the process definition.
This is `null` if the process has no name defined.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### state

```ts
state: UserTaskStateEnum;
```

---

### tags

```ts
tags: TagSet;
```

---

### tenantId

```ts
tenantId: TenantId;
```

---

### userTaskKey

```ts
userTaskKey: UserTaskKey;
```

The key of the user task.

---

## Type Alias: UserTaskSearchQuery


```ts
type UserTaskSearchQuery = SearchQueryRequest & object;
```

User task search query request.

## Type Declaration

### filter?

```ts
optional filter?: UserTaskFilter;
```

The user task search filters.

### sort?

```ts
optional sort?: UserTaskSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: UserTaskSearchQueryResult


```ts
type UserTaskSearchQueryResult = SearchQueryResponse & object;
```

User task search query response.

## Type Declaration

### items

```ts
items: UserTaskResult[];
```

The matching user tasks.

---

## Type Alias: UserTaskSearchQuerySortRequest


```ts
type UserTaskSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "creationDate"
  | "completionDate"
  | "followUpDate"
  | "dueDate"
  | "priority"
  | "name"
  | "businessId";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: UserTaskStateEnum


```ts
type UserTaskStateEnum =
  (typeof UserTaskStateEnum)[keyof typeof UserTaskStateEnum];
```

The state of the user task.
Note: FAILED state is only for legacy job-worker-based tasks.

---

## Type Alias: UserTaskStateExactMatch


```ts
type UserTaskStateExactMatch = UserTaskStateEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: UserTaskStateFilterProperty


```ts
type UserTaskStateFilterProperty =
  UserTaskStateExactMatch | AdvancedUserTaskStateFilter;
```

UserTaskStateEnum property with full advanced search capabilities.

---

## Type Alias: UserTaskUpdateRequest


```ts
type UserTaskUpdateRequest = object;
```

## Properties

### action?

```ts
optional action?: string | null;
```

A custom action value that will be accessible from user task events resulting from this endpoint invocation. If not provided, it will default to "update".

---

### changeset?

```ts
optional changeset?: Changeset;
```

---

## Type Alias: UserTaskVariableFilter


```ts
type UserTaskVariableFilter = object;
```

The user task variable search filters.

## Properties

### name?

```ts
optional name?: StringFilterProperty;
```

Name of the variable.

---

## Type Alias: UserTaskVariableSearchQueryRequest


```ts
type UserTaskVariableSearchQueryRequest = SearchQueryRequest & object;
```

User task search query request.

## Type Declaration

### filter?

```ts
optional filter?: UserTaskVariableFilter;
```

The user task variable search filters.

### sort?

```ts
optional sort?: UserTaskVariableSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: UserTaskVariableSearchQuerySortRequest


```ts
type UserTaskVariableSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "value"
  | "name"
  | "tenantId"
  | "variableKey"
  | "scopeKey"
  | "processInstanceKey";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: UserTaskWaitStateDetails


```ts
type UserTaskWaitStateDetails = BaseWaitStateDetails & object;
```

## Type Declaration

### dueDate

```ts
dueDate: string | null;
```

The due date of the user task, if set.

### taskKey

```ts
taskKey: UserTaskKey;
```

The key of the user task.

### waitStateType

```ts
waitStateType: string;
```

The wait state type discriminator.

---

## Type Alias: UserUpdateRequest


```ts
type UserUpdateRequest = object;
```

## Properties

### email?

```ts
optional email?: string;
```

The email of the user.

---

### name?

```ts
optional name?: string;
```

The name of the user.

---

### password?

```ts
optional password?: string;
```

The password of the user. If blank, the password is unchanged.

---

## Type Alias: UserUpdateResult


```ts
type UserUpdateResult = object;
```

## Properties

### email

```ts
email: string | null;
```

The email of the user.

---

### name

```ts
name: string | null;
```

The name of the user.

---

### username

```ts
username: Username;
```

The username of the updated user.

---

## Type Alias: Username


```ts
type Username = CamundaKey<"Username">;
```

The unique name of a user.

---

## Type Alias: ValidationMode


```ts
type ValidationMode = "none" | "warn" | "strict" | "fanatical";
```

---

## Type Alias: VariableFilter


```ts
type VariableFilter = object;
```

Variable filter request.

## Properties

### isTruncated?

```ts
optional isTruncated?: boolean;
```

Whether the value is truncated or not.

---

### name?

```ts
optional name?: StringFilterProperty;
```

Name of the variable.

---

### processInstanceKey?

```ts
optional processInstanceKey?: ProcessInstanceKeyFilterProperty;
```

The key of the process instance of this variable.

---

### scopeKey?

```ts
optional scopeKey?: ScopeKeyFilterProperty;
```

The key of the scope that defines where this variable is directly defined. This can be a
process instance key (for process-level variables) or an element instance key (for local
variables scoped to tasks, subprocesses, gateways, events, etc.). Use this filter to
find variables directly defined in specific scopes. Note that this does not include
variables from parent scopes that would be visible through the scope hierarchy.

---

### tenantId?

```ts
optional tenantId?: TenantId;
```

Tenant ID of this variable.

---

### value?

```ts
optional value?: StringFilterProperty;
```

The value of the variable.
Variable values in filters need to be in serialized JSON format. For example, a variable
with string value `myValue` can be found with the filter value `"myValue"`. Consider
appropriate escaping for special characters in JSON strings when constructing filter values.

---

### variableKey?

```ts
optional variableKey?: VariableKeyFilterProperty;
```

The key for this variable.

---

## Type Alias: VariableKey


```ts
type VariableKey = CamundaKey<"VariableKey">;
```

System-generated key for a variable.

---

## Type Alias: VariableKeyExactMatch


```ts
type VariableKeyExactMatch = VariableKey;
```

Exact match

Matches the value exactly.

---

## Type Alias: VariableKeyFilterProperty


```ts
type VariableKeyFilterProperty =
  VariableKeyExactMatch | AdvancedVariableKeyFilter;
```

VariableKey property with full advanced search capabilities.

---

## Type Alias: VariableResult


```ts
type VariableResult = VariableResultBase & object;
```

Variable search response item.

## Type Declaration

### value

```ts
value: string;
```

Full value of this variable.

---

## Type Alias: VariableResultBase


```ts
type VariableResultBase = object;
```

Variable response item.

## Properties

### name

```ts
name: string;
```

Name of this variable.

---

### processInstanceKey

```ts
processInstanceKey: ProcessInstanceKey;
```

The key of the process instance of this variable.

---

### rootProcessInstanceKey

```ts
rootProcessInstanceKey: ProcessInstanceKey | null;
```

The key of the root process instance. The root process instance is the top-level
ancestor in the process instance hierarchy. This field is only present for data
belonging to process instance hierarchies created in version 8.9 or later.

---

### scopeKey

```ts
scopeKey: ScopeKey;
```

The key of the scope where this variable is directly defined. For process-level
variables, this is the process instance key. For local variables, this is the key of the
specific element instance (task, subprocess, gateway, event, etc.) where the variable is
directly defined.

---

### tenantId

```ts
tenantId: TenantId;
```

Tenant ID of this variable.

---

### variableKey

```ts
variableKey: VariableKey;
```

The key for this variable.

---

## Type Alias: VariableSearchQuery


```ts
type VariableSearchQuery = SearchQueryRequest & object;
```

Variable search query request.

## Type Declaration

### filter?

```ts
optional filter?: VariableFilter;
```

The variable search filters.

### sort?

```ts
optional sort?: VariableSearchQuerySortRequest[];
```

Sort field criteria.

---

## Type Alias: VariableSearchQueryResult


```ts
type VariableSearchQueryResult = SearchQueryResponse & object;
```

Variable search query response.

## Type Declaration

### items

```ts
items: VariableSearchResult[];
```

The matching variables.

---

## Type Alias: VariableSearchQuerySortRequest


```ts
type VariableSearchQuerySortRequest = object;
```

## Properties

### field

```ts
field:
  | "value"
  | "name"
  | "tenantId"
  | "variableKey"
  | "scopeKey"
  | "processInstanceKey";
```

The field to sort by.

---

### order?

```ts
optional order?: SortOrderEnum;
```

---

## Type Alias: VariableSearchResult


```ts
type VariableSearchResult = VariableResultBase & object;
```

Variable search response item.

## Type Declaration

### isTruncated

```ts
isTruncated: boolean;
```

Whether the value is truncated or not.

### value

```ts
value: string;
```

Value of this variable. Can be truncated.

---

## Type Alias: VariableValueFilterProperty


```ts
type VariableValueFilterProperty = object;
```

## Properties

### name

```ts
name: string;
```

Name of the variable.

---

### value

```ts
value: StringFilterProperty;
```

The value of the variable.
Variable values in filters need to be in serialized JSON format. For example, a variable
with string value `myValue` can be found with the filter value `"myValue"`. Consider
appropriate escaping for special characters in JSON strings when constructing filter values.

---

## Type Alias: WaitStateDetails


```ts
type WaitStateDetails =
  | (object & JobWaitStateDetails)
  | (object & MessageWaitStateDetails)
  | (object & UserTaskWaitStateDetails)
  | (object & TimerWaitStateDetails)
  | (object & SignalWaitStateDetails)
  | (object & ConditionWaitStateDetails);
```

Wait-state-specific details of an element instance.

---

## Type Alias: WaitStateElementTypeEnum


```ts
type WaitStateElementTypeEnum =
  (typeof WaitStateElementTypeEnum)[keyof typeof WaitStateElementTypeEnum];
```

The BPMN element type of a waiting element instance.

---

## Type Alias: WaitStateElementTypeExactMatch


```ts
type WaitStateElementTypeExactMatch = WaitStateElementTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: WaitStateElementTypeFilterProperty


```ts
type WaitStateElementTypeFilterProperty =
  WaitStateElementTypeExactMatch | AdvancedWaitStateElementTypeFilter;
```

Element type property with full advanced search capabilities.

---

## Type Alias: WaitStateTypeEnum


```ts
type WaitStateTypeEnum =
  (typeof WaitStateTypeEnum)[keyof typeof WaitStateTypeEnum];
```

The type of waiting state an element instance is in.

---

## Type Alias: WaitStateTypeExactMatch


```ts
type WaitStateTypeExactMatch = WaitStateTypeEnum;
```

Exact match

Matches the value exactly.

---

## Type Alias: WaitStateTypeFilterProperty


```ts
type WaitStateTypeFilterProperty =
  WaitStateTypeExactMatch | AdvancedWaitStateTypeFilter;
```

Wait state type property with full advanced search capabilities.

---

## Type Alias: WebappComponent


```ts
type WebappComponent = "operate" | "tasklist" | "admin";
```

A Camunda webapp component name.

---

## Type Alias: activateAdHocSubProcessActivitiesInput


```ts
type activateAdHocSubProcessActivitiesInput =
  activateAdHocSubProcessActivitiesBody & object;
```

## Type Declaration

### adHocSubProcessInstanceKey

```ts
adHocSubProcessInstanceKey: activateAdHocSubProcessActivitiesPathParam_adHocSubProcessInstanceKey;
```

---

## Type Alias: activateJobsInput


```ts
type activateJobsInput = activateJobsBody;
```

---

## Type Alias: assignClientToGroupInput


```ts
type assignClientToGroupInput = object;
```

## Properties

### clientId

```ts
clientId: assignClientToGroupPathParam_clientId;
```

---

### groupId

```ts
groupId: assignClientToGroupPathParam_groupId;
```

---

## Type Alias: assignClientToTenantInput


```ts
type assignClientToTenantInput = object;
```

## Properties

### clientId

```ts
clientId: assignClientToTenantPathParam_clientId;
```

---

### tenantId

```ts
tenantId: assignClientToTenantPathParam_tenantId;
```

---

## Type Alias: assignGroupToTenantInput


```ts
type assignGroupToTenantInput = object;
```

## Properties

### groupId

```ts
groupId: assignGroupToTenantPathParam_groupId;
```

---

### tenantId

```ts
tenantId: assignGroupToTenantPathParam_tenantId;
```

---

## Type Alias: assignMappingRuleToGroupInput


```ts
type assignMappingRuleToGroupInput = object;
```

## Properties

### groupId

```ts
groupId: assignMappingRuleToGroupPathParam_groupId;
```

---

### mappingRuleId

```ts
mappingRuleId: assignMappingRuleToGroupPathParam_mappingRuleId;
```

---

## Type Alias: assignMappingRuleToTenantInput


```ts
type assignMappingRuleToTenantInput = object;
```

## Properties

### mappingRuleId

```ts
mappingRuleId: assignMappingRuleToTenantPathParam_mappingRuleId;
```

---

### tenantId

```ts
tenantId: assignMappingRuleToTenantPathParam_tenantId;
```

---

## Type Alias: assignRoleToClientInput


```ts
type assignRoleToClientInput = object;
```

## Properties

### clientId

```ts
clientId: assignRoleToClientPathParam_clientId;
```

---

### roleId

```ts
roleId: assignRoleToClientPathParam_roleId;
```

---

## Type Alias: assignRoleToGroupInput


```ts
type assignRoleToGroupInput = object;
```

## Properties

### groupId

```ts
groupId: assignRoleToGroupPathParam_groupId;
```

---

### roleId

```ts
roleId: assignRoleToGroupPathParam_roleId;
```

---

## Type Alias: assignRoleToMappingRuleInput


```ts
type assignRoleToMappingRuleInput = object;
```

## Properties

### mappingRuleId

```ts
mappingRuleId: assignRoleToMappingRulePathParam_mappingRuleId;
```

---

### roleId

```ts
roleId: assignRoleToMappingRulePathParam_roleId;
```

---

## Type Alias: assignRoleToTenantInput


```ts
type assignRoleToTenantInput = object;
```

## Properties

### roleId

```ts
roleId: assignRoleToTenantPathParam_roleId;
```

---

### tenantId

```ts
tenantId: assignRoleToTenantPathParam_tenantId;
```

---

## Type Alias: assignRoleToUserInput


```ts
type assignRoleToUserInput = object;
```

## Properties

### roleId

```ts
roleId: assignRoleToUserPathParam_roleId;
```

---

### username

```ts
username: assignRoleToUserPathParam_username;
```

---

## Type Alias: assignUserTaskInput


```ts
type assignUserTaskInput = assignUserTaskBody & object;
```

## Type Declaration

### userTaskKey

```ts
userTaskKey: assignUserTaskPathParam_userTaskKey;
```

---

## Type Alias: assignUserToGroupInput


```ts
type assignUserToGroupInput = object;
```

## Properties

### groupId

```ts
groupId: assignUserToGroupPathParam_groupId;
```

---

### username

```ts
username: assignUserToGroupPathParam_username;
```

---

## Type Alias: assignUserToTenantInput


```ts
type assignUserToTenantInput = object;
```

## Properties

### tenantId

```ts
tenantId: assignUserToTenantPathParam_tenantId;
```

---

### username

```ts
username: assignUserToTenantPathParam_username;
```

---

## Type Alias: broadcastSignalInput


```ts
type broadcastSignalInput = broadcastSignalBody;
```

---

## Type Alias: cancelBatchOperationInput


```ts
type cancelBatchOperationInput = cancelBatchOperationBody & object;
```

## Type Declaration

### batchOperationKey

```ts
batchOperationKey: cancelBatchOperationPathParam_batchOperationKey;
```

---

## Type Alias: cancelProcessInstanceInput


```ts
type cancelProcessInstanceInput = cancelProcessInstanceBody & object;
```

## Type Declaration

### processInstanceKey

```ts
processInstanceKey: cancelProcessInstancePathParam_processInstanceKey;
```

---

## Type Alias: cancelProcessInstancesBatchOperationInput


```ts
type cancelProcessInstancesBatchOperationInput =
  cancelProcessInstancesBatchOperationBody;
```

---

## Type Alias: completeJobInput


```ts
type completeJobInput = completeJobBody & object;
```

## Type Declaration

### jobKey

```ts
jobKey: completeJobPathParam_jobKey;
```

---

## Type Alias: completeUserTaskInput


```ts
type completeUserTaskInput = completeUserTaskBody & object;
```

## Type Declaration

### userTaskKey

```ts
userTaskKey: completeUserTaskPathParam_userTaskKey;
```

---

## Type Alias: correlateMessageInput


```ts
type correlateMessageInput = correlateMessageBody;
```

---

## Type Alias: createAdminUserInput


```ts
type createAdminUserInput = createAdminUserBody;
```

---

## Type Alias: createAgentInstanceHistoryItemInput


```ts
type createAgentInstanceHistoryItemInput = createAgentInstanceHistoryItemBody &
  object;
```

## Type Declaration

### agentInstanceKey

```ts
agentInstanceKey: createAgentInstanceHistoryItemPathParam_agentInstanceKey;
```

---

## Type Alias: createAgentInstanceInput


```ts
type createAgentInstanceInput = createAgentInstanceBody;
```

---

## Type Alias: createAuthorizationInput


```ts
type createAuthorizationInput = createAuthorizationBody;
```

---

## Type Alias: createDeploymentInput


```ts
type createDeploymentInput = Omit<createDeploymentBody, "resources"> & object;
```

## Type Declaration

### resources

```ts
resources: File[];
```

---

## Type Alias: createDocumentInput


```ts
type createDocumentInput = createDocumentBody & object;
```

## Type Declaration

### documentId?

```ts
optional documentId?: createDocumentQueryParam_documentId;
```

### storeId?

```ts
optional storeId?: createDocumentQueryParam_storeId;
```

---

## Type Alias: createDocumentLinkInput


```ts
type createDocumentLinkInput = createDocumentLinkBody & object;
```

## Type Declaration

### contentHash?

```ts
optional contentHash?: createDocumentLinkQueryParam_contentHash;
```

### documentId

```ts
documentId: createDocumentLinkPathParam_documentId;
```

### storeId?

```ts
optional storeId?: createDocumentLinkQueryParam_storeId;
```

---

## Type Alias: createDocumentsInput


```ts
type createDocumentsInput = createDocumentsBody & object;
```

## Type Declaration

### storeId?

```ts
optional storeId?: createDocumentsQueryParam_storeId;
```

---

## Type Alias: createElementInstanceVariablesInput


```ts
type createElementInstanceVariablesInput = createElementInstanceVariablesBody &
  object;
```

## Type Declaration

### elementInstanceKey

```ts
elementInstanceKey: createElementInstanceVariablesPathParam_elementInstanceKey;
```

---

## Type Alias: createGlobalClusterVariableInput


```ts
type createGlobalClusterVariableInput = createGlobalClusterVariableBody;
```

---

## Type Alias: createGlobalTaskListenerInput


```ts
type createGlobalTaskListenerInput = createGlobalTaskListenerBody;
```

---

## Type Alias: createGroupInput


```ts
type createGroupInput = createGroupBody;
```

---

## Type Alias: createMappingRuleInput


```ts
type createMappingRuleInput = createMappingRuleBody;
```

---

## Type Alias: createProcessInstanceInput


```ts
type createProcessInstanceInput = createProcessInstanceBody;
```

---

## Type Alias: createRoleInput


```ts
type createRoleInput = createRoleBody;
```

---

## Type Alias: createTenantClusterVariableInput


```ts
type createTenantClusterVariableInput = createTenantClusterVariableBody &
  object;
```

## Type Declaration

### tenantId

```ts
tenantId: createTenantClusterVariablePathParam_tenantId;
```

---

## Type Alias: createTenantInput


```ts
type createTenantInput = createTenantBody;
```

---

## Type Alias: createUserInput


```ts
type createUserInput = createUserBody;
```

---

## Type Alias: deleteAuthorizationInput


```ts
type deleteAuthorizationInput = object;
```

## Properties

### authorizationKey

```ts
authorizationKey: deleteAuthorizationPathParam_authorizationKey;
```

---

## Type Alias: deleteDecisionInstanceInput


```ts
type deleteDecisionInstanceInput = deleteDecisionInstanceBody & object;
```

## Type Declaration

### decisionEvaluationKey

```ts
decisionEvaluationKey: deleteDecisionInstancePathParam_decisionEvaluationKey;
```

---

## Type Alias: deleteDecisionInstancesBatchOperationInput


```ts
type deleteDecisionInstancesBatchOperationInput =
  deleteDecisionInstancesBatchOperationBody;
```

---

## Type Alias: deleteDocumentInput


```ts
type deleteDocumentInput = object;
```

## Properties

### documentId

```ts
documentId: deleteDocumentPathParam_documentId;
```

---

### storeId?

```ts
optional storeId?: deleteDocumentQueryParam_storeId;
```

---

## Type Alias: deleteGlobalClusterVariableInput


```ts
type deleteGlobalClusterVariableInput = object;
```

## Properties

### name

```ts
name: deleteGlobalClusterVariablePathParam_name;
```

---

## Type Alias: deleteGlobalTaskListenerInput


```ts
type deleteGlobalTaskListenerInput = object;
```

## Properties

### id

```ts
id: deleteGlobalTaskListenerPathParam_id;
```

---

## Type Alias: deleteGroupInput


```ts
type deleteGroupInput = object;
```

## Properties

### groupId

```ts
groupId: deleteGroupPathParam_groupId;
```

---

## Type Alias: deleteMappingRuleInput


```ts
type deleteMappingRuleInput = object;
```

## Properties

### mappingRuleId

```ts
mappingRuleId: deleteMappingRulePathParam_mappingRuleId;
```

---

## Type Alias: deleteProcessInstanceInput


```ts
type deleteProcessInstanceInput = deleteProcessInstanceBody & object;
```

## Type Declaration

### processInstanceKey

```ts
processInstanceKey: deleteProcessInstancePathParam_processInstanceKey;
```

---

## Type Alias: deleteProcessInstancesBatchOperationInput


```ts
type deleteProcessInstancesBatchOperationInput =
  deleteProcessInstancesBatchOperationBody;
```

---

## Type Alias: deleteResourceInput


```ts
type deleteResourceInput = deleteResourceBody & object;
```

## Type Declaration

### resourceKey

```ts
resourceKey: deleteResourcePathParam_resourceKey;
```

---

## Type Alias: deleteRoleInput


```ts
type deleteRoleInput = object;
```

## Properties

### roleId

```ts
roleId: deleteRolePathParam_roleId;
```

---

## Type Alias: deleteTenantClusterVariableInput


```ts
type deleteTenantClusterVariableInput = object;
```

## Properties

### name

```ts
name: deleteTenantClusterVariablePathParam_name;
```

---

### tenantId

```ts
tenantId: deleteTenantClusterVariablePathParam_tenantId;
```

---

## Type Alias: deleteTenantInput


```ts
type deleteTenantInput = object;
```

## Properties

### tenantId

```ts
tenantId: deleteTenantPathParam_tenantId;
```

---

## Type Alias: deleteUserInput


```ts
type deleteUserInput = object;
```

## Properties

### username

```ts
username: deleteUserPathParam_username;
```

---

## Type Alias: evaluateConditionalsInput


```ts
type evaluateConditionalsInput = evaluateConditionalsBody;
```

---

## Type Alias: evaluateDecisionInput


```ts
type evaluateDecisionInput = evaluateDecisionBody;
```

---

## Type Alias: evaluateExpressionInput


```ts
type evaluateExpressionInput = evaluateExpressionBody;
```

---

## Type Alias: failJobInput


```ts
type failJobInput = failJobBody & object;
```

## Type Declaration

### jobKey

```ts
jobKey: failJobPathParam_jobKey;
```

---

## Type Alias: getAgentInstanceConsistency


```ts
type getAgentInstanceConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getAgentInstance>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getAgentInstanceInput


```ts
type getAgentInstanceInput = object;
```

## Properties

### agentInstanceKey

```ts
agentInstanceKey: getAgentInstancePathParam_agentInstanceKey;
```

---

## Type Alias: getAuditLogConsistency


```ts
type getAuditLogConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getAuditLog>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getAuditLogInput


```ts
type getAuditLogInput = object;
```

## Properties

### auditLogKey

```ts
auditLogKey: getAuditLogPathParam_auditLogKey;
```

---

## Type Alias: getAuthenticationInput


```ts
type getAuthenticationInput = void;
```

---

## Type Alias: getAuthorizationConsistency


```ts
type getAuthorizationConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getAuthorization>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getAuthorizationInput


```ts
type getAuthorizationInput = object;
```

## Properties

### authorizationKey

```ts
authorizationKey: getAuthorizationPathParam_authorizationKey;
```

---

## Type Alias: getBatchOperationConsistency


```ts
type getBatchOperationConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getBatchOperation>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getBatchOperationInput


```ts
type getBatchOperationInput = object;
```

## Properties

### batchOperationKey

```ts
batchOperationKey: getBatchOperationPathParam_batchOperationKey;
```

---

## Type Alias: getDecisionDefinitionConsistency


```ts
type getDecisionDefinitionConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getDecisionDefinition>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getDecisionDefinitionInput


```ts
type getDecisionDefinitionInput = object;
```

## Properties

### decisionDefinitionKey

```ts
decisionDefinitionKey: getDecisionDefinitionPathParam_decisionDefinitionKey;
```

---

## Type Alias: getDecisionDefinitionXmlConsistency


```ts
type getDecisionDefinitionXmlConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getDecisionDefinitionXml>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getDecisionDefinitionXmlInput


```ts
type getDecisionDefinitionXmlInput = object;
```

## Properties

### decisionDefinitionKey

```ts
decisionDefinitionKey: getDecisionDefinitionXmlPathParam_decisionDefinitionKey;
```

---

## Type Alias: getDecisionInstanceConsistency


```ts
type getDecisionInstanceConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getDecisionInstance>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getDecisionInstanceInput


```ts
type getDecisionInstanceInput = object;
```

## Properties

### decisionEvaluationInstanceKey

```ts
decisionEvaluationInstanceKey: getDecisionInstancePathParam_decisionEvaluationInstanceKey;
```

---

## Type Alias: getDecisionRequirementsConsistency


```ts
type getDecisionRequirementsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getDecisionRequirements>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getDecisionRequirementsInput


```ts
type getDecisionRequirementsInput = object;
```

## Properties

### decisionRequirementsKey

```ts
decisionRequirementsKey: getDecisionRequirementsPathParam_decisionRequirementsKey;
```

---

## Type Alias: getDecisionRequirementsXmlConsistency


```ts
type getDecisionRequirementsXmlConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getDecisionRequirementsXml>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getDecisionRequirementsXmlInput


```ts
type getDecisionRequirementsXmlInput = object;
```

## Properties

### decisionRequirementsKey

```ts
decisionRequirementsKey: getDecisionRequirementsXmlPathParam_decisionRequirementsKey;
```

---

## Type Alias: getDocumentInput


```ts
type getDocumentInput = object;
```

## Properties

### contentHash?

```ts
optional contentHash?: getDocumentQueryParam_contentHash;
```

---

### documentId

```ts
documentId: getDocumentPathParam_documentId;
```

---

### storeId?

```ts
optional storeId?: getDocumentQueryParam_storeId;
```

---

## Type Alias: getElementInstanceConsistency


```ts
type getElementInstanceConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getElementInstance>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getElementInstanceInput


```ts
type getElementInstanceInput = object;
```

## Properties

### elementInstanceKey

```ts
elementInstanceKey: getElementInstancePathParam_elementInstanceKey;
```

---

## Type Alias: getFormByKeyConsistency


```ts
type getFormByKeyConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getFormByKey>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getFormByKeyInput


```ts
type getFormByKeyInput = object;
```

## Properties

### formKey

```ts
formKey: getFormByKeyPathParam_formKey;
```

---

## Type Alias: getGlobalClusterVariableConsistency


```ts
type getGlobalClusterVariableConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getGlobalClusterVariable>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getGlobalClusterVariableInput


```ts
type getGlobalClusterVariableInput = object;
```

## Properties

### name

```ts
name: getGlobalClusterVariablePathParam_name;
```

---

## Type Alias: getGlobalJobStatisticsConsistency


```ts
type getGlobalJobStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getGlobalJobStatistics>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getGlobalJobStatisticsInput


```ts
type getGlobalJobStatisticsInput = object;
```

## Properties

### from

```ts
from: getGlobalJobStatisticsQueryParam_from;
```

---

### jobType?

```ts
optional jobType?: getGlobalJobStatisticsQueryParam_jobType;
```

---

### to

```ts
to: getGlobalJobStatisticsQueryParam_to;
```

---

## Type Alias: getGlobalTaskListenerConsistency


```ts
type getGlobalTaskListenerConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getGlobalTaskListener>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getGlobalTaskListenerInput


```ts
type getGlobalTaskListenerInput = object;
```

## Properties

### id

```ts
id: getGlobalTaskListenerPathParam_id;
```

---

## Type Alias: getGroupConsistency


```ts
type getGroupConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getGroup>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getGroupInput


```ts
type getGroupInput = object;
```

## Properties

### groupId

```ts
groupId: getGroupPathParam_groupId;
```

---

## Type Alias: getIncidentConsistency


```ts
type getIncidentConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getIncident>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getIncidentInput


```ts
type getIncidentInput = object;
```

## Properties

### incidentKey

```ts
incidentKey: getIncidentPathParam_incidentKey;
```

---

## Type Alias: getJobErrorStatisticsConsistency


```ts
type getJobErrorStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getJobErrorStatistics>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getJobErrorStatisticsInput


```ts
type getJobErrorStatisticsInput = getJobErrorStatisticsBody;
```

---

## Type Alias: getJobTimeSeriesStatisticsConsistency


```ts
type getJobTimeSeriesStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getJobTimeSeriesStatistics>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getJobTimeSeriesStatisticsInput


```ts
type getJobTimeSeriesStatisticsInput = getJobTimeSeriesStatisticsBody;
```

---

## Type Alias: getJobTypeStatisticsConsistency


```ts
type getJobTypeStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getJobTypeStatistics>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getJobTypeStatisticsInput


```ts
type getJobTypeStatisticsInput = getJobTypeStatisticsBody;
```

---

## Type Alias: getJobWorkerStatisticsConsistency


```ts
type getJobWorkerStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getJobWorkerStatistics>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getJobWorkerStatisticsInput


```ts
type getJobWorkerStatisticsInput = getJobWorkerStatisticsBody;
```

---

## Type Alias: getLicenseInput


```ts
type getLicenseInput = void;
```

---

## Type Alias: getMappingRuleConsistency


```ts
type getMappingRuleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getMappingRule>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getMappingRuleInput


```ts
type getMappingRuleInput = object;
```

## Properties

### mappingRuleId

```ts
mappingRuleId: getMappingRulePathParam_mappingRuleId;
```

---

## Type Alias: getProcessDefinitionConsistency


```ts
type getProcessDefinitionConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getProcessDefinition>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessDefinitionInput


```ts
type getProcessDefinitionInput = object;
```

## Properties

### processDefinitionKey

```ts
processDefinitionKey: getProcessDefinitionPathParam_processDefinitionKey;
```

---

## Type Alias: getProcessDefinitionInstanceStatisticsConsistency


```ts
type getProcessDefinitionInstanceStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessDefinitionInstanceStatistics>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessDefinitionInstanceStatisticsInput


```ts
type getProcessDefinitionInstanceStatisticsInput =
  getProcessDefinitionInstanceStatisticsBody;
```

---

## Type Alias: getProcessDefinitionInstanceVersionStatisticsConsistency


```ts
type getProcessDefinitionInstanceVersionStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessDefinitionInstanceVersionStatistics>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessDefinitionInstanceVersionStatisticsInput


```ts
type getProcessDefinitionInstanceVersionStatisticsInput =
  getProcessDefinitionInstanceVersionStatisticsBody;
```

---

## Type Alias: getProcessDefinitionMessageSubscriptionStatisticsConsistency


```ts
type getProcessDefinitionMessageSubscriptionStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessDefinitionMessageSubscriptionStatistics>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessDefinitionMessageSubscriptionStatisticsInput


```ts
type getProcessDefinitionMessageSubscriptionStatisticsInput =
  getProcessDefinitionMessageSubscriptionStatisticsBody;
```

---

## Type Alias: getProcessDefinitionStatisticsConsistency


```ts
type getProcessDefinitionStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessDefinitionStatistics>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessDefinitionStatisticsInput


```ts
type getProcessDefinitionStatisticsInput = getProcessDefinitionStatisticsBody &
  object;
```

## Type Declaration

### processDefinitionKey

```ts
processDefinitionKey: getProcessDefinitionStatisticsPathParam_processDefinitionKey;
```

---

## Type Alias: getProcessDefinitionXmlConsistency


```ts
type getProcessDefinitionXmlConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getProcessDefinitionXml>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessDefinitionXmlInput


```ts
type getProcessDefinitionXmlInput = object;
```

## Properties

### processDefinitionKey

```ts
processDefinitionKey: getProcessDefinitionXmlPathParam_processDefinitionKey;
```

---

## Type Alias: getProcessInstanceCallHierarchyConsistency


```ts
type getProcessInstanceCallHierarchyConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessInstanceCallHierarchy>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceCallHierarchyInput


```ts
type getProcessInstanceCallHierarchyInput = object;
```

## Properties

### processInstanceKey

```ts
processInstanceKey: getProcessInstanceCallHierarchyPathParam_processInstanceKey;
```

---

## Type Alias: getProcessInstanceConsistency


```ts
type getProcessInstanceConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getProcessInstance>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceInput


```ts
type getProcessInstanceInput = object;
```

## Properties

### processInstanceKey

```ts
processInstanceKey: getProcessInstancePathParam_processInstanceKey;
```

---

## Type Alias: getProcessInstanceSequenceFlowsConsistency


```ts
type getProcessInstanceSequenceFlowsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessInstanceSequenceFlows>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceSequenceFlowsInput


```ts
type getProcessInstanceSequenceFlowsInput = object;
```

## Properties

### processInstanceKey

```ts
processInstanceKey: getProcessInstanceSequenceFlowsPathParam_processInstanceKey;
```

---

## Type Alias: getProcessInstanceStatisticsByDefinitionConsistency


```ts
type getProcessInstanceStatisticsByDefinitionConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessInstanceStatisticsByDefinition>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceStatisticsByDefinitionInput


```ts
type getProcessInstanceStatisticsByDefinitionInput =
  getProcessInstanceStatisticsByDefinitionBody;
```

---

## Type Alias: getProcessInstanceStatisticsByErrorConsistency


```ts
type getProcessInstanceStatisticsByErrorConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessInstanceStatisticsByError>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceStatisticsByErrorInput


```ts
type getProcessInstanceStatisticsByErrorInput =
  getProcessInstanceStatisticsByErrorBody;
```

---

## Type Alias: getProcessInstanceStatisticsConsistency


```ts
type getProcessInstanceStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessInstanceStatistics>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceStatisticsInput


```ts
type getProcessInstanceStatisticsInput = object;
```

## Properties

### processInstanceKey

```ts
processInstanceKey: getProcessInstanceStatisticsPathParam_processInstanceKey;
```

---

## Type Alias: getProcessInstanceWaitStateStatisticsConsistency


```ts
type getProcessInstanceWaitStateStatisticsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.getProcessInstanceWaitStateStatistics>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getProcessInstanceWaitStateStatisticsInput


```ts
type getProcessInstanceWaitStateStatisticsInput = object;
```

## Properties

### processInstanceKey

```ts
processInstanceKey: getProcessInstanceWaitStateStatisticsPathParam_processInstanceKey;
```

---

## Type Alias: getResourceConsistency


```ts
type getResourceConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getResource>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getResourceContentBinaryConsistency


```ts
type getResourceContentBinaryConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getResourceContentBinary>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getResourceContentBinaryInput


```ts
type getResourceContentBinaryInput = object;
```

## Properties

### resourceKey

```ts
resourceKey: getResourceContentBinaryPathParam_resourceKey;
```

---

## Type Alias: getResourceContentConsistency


```ts
type getResourceContentConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getResourceContent>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getResourceContentInput


```ts
type getResourceContentInput = object;
```

## Properties

### resourceKey

```ts
resourceKey: getResourceContentPathParam_resourceKey;
```

---

## Type Alias: getResourceInput


```ts
type getResourceInput = object;
```

## Properties

### resourceKey

```ts
resourceKey: getResourcePathParam_resourceKey;
```

---

## Type Alias: getRoleConsistency


```ts
type getRoleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getRole>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getRoleInput


```ts
type getRoleInput = object;
```

## Properties

### roleId

```ts
roleId: getRolePathParam_roleId;
```

---

## Type Alias: getStartProcessFormConsistency


```ts
type getStartProcessFormConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getStartProcessForm>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getStartProcessFormInput


```ts
type getStartProcessFormInput = object;
```

## Properties

### processDefinitionKey

```ts
processDefinitionKey: getStartProcessFormPathParam_processDefinitionKey;
```

---

## Type Alias: getStatusInput


```ts
type getStatusInput = void;
```

---

## Type Alias: getSystemConfigurationInput


```ts
type getSystemConfigurationInput = void;
```

---

## Type Alias: getTenantClusterVariableConsistency


```ts
type getTenantClusterVariableConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getTenantClusterVariable>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getTenantClusterVariableInput


```ts
type getTenantClusterVariableInput = object;
```

## Properties

### name

```ts
name: getTenantClusterVariablePathParam_name;
```

---

### tenantId

```ts
tenantId: getTenantClusterVariablePathParam_tenantId;
```

---

## Type Alias: getTenantConsistency


```ts
type getTenantConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getTenant>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getTenantInput


```ts
type getTenantInput = object;
```

## Properties

### tenantId

```ts
tenantId: getTenantPathParam_tenantId;
```

---

## Type Alias: getTopologyInput


```ts
type getTopologyInput = void;
```

---

## Type Alias: getUsageMetricsConsistency


```ts
type getUsageMetricsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getUsageMetrics>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getUsageMetricsInput


```ts
type getUsageMetricsInput = object;
```

## Properties

### endTime

```ts
endTime: getUsageMetricsQueryParam_endTime;
```

---

### startTime

```ts
startTime: getUsageMetricsQueryParam_startTime;
```

---

### tenantId?

```ts
optional tenantId?: getUsageMetricsQueryParam_tenantId;
```

---

### withTenants?

```ts
optional withTenants?: getUsageMetricsQueryParam_withTenants;
```

---

## Type Alias: getUserConsistency


```ts
type getUserConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getUser>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getUserInput


```ts
type getUserInput = object;
```

## Properties

### username

```ts
username: getUserPathParam_username;
```

---

## Type Alias: getUserTaskConsistency


```ts
type getUserTaskConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getUserTask>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getUserTaskFormConsistency


```ts
type getUserTaskFormConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getUserTaskForm>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getUserTaskFormInput


```ts
type getUserTaskFormInput = object;
```

## Properties

### userTaskKey

```ts
userTaskKey: getUserTaskFormPathParam_userTaskKey;
```

---

## Type Alias: getUserTaskInput


```ts
type getUserTaskInput = object;
```

## Properties

### userTaskKey

```ts
userTaskKey: getUserTaskPathParam_userTaskKey;
```

---

## Type Alias: getVariableConsistency


```ts
type getVariableConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.getVariable>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: getVariableInput


```ts
type getVariableInput = object;
```

## Properties

### variableKey

```ts
variableKey: getVariablePathParam_variableKey;
```

---

## Type Alias: migrateProcessInstanceInput


```ts
type migrateProcessInstanceInput = migrateProcessInstanceBody & object;
```

## Type Declaration

### processInstanceKey

```ts
processInstanceKey: migrateProcessInstancePathParam_processInstanceKey;
```

---

## Type Alias: migrateProcessInstancesBatchOperationInput


```ts
type migrateProcessInstancesBatchOperationInput =
  migrateProcessInstancesBatchOperationBody;
```

---

## Type Alias: modifyProcessInstanceInput


```ts
type modifyProcessInstanceInput = modifyProcessInstanceBody & object;
```

## Type Declaration

### processInstanceKey

```ts
processInstanceKey: modifyProcessInstancePathParam_processInstanceKey;
```

---

## Type Alias: modifyProcessInstancesBatchOperationInput


```ts
type modifyProcessInstancesBatchOperationInput =
  modifyProcessInstancesBatchOperationBody;
```

---

## Type Alias: pinClockInput


```ts
type pinClockInput = pinClockBody;
```

---

## Type Alias: publishMessageInput


```ts
type publishMessageInput = publishMessageBody;
```

---

## Type Alias: resetClockInput


```ts
type resetClockInput = void;
```

---

## Type Alias: resolveIncidentInput


```ts
type resolveIncidentInput = resolveIncidentBody & object;
```

## Type Declaration

### incidentKey

```ts
incidentKey: resolveIncidentPathParam_incidentKey;
```

---

## Type Alias: resolveIncidentsBatchOperationInput


```ts
type resolveIncidentsBatchOperationInput = resolveIncidentsBatchOperationBody;
```

---

## Type Alias: resolveProcessInstanceIncidentsInput


```ts
type resolveProcessInstanceIncidentsInput = object;
```

## Properties

### processInstanceKey

```ts
processInstanceKey: resolveProcessInstanceIncidentsPathParam_processInstanceKey;
```

---

## Type Alias: resumeBatchOperationInput


```ts
type resumeBatchOperationInput = resumeBatchOperationBody & object;
```

## Type Declaration

### batchOperationKey

```ts
batchOperationKey: resumeBatchOperationPathParam_batchOperationKey;
```

---

## Type Alias: searchAgentInstanceHistoryConsistency


```ts
type searchAgentInstanceHistoryConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchAgentInstanceHistory>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchAgentInstanceHistoryInput


```ts
type searchAgentInstanceHistoryInput = searchAgentInstanceHistoryBody & object;
```

## Type Declaration

### agentInstanceKey

```ts
agentInstanceKey: searchAgentInstanceHistoryPathParam_agentInstanceKey;
```

---

## Type Alias: searchAgentInstancesConsistency


```ts
type searchAgentInstancesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchAgentInstances>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchAgentInstancesInput


```ts
type searchAgentInstancesInput = searchAgentInstancesBody;
```

---

## Type Alias: searchAuditLogsConsistency


```ts
type searchAuditLogsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchAuditLogs>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchAuditLogsInput


```ts
type searchAuditLogsInput = searchAuditLogsBody;
```

---

## Type Alias: searchAuthorizationsConsistency


```ts
type searchAuthorizationsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchAuthorizations>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchAuthorizationsInput


```ts
type searchAuthorizationsInput = searchAuthorizationsBody;
```

---

## Type Alias: searchBatchOperationItemsConsistency


```ts
type searchBatchOperationItemsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchBatchOperationItems>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchBatchOperationItemsInput


```ts
type searchBatchOperationItemsInput = searchBatchOperationItemsBody;
```

---

## Type Alias: searchBatchOperationsConsistency


```ts
type searchBatchOperationsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchBatchOperations>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchBatchOperationsInput


```ts
type searchBatchOperationsInput = searchBatchOperationsBody;
```

---

## Type Alias: searchClientsForGroupConsistency


```ts
type searchClientsForGroupConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchClientsForGroup>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchClientsForGroupInput


```ts
type searchClientsForGroupInput = searchClientsForGroupBody & object;
```

## Type Declaration

### groupId

```ts
groupId: searchClientsForGroupPathParam_groupId;
```

---

## Type Alias: searchClientsForRoleConsistency


```ts
type searchClientsForRoleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchClientsForRole>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchClientsForRoleInput


```ts
type searchClientsForRoleInput = searchClientsForRoleBody & object;
```

## Type Declaration

### roleId

```ts
roleId: searchClientsForRolePathParam_roleId;
```

---

## Type Alias: searchClientsForTenantConsistency


```ts
type searchClientsForTenantConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchClientsForTenant>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchClientsForTenantInput


```ts
type searchClientsForTenantInput = searchClientsForTenantBody & object;
```

## Type Declaration

### tenantId

```ts
tenantId: searchClientsForTenantPathParam_tenantId;
```

---

## Type Alias: searchClusterVariablesConsistency


```ts
type searchClusterVariablesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchClusterVariables>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchClusterVariablesInput


```ts
type searchClusterVariablesInput = searchClusterVariablesBody & object;
```

## Type Declaration

### truncateValues?

```ts
optional truncateValues?: searchClusterVariablesQueryParam_truncateValues;
```

---

## Type Alias: searchCorrelatedMessageSubscriptionsConsistency


```ts
type searchCorrelatedMessageSubscriptionsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.searchCorrelatedMessageSubscriptions>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchCorrelatedMessageSubscriptionsInput


```ts
type searchCorrelatedMessageSubscriptionsInput =
  searchCorrelatedMessageSubscriptionsBody;
```

---

## Type Alias: searchDecisionDefinitionsConsistency


```ts
type searchDecisionDefinitionsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchDecisionDefinitions>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchDecisionDefinitionsInput


```ts
type searchDecisionDefinitionsInput = searchDecisionDefinitionsBody;
```

---

## Type Alias: searchDecisionInstancesConsistency


```ts
type searchDecisionInstancesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchDecisionInstances>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchDecisionInstancesInput


```ts
type searchDecisionInstancesInput = searchDecisionInstancesBody;
```

---

## Type Alias: searchDecisionRequirementsConsistency


```ts
type searchDecisionRequirementsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchDecisionRequirements>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchDecisionRequirementsInput


```ts
type searchDecisionRequirementsInput = searchDecisionRequirementsBody;
```

---

## Type Alias: searchElementInstanceIncidentsConsistency


```ts
type searchElementInstanceIncidentsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.searchElementInstanceIncidents>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchElementInstanceIncidentsInput


```ts
type searchElementInstanceIncidentsInput = searchElementInstanceIncidentsBody &
  object;
```

## Type Declaration

### elementInstanceKey

```ts
elementInstanceKey: searchElementInstanceIncidentsPathParam_elementInstanceKey;
```

---

## Type Alias: searchElementInstanceWaitStatesConsistency


```ts
type searchElementInstanceWaitStatesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.searchElementInstanceWaitStates>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchElementInstanceWaitStatesInput


```ts
type searchElementInstanceWaitStatesInput = searchElementInstanceWaitStatesBody;
```

---

## Type Alias: searchElementInstancesConsistency


```ts
type searchElementInstancesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchElementInstances>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchElementInstancesInput


```ts
type searchElementInstancesInput = searchElementInstancesBody;
```

---

## Type Alias: searchGlobalTaskListenersConsistency


```ts
type searchGlobalTaskListenersConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchGlobalTaskListeners>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchGlobalTaskListenersInput


```ts
type searchGlobalTaskListenersInput = searchGlobalTaskListenersBody;
```

---

## Type Alias: searchGroupIdsForTenantConsistency


```ts
type searchGroupIdsForTenantConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchGroupIdsForTenant>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchGroupIdsForTenantInput


```ts
type searchGroupIdsForTenantInput = searchGroupIdsForTenantBody & object;
```

## Type Declaration

### tenantId

```ts
tenantId: searchGroupIdsForTenantPathParam_tenantId;
```

---

## Type Alias: searchGroupsConsistency


```ts
type searchGroupsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchGroups>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchGroupsForRoleConsistency


```ts
type searchGroupsForRoleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchGroupsForRole>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchGroupsForRoleInput


```ts
type searchGroupsForRoleInput = searchGroupsForRoleBody & object;
```

## Type Declaration

### roleId

```ts
roleId: searchGroupsForRolePathParam_roleId;
```

---

## Type Alias: searchGroupsInput


```ts
type searchGroupsInput = searchGroupsBody;
```

---

## Type Alias: searchIncidentsConsistency


```ts
type searchIncidentsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchIncidents>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchIncidentsInput


```ts
type searchIncidentsInput = searchIncidentsBody;
```

---

## Type Alias: searchJobsConsistency


```ts
type searchJobsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchJobs>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchJobsInput


```ts
type searchJobsInput = searchJobsBody;
```

---

## Type Alias: searchMappingRuleConsistency


```ts
type searchMappingRuleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchMappingRule>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchMappingRuleInput


```ts
type searchMappingRuleInput = searchMappingRuleBody;
```

---

## Type Alias: searchMappingRulesForGroupConsistency


```ts
type searchMappingRulesForGroupConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchMappingRulesForGroup>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchMappingRulesForGroupInput


```ts
type searchMappingRulesForGroupInput = searchMappingRulesForGroupBody & object;
```

## Type Declaration

### groupId

```ts
groupId: searchMappingRulesForGroupPathParam_groupId;
```

---

## Type Alias: searchMappingRulesForRoleConsistency


```ts
type searchMappingRulesForRoleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchMappingRulesForRole>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchMappingRulesForRoleInput


```ts
type searchMappingRulesForRoleInput = searchMappingRulesForRoleBody & object;
```

## Type Declaration

### roleId

```ts
roleId: searchMappingRulesForRolePathParam_roleId;
```

---

## Type Alias: searchMappingRulesForTenantConsistency


```ts
type searchMappingRulesForTenantConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.searchMappingRulesForTenant>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchMappingRulesForTenantInput


```ts
type searchMappingRulesForTenantInput = searchMappingRulesForTenantBody &
  object;
```

## Type Declaration

### tenantId

```ts
tenantId: searchMappingRulesForTenantPathParam_tenantId;
```

---

## Type Alias: searchMessageSubscriptionsConsistency


```ts
type searchMessageSubscriptionsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchMessageSubscriptions>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchMessageSubscriptionsInput


```ts
type searchMessageSubscriptionsInput = searchMessageSubscriptionsBody;
```

---

## Type Alias: searchProcessDefinitionsConsistency


```ts
type searchProcessDefinitionsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchProcessDefinitions>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchProcessDefinitionsInput


```ts
type searchProcessDefinitionsInput = searchProcessDefinitionsBody;
```

---

## Type Alias: searchProcessInstanceIncidentsConsistency


```ts
type searchProcessInstanceIncidentsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.searchProcessInstanceIncidents>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchProcessInstanceIncidentsInput


```ts
type searchProcessInstanceIncidentsInput = searchProcessInstanceIncidentsBody &
  object;
```

## Type Declaration

### processInstanceKey

```ts
processInstanceKey: searchProcessInstanceIncidentsPathParam_processInstanceKey;
```

---

## Type Alias: searchProcessInstancesConsistency


```ts
type searchProcessInstancesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchProcessInstances>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchProcessInstancesInput


```ts
type searchProcessInstancesInput = searchProcessInstancesBody;
```

---

## Type Alias: searchResourcesConsistency


```ts
type searchResourcesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchResources>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchResourcesInput


```ts
type searchResourcesInput = searchResourcesBody;
```

---

## Type Alias: searchRolesConsistency


```ts
type searchRolesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchRoles>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchRolesForGroupConsistency


```ts
type searchRolesForGroupConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchRolesForGroup>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchRolesForGroupInput


```ts
type searchRolesForGroupInput = searchRolesForGroupBody & object;
```

## Type Declaration

### groupId

```ts
groupId: searchRolesForGroupPathParam_groupId;
```

---

## Type Alias: searchRolesForTenantConsistency


```ts
type searchRolesForTenantConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchRolesForTenant>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchRolesForTenantInput


```ts
type searchRolesForTenantInput = searchRolesForTenantBody & object;
```

## Type Declaration

### tenantId

```ts
tenantId: searchRolesForTenantPathParam_tenantId;
```

---

## Type Alias: searchRolesInput


```ts
type searchRolesInput = searchRolesBody;
```

---

## Type Alias: searchTenantsConsistency


```ts
type searchTenantsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchTenants>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchTenantsInput


```ts
type searchTenantsInput = searchTenantsBody;
```

---

## Type Alias: searchUserTaskAuditLogsConsistency


```ts
type searchUserTaskAuditLogsConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUserTaskAuditLogs>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUserTaskAuditLogsInput


```ts
type searchUserTaskAuditLogsInput = searchUserTaskAuditLogsBody & object;
```

## Type Declaration

### userTaskKey

```ts
userTaskKey: searchUserTaskAuditLogsPathParam_userTaskKey;
```

---

## Type Alias: searchUserTaskEffectiveVariablesConsistency


```ts
type searchUserTaskEffectiveVariablesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<
  _DataOf<typeof Sdk.searchUserTaskEffectiveVariables>
>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUserTaskEffectiveVariablesInput


```ts
type searchUserTaskEffectiveVariablesInput =
  searchUserTaskEffectiveVariablesBody & object;
```

## Type Declaration

### truncateValues?

```ts
optional truncateValues?: searchUserTaskEffectiveVariablesQueryParam_truncateValues;
```

### userTaskKey

```ts
userTaskKey: searchUserTaskEffectiveVariablesPathParam_userTaskKey;
```

---

## Type Alias: searchUserTaskVariablesConsistency


```ts
type searchUserTaskVariablesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUserTaskVariables>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUserTaskVariablesInput


```ts
type searchUserTaskVariablesInput = searchUserTaskVariablesBody & object;
```

## Type Declaration

### truncateValues?

```ts
optional truncateValues?: searchUserTaskVariablesQueryParam_truncateValues;
```

### userTaskKey

```ts
userTaskKey: searchUserTaskVariablesPathParam_userTaskKey;
```

---

## Type Alias: searchUserTasksConsistency


```ts
type searchUserTasksConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUserTasks>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUserTasksInput


```ts
type searchUserTasksInput = searchUserTasksBody;
```

---

## Type Alias: searchUsersConsistency


```ts
type searchUsersConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUsers>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUsersForGroupConsistency


```ts
type searchUsersForGroupConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUsersForGroup>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUsersForGroupInput


```ts
type searchUsersForGroupInput = searchUsersForGroupBody & object;
```

## Type Declaration

### groupId

```ts
groupId: searchUsersForGroupPathParam_groupId;
```

---

## Type Alias: searchUsersForRoleConsistency


```ts
type searchUsersForRoleConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUsersForRole>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUsersForRoleInput


```ts
type searchUsersForRoleInput = searchUsersForRoleBody & object;
```

## Type Declaration

### roleId

```ts
roleId: searchUsersForRolePathParam_roleId;
```

---

## Type Alias: searchUsersForTenantConsistency


```ts
type searchUsersForTenantConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchUsersForTenant>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchUsersForTenantInput


```ts
type searchUsersForTenantInput = searchUsersForTenantBody & object;
```

## Type Declaration

### tenantId

```ts
tenantId: searchUsersForTenantPathParam_tenantId;
```

---

## Type Alias: searchUsersInput


```ts
type searchUsersInput = searchUsersBody;
```

---

## Type Alias: searchVariablesConsistency


```ts
type searchVariablesConsistency = object;
```

Management of eventual consistency *

## Properties

### consistency

```ts
consistency: ConsistencyOptions<_DataOf<typeof Sdk.searchVariables>>;
```

Management of eventual consistency tolerance. Set waitUpToMs to 0 to ignore eventual consistency. pollInterval is 500ms by default.

---

## Type Alias: searchVariablesInput


```ts
type searchVariablesInput = searchVariablesBody & object;
```

## Type Declaration

### truncateValues?

```ts
optional truncateValues?: searchVariablesQueryParam_truncateValues;
```

---

## Type Alias: suspendBatchOperationInput


```ts
type suspendBatchOperationInput = suspendBatchOperationBody & object;
```

## Type Declaration

### batchOperationKey

```ts
batchOperationKey: suspendBatchOperationPathParam_batchOperationKey;
```

---

## Type Alias: throwJobErrorInput


```ts
type throwJobErrorInput = throwJobErrorBody & object;
```

## Type Declaration

### jobKey

```ts
jobKey: throwJobErrorPathParam_jobKey;
```

---

## Type Alias: unassignClientFromGroupInput


```ts
type unassignClientFromGroupInput = object;
```

## Properties

### clientId

```ts
clientId: unassignClientFromGroupPathParam_clientId;
```

---

### groupId

```ts
groupId: unassignClientFromGroupPathParam_groupId;
```

---

## Type Alias: unassignClientFromTenantInput


```ts
type unassignClientFromTenantInput = object;
```

## Properties

### clientId

```ts
clientId: unassignClientFromTenantPathParam_clientId;
```

---

### tenantId

```ts
tenantId: unassignClientFromTenantPathParam_tenantId;
```

---

## Type Alias: unassignGroupFromTenantInput


```ts
type unassignGroupFromTenantInput = object;
```

## Properties

### groupId

```ts
groupId: unassignGroupFromTenantPathParam_groupId;
```

---

### tenantId

```ts
tenantId: unassignGroupFromTenantPathParam_tenantId;
```

---

## Type Alias: unassignMappingRuleFromGroupInput


```ts
type unassignMappingRuleFromGroupInput = object;
```

## Properties

### groupId

```ts
groupId: unassignMappingRuleFromGroupPathParam_groupId;
```

---

### mappingRuleId

```ts
mappingRuleId: unassignMappingRuleFromGroupPathParam_mappingRuleId;
```

---

## Type Alias: unassignMappingRuleFromTenantInput


```ts
type unassignMappingRuleFromTenantInput = object;
```

## Properties

### mappingRuleId

```ts
mappingRuleId: unassignMappingRuleFromTenantPathParam_mappingRuleId;
```

---

### tenantId

```ts
tenantId: unassignMappingRuleFromTenantPathParam_tenantId;
```

---

## Type Alias: unassignRoleFromClientInput


```ts
type unassignRoleFromClientInput = object;
```

## Properties

### clientId

```ts
clientId: unassignRoleFromClientPathParam_clientId;
```

---

### roleId

```ts
roleId: unassignRoleFromClientPathParam_roleId;
```

---

## Type Alias: unassignRoleFromGroupInput


```ts
type unassignRoleFromGroupInput = object;
```

## Properties

### groupId

```ts
groupId: unassignRoleFromGroupPathParam_groupId;
```

---

### roleId

```ts
roleId: unassignRoleFromGroupPathParam_roleId;
```

---

## Type Alias: unassignRoleFromMappingRuleInput


```ts
type unassignRoleFromMappingRuleInput = object;
```

## Properties

### mappingRuleId

```ts
mappingRuleId: unassignRoleFromMappingRulePathParam_mappingRuleId;
```

---

### roleId

```ts
roleId: unassignRoleFromMappingRulePathParam_roleId;
```

---

## Type Alias: unassignRoleFromTenantInput


```ts
type unassignRoleFromTenantInput = object;
```

## Properties

### roleId

```ts
roleId: unassignRoleFromTenantPathParam_roleId;
```

---

### tenantId

```ts
tenantId: unassignRoleFromTenantPathParam_tenantId;
```

---

## Type Alias: unassignRoleFromUserInput


```ts
type unassignRoleFromUserInput = object;
```

## Properties

### roleId

```ts
roleId: unassignRoleFromUserPathParam_roleId;
```

---

### username

```ts
username: unassignRoleFromUserPathParam_username;
```

---

## Type Alias: unassignUserFromGroupInput


```ts
type unassignUserFromGroupInput = object;
```

## Properties

### groupId

```ts
groupId: unassignUserFromGroupPathParam_groupId;
```

---

### username

```ts
username: unassignUserFromGroupPathParam_username;
```

---

## Type Alias: unassignUserFromTenantInput


```ts
type unassignUserFromTenantInput = object;
```

## Properties

### tenantId

```ts
tenantId: unassignUserFromTenantPathParam_tenantId;
```

---

### username

```ts
username: unassignUserFromTenantPathParam_username;
```

---

## Type Alias: unassignUserTaskInput


```ts
type unassignUserTaskInput = object;
```

## Properties

### userTaskKey

```ts
userTaskKey: unassignUserTaskPathParam_userTaskKey;
```

---

## Type Alias: updateAgentInstanceInput


```ts
type updateAgentInstanceInput = updateAgentInstanceBody & object;
```

## Type Declaration

### agentInstanceKey

```ts
agentInstanceKey: updateAgentInstancePathParam_agentInstanceKey;
```

---

## Type Alias: updateAuthorizationInput


```ts
type updateAuthorizationInput = updateAuthorizationBody & object;
```

## Type Declaration

### authorizationKey

```ts
authorizationKey: updateAuthorizationPathParam_authorizationKey;
```

---

## Type Alias: updateGlobalClusterVariableInput


```ts
type updateGlobalClusterVariableInput = updateGlobalClusterVariableBody &
  object;
```

## Type Declaration

### name

```ts
name: updateGlobalClusterVariablePathParam_name;
```

---

## Type Alias: updateGlobalTaskListenerInput


```ts
type updateGlobalTaskListenerInput = updateGlobalTaskListenerBody & object;
```

## Type Declaration

### id

```ts
id: updateGlobalTaskListenerPathParam_id;
```

---

## Type Alias: updateGroupInput


```ts
type updateGroupInput = updateGroupBody & object;
```

## Type Declaration

### groupId

```ts
groupId: updateGroupPathParam_groupId;
```

---

## Type Alias: updateJobInput


```ts
type updateJobInput = updateJobBody & object;
```

## Type Declaration

### jobKey

```ts
jobKey: updateJobPathParam_jobKey;
```

---

## Type Alias: updateJobsBatchOperationInput


```ts
type updateJobsBatchOperationInput = updateJobsBatchOperationBody;
```

---

## Type Alias: updateMappingRuleInput


```ts
type updateMappingRuleInput = updateMappingRuleBody & object;
```

## Type Declaration

### mappingRuleId

```ts
mappingRuleId: updateMappingRulePathParam_mappingRuleId;
```

---

## Type Alias: updateRoleInput


```ts
type updateRoleInput = updateRoleBody & object;
```

## Type Declaration

### roleId

```ts
roleId: updateRolePathParam_roleId;
```

---

## Type Alias: updateTenantClusterVariableInput


```ts
type updateTenantClusterVariableInput = updateTenantClusterVariableBody &
  object;
```

## Type Declaration

### name

```ts
name: updateTenantClusterVariablePathParam_name;
```

### tenantId

```ts
tenantId: updateTenantClusterVariablePathParam_tenantId;
```

---

## Type Alias: updateTenantInput


```ts
type updateTenantInput = updateTenantBody & object;
```

## Type Declaration

### tenantId

```ts
tenantId: updateTenantPathParam_tenantId;
```

---

## Type Alias: updateUserInput


```ts
type updateUserInput = updateUserBody & object;
```

## Type Declaration

### username

```ts
username: updateUserPathParam_username;
```

---

## Type Alias: updateUserTaskInput


```ts
type updateUserTaskInput = updateUserTaskBody & object;
```

## Type Declaration

### userTaskKey

```ts
userTaskKey: updateUserTaskPathParam_userTaskKey;
```

---

## Variable: AgentInstanceHistoryCommitStatusEnum


```ts
const AgentInstanceHistoryCommitStatusEnum: object;
```

The commit status of a history item.
COMMITTED: the producing job completed successfully.
PENDING: the producing job is still active (in-flight).
DISCARDED: the producing job failed; this item was superseded by a later activation.

## Type Declaration

### COMMITTED

```ts
readonly COMMITTED: "COMMITTED" = 'COMMITTED';
```

### DISCARDED

```ts
readonly DISCARDED: "DISCARDED" = 'DISCARDED';
```

### PENDING

```ts
readonly PENDING: "PENDING" = 'PENDING';
```

---

## Variable: AgentInstanceHistoryRoleEnum


```ts
const AgentInstanceHistoryRoleEnum: object;
```

The role of a history item in the agent conversation.

## Type Declaration

### ASSISTANT

```ts
readonly ASSISTANT: "ASSISTANT" = 'ASSISTANT';
```

### TOOL\_RESULT

```ts
readonly TOOL_RESULT: "TOOL_RESULT" = 'TOOL_RESULT';
```

### USER

```ts
readonly USER: "USER" = 'USER';
```

---

## Variable: AgentInstanceMessageContentTypeEnum


```ts
const AgentInstanceMessageContentTypeEnum: object;
```

The content type discriminator for a history item content block.

## Type Declaration

### DOCUMENT

```ts
readonly DOCUMENT: "DOCUMENT" = 'DOCUMENT';
```

### OBJECT

```ts
readonly OBJECT: "OBJECT" = 'OBJECT';
```

### TEXT

```ts
readonly TEXT: "TEXT" = 'TEXT';
```

---

## Variable: AgentInstanceStatusEnum


```ts
const AgentInstanceStatusEnum: object;
```

The current status of an agent instance.

## Type Declaration

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### IDLE

```ts
readonly IDLE: "IDLE" = 'IDLE';
```

### INITIALIZING

```ts
readonly INITIALIZING: "INITIALIZING" = 'INITIALIZING';
```

### THINKING

```ts
readonly THINKING: "THINKING" = 'THINKING';
```

### TOOL\_CALLING

```ts
readonly TOOL_CALLING: "TOOL_CALLING" = 'TOOL_CALLING';
```

### TOOL\_DISCOVERY

```ts
readonly TOOL_DISCOVERY: "TOOL_DISCOVERY" = 'TOOL_DISCOVERY';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

---

## Variable: AgentInstanceUpdateStatusEnum


```ts
const AgentInstanceUpdateStatusEnum: object;
```

The status values that can be set on an agent instance via an update request.

## Type Declaration

### IDLE

```ts
readonly IDLE: "IDLE" = 'IDLE';
```

### THINKING

```ts
readonly THINKING: "THINKING" = 'THINKING';
```

### TOOL\_CALLING

```ts
readonly TOOL_CALLING: "TOOL_CALLING" = 'TOOL_CALLING';
```

### TOOL\_DISCOVERY

```ts
readonly TOOL_DISCOVERY: "TOOL_DISCOVERY" = 'TOOL_DISCOVERY';
```

---

## Variable: AuditLogActorTypeEnum


```ts
const AuditLogActorTypeEnum: object;
```

The type of actor who performed the operation.

## Type Declaration

### ANONYMOUS

```ts
readonly ANONYMOUS: "ANONYMOUS" = 'ANONYMOUS';
```

### CLIENT

```ts
readonly CLIENT: "CLIENT" = 'CLIENT';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

### USER

```ts
readonly USER: "USER" = 'USER';
```

---

## Variable: AuditLogCategoryEnum


```ts
const AuditLogCategoryEnum: object;
```

The category of the audit log operation.

## Type Declaration

### ADMIN

```ts
readonly ADMIN: "ADMIN" = 'ADMIN';
```

### DEPLOYED\_RESOURCES

```ts
readonly DEPLOYED_RESOURCES: "DEPLOYED_RESOURCES" = 'DEPLOYED_RESOURCES';
```

### USER\_TASKS

```ts
readonly USER_TASKS: "USER_TASKS" = 'USER_TASKS';
```

---

## Variable: AuditLogEntityTypeEnum


```ts
const AuditLogEntityTypeEnum: object;
```

The type of entity affected by the operation.

## Type Declaration

### AUTHORIZATION

```ts
readonly AUTHORIZATION: "AUTHORIZATION" = 'AUTHORIZATION';
```

### BATCH

```ts
readonly BATCH: "BATCH" = 'BATCH';
```

### CLIENT

```ts
readonly CLIENT: "CLIENT" = 'CLIENT';
```

### DECISION

```ts
readonly DECISION: "DECISION" = 'DECISION';
```

### GROUP

```ts
readonly GROUP: "GROUP" = 'GROUP';
```

### INCIDENT

```ts
readonly INCIDENT: "INCIDENT" = 'INCIDENT';
```

### JOB

```ts
readonly JOB: "JOB" = 'JOB';
```

### MAPPING\_RULE

```ts
readonly MAPPING_RULE: "MAPPING_RULE" = 'MAPPING_RULE';
```

### PROCESS\_INSTANCE

```ts
readonly PROCESS_INSTANCE: "PROCESS_INSTANCE" = 'PROCESS_INSTANCE';
```

### RESOURCE

```ts
readonly RESOURCE: "RESOURCE" = 'RESOURCE';
```

### ROLE

```ts
readonly ROLE: "ROLE" = 'ROLE';
```

### TENANT

```ts
readonly TENANT: "TENANT" = 'TENANT';
```

### USER

```ts
readonly USER: "USER" = 'USER';
```

### USER\_TASK

```ts
readonly USER_TASK: "USER_TASK" = 'USER_TASK';
```

### VARIABLE

```ts
readonly VARIABLE: "VARIABLE" = 'VARIABLE';
```

---

## Variable: AuditLogOperationTypeEnum


```ts
const AuditLogOperationTypeEnum: object;
```

The type of operation performed.

## Type Declaration

### ASSIGN

```ts
readonly ASSIGN: "ASSIGN" = 'ASSIGN';
```

### CANCEL

```ts
readonly CANCEL: "CANCEL" = 'CANCEL';
```

### COMPLETE

```ts
readonly COMPLETE: "COMPLETE" = 'COMPLETE';
```

### CREATE

```ts
readonly CREATE: "CREATE" = 'CREATE';
```

### DELETE

```ts
readonly DELETE: "DELETE" = 'DELETE';
```

### EVALUATE

```ts
readonly EVALUATE: "EVALUATE" = 'EVALUATE';
```

### MIGRATE

```ts
readonly MIGRATE: "MIGRATE" = 'MIGRATE';
```

### MODIFY

```ts
readonly MODIFY: "MODIFY" = 'MODIFY';
```

### RESOLVE

```ts
readonly RESOLVE: "RESOLVE" = 'RESOLVE';
```

### RESUME

```ts
readonly RESUME: "RESUME" = 'RESUME';
```

### SUSPEND

```ts
readonly SUSPEND: "SUSPEND" = 'SUSPEND';
```

### UNASSIGN

```ts
readonly UNASSIGN: "UNASSIGN" = 'UNASSIGN';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

### UPDATE

```ts
readonly UPDATE: "UPDATE" = 'UPDATE';
```

---

## Variable: AuditLogResultEnum


```ts
const AuditLogResultEnum: object;
```

The result status of the operation.

## Type Declaration

### FAIL

```ts
readonly FAIL: "FAIL" = 'FAIL';
```

### SUCCESS

```ts
readonly SUCCESS: "SUCCESS" = 'SUCCESS';
```

---

## Variable: BatchOperationItemStateEnum


```ts
const BatchOperationItemStateEnum: object;
```

The batch operation item state.

## Type Declaration

### ACTIVE

```ts
readonly ACTIVE: "ACTIVE" = 'ACTIVE';
```

### CANCELED

```ts
readonly CANCELED: "CANCELED" = 'CANCELED';
```

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### FAILED

```ts
readonly FAILED: "FAILED" = 'FAILED';
```

---

## Variable: BatchOperationStateEnum


```ts
const BatchOperationStateEnum: object;
```

The batch operation state.

## Type Declaration

### ACTIVE

```ts
readonly ACTIVE: "ACTIVE" = 'ACTIVE';
```

### CANCELED

```ts
readonly CANCELED: "CANCELED" = 'CANCELED';
```

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### CREATED

```ts
readonly CREATED: "CREATED" = 'CREATED';
```

### FAILED

```ts
readonly FAILED: "FAILED" = 'FAILED';
```

### PARTIALLY\_COMPLETED

```ts
readonly PARTIALLY_COMPLETED: "PARTIALLY_COMPLETED" = 'PARTIALLY_COMPLETED';
```

### SUSPENDED

```ts
readonly SUSPENDED: "SUSPENDED" = 'SUSPENDED';
```

---

## Variable: BatchOperationTypeEnum


```ts
const BatchOperationTypeEnum: object;
```

The type of the batch operation.

## Type Declaration

### ADD\_VARIABLE

```ts
readonly ADD_VARIABLE: "ADD_VARIABLE" = 'ADD_VARIABLE';
```

### CANCEL\_PROCESS\_INSTANCE

```ts
readonly CANCEL_PROCESS_INSTANCE: "CANCEL_PROCESS_INSTANCE" = 'CANCEL_PROCESS_INSTANCE';
```

### DELETE\_DECISION\_DEFINITION

```ts
readonly DELETE_DECISION_DEFINITION: "DELETE_DECISION_DEFINITION" = 'DELETE_DECISION_DEFINITION';
```

### DELETE\_DECISION\_INSTANCE

```ts
readonly DELETE_DECISION_INSTANCE: "DELETE_DECISION_INSTANCE" = 'DELETE_DECISION_INSTANCE';
```

### DELETE\_PROCESS\_DEFINITION

```ts
readonly DELETE_PROCESS_DEFINITION: "DELETE_PROCESS_DEFINITION" = 'DELETE_PROCESS_DEFINITION';
```

### DELETE\_PROCESS\_INSTANCE

```ts
readonly DELETE_PROCESS_INSTANCE: "DELETE_PROCESS_INSTANCE" = 'DELETE_PROCESS_INSTANCE';
```

### MIGRATE\_PROCESS\_INSTANCE

```ts
readonly MIGRATE_PROCESS_INSTANCE: "MIGRATE_PROCESS_INSTANCE" = 'MIGRATE_PROCESS_INSTANCE';
```

### MODIFY\_PROCESS\_INSTANCE

```ts
readonly MODIFY_PROCESS_INSTANCE: "MODIFY_PROCESS_INSTANCE" = 'MODIFY_PROCESS_INSTANCE';
```

### RESOLVE\_INCIDENT

```ts
readonly RESOLVE_INCIDENT: "RESOLVE_INCIDENT" = 'RESOLVE_INCIDENT';
```

### UPDATE\_JOB

```ts
readonly UPDATE_JOB: "UPDATE_JOB" = 'UPDATE_JOB';
```

### UPDATE\_VARIABLE

```ts
readonly UPDATE_VARIABLE: "UPDATE_VARIABLE" = 'UPDATE_VARIABLE';
```

---

## Variable: ClusterVariableScopeEnum


```ts
const ClusterVariableScopeEnum: object;
```

The scope of a cluster variable.

## Type Declaration

### GLOBAL

```ts
readonly GLOBAL: "GLOBAL" = 'GLOBAL';
```

### TENANT

```ts
readonly TENANT: "TENANT" = 'TENANT';
```

---

## Variable: DecisionDefinitionTypeEnum


```ts
const DecisionDefinitionTypeEnum: object;
```

The type of the decision. UNSPECIFIED is deprecated and should not be used anymore, for removal in 8.10

## Type Declaration

### DECISION\_TABLE

```ts
readonly DECISION_TABLE: "DECISION_TABLE" = 'DECISION_TABLE';
```

### LITERAL\_EXPRESSION

```ts
readonly LITERAL_EXPRESSION: "LITERAL_EXPRESSION" = 'LITERAL_EXPRESSION';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

### ~~UNSPECIFIED~~

```ts
readonly UNSPECIFIED: "UNSPECIFIED" = 'UNSPECIFIED';
```

#### Deprecated

since 8.9.0

---

## Variable: DecisionInstanceStateEnum


```ts
const DecisionInstanceStateEnum: object;
```

The state of the decision instance. UNSPECIFIED and UNKNOWN are deprecated and should not be used anymore, for removal in 8.10

## Type Declaration

### EVALUATED

```ts
readonly EVALUATED: "EVALUATED" = 'EVALUATED';
```

### FAILED

```ts
readonly FAILED: "FAILED" = 'FAILED';
```

### ~~UNKNOWN~~

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

#### Deprecated

since 8.9.0

### ~~UNSPECIFIED~~

```ts
readonly UNSPECIFIED: "UNSPECIFIED" = 'UNSPECIFIED';
```

#### Deprecated

since 8.9.0

---

## Variable: ElementInstanceStateEnum


```ts
const ElementInstanceStateEnum: object;
```

Element states

## Type Declaration

### ACTIVE

```ts
readonly ACTIVE: "ACTIVE" = 'ACTIVE';
```

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### TERMINATED

```ts
readonly TERMINATED: "TERMINATED" = 'TERMINATED';
```

---

## Variable: GlobalListenerSourceEnum


```ts
const GlobalListenerSourceEnum: object;
```

How the global listener was defined.

## Type Declaration

### API

```ts
readonly API: "API" = 'API';
```

### CONFIGURATION

```ts
readonly CONFIGURATION: "CONFIGURATION" = 'CONFIGURATION';
```

---

## Variable: GlobalTaskListenerEventTypeEnum


```ts
const GlobalTaskListenerEventTypeEnum: object;
```

The event type that triggers the user task listener.

## Type Declaration

### all

```ts
readonly all: "all" = 'all';
```

### assigning

```ts
readonly assigning: "assigning" = 'assigning';
```

### canceling

```ts
readonly canceling: "canceling" = 'canceling';
```

### completing

```ts
readonly completing: "completing" = 'completing';
```

### creating

```ts
readonly creating: "creating" = 'creating';
```

### updating

```ts
readonly updating: "updating" = 'updating';
```

---

## Variable: IncidentErrorTypeEnum


```ts
const IncidentErrorTypeEnum: object;
```

Incident error type with a defined set of values.

## Type Declaration

### AD\_HOC\_SUB\_PROCESS\_NO\_RETRIES

```ts
readonly AD_HOC_SUB_PROCESS_NO_RETRIES: "AD_HOC_SUB_PROCESS_NO_RETRIES" = 'AD_HOC_SUB_PROCESS_NO_RETRIES';
```

### CALLED\_DECISION\_ERROR

```ts
readonly CALLED_DECISION_ERROR: "CALLED_DECISION_ERROR" = 'CALLED_DECISION_ERROR';
```

### CALLED\_ELEMENT\_ERROR

```ts
readonly CALLED_ELEMENT_ERROR: "CALLED_ELEMENT_ERROR" = 'CALLED_ELEMENT_ERROR';
```

### CONDITION\_ERROR

```ts
readonly CONDITION_ERROR: "CONDITION_ERROR" = 'CONDITION_ERROR';
```

### DECISION\_EVALUATION\_ERROR

```ts
readonly DECISION_EVALUATION_ERROR: "DECISION_EVALUATION_ERROR" = 'DECISION_EVALUATION_ERROR';
```

### EXECUTION\_LISTENER\_NO\_RETRIES

```ts
readonly EXECUTION_LISTENER_NO_RETRIES: "EXECUTION_LISTENER_NO_RETRIES" = 'EXECUTION_LISTENER_NO_RETRIES';
```

### EXTRACT\_VALUE\_ERROR

```ts
readonly EXTRACT_VALUE_ERROR: "EXTRACT_VALUE_ERROR" = 'EXTRACT_VALUE_ERROR';
```

### FORM\_NOT\_FOUND

```ts
readonly FORM_NOT_FOUND: "FORM_NOT_FOUND" = 'FORM_NOT_FOUND';
```

### IO\_MAPPING\_ERROR

```ts
readonly IO_MAPPING_ERROR: "IO_MAPPING_ERROR" = 'IO_MAPPING_ERROR';
```

### JOB\_NO\_RETRIES

```ts
readonly JOB_NO_RETRIES: "JOB_NO_RETRIES" = 'JOB_NO_RETRIES';
```

### MESSAGE\_SIZE\_EXCEEDED

```ts
readonly MESSAGE_SIZE_EXCEEDED: "MESSAGE_SIZE_EXCEEDED" = 'MESSAGE_SIZE_EXCEEDED';
```

### RESOURCE\_NOT\_FOUND

```ts
readonly RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND" = 'RESOURCE_NOT_FOUND';
```

### TASK\_LISTENER\_NO\_RETRIES

```ts
readonly TASK_LISTENER_NO_RETRIES: "TASK_LISTENER_NO_RETRIES" = 'TASK_LISTENER_NO_RETRIES';
```

### UNHANDLED\_ERROR\_EVENT

```ts
readonly UNHANDLED_ERROR_EVENT: "UNHANDLED_ERROR_EVENT" = 'UNHANDLED_ERROR_EVENT';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

### UNSPECIFIED

```ts
readonly UNSPECIFIED: "UNSPECIFIED" = 'UNSPECIFIED';
```

---

## Variable: IncidentStateEnum


```ts
const IncidentStateEnum: object;
```

Incident states with a defined set of values.

## Type Declaration

### ACTIVE

```ts
readonly ACTIVE: "ACTIVE" = 'ACTIVE';
```

### MIGRATED

```ts
readonly MIGRATED: "MIGRATED" = 'MIGRATED';
```

### PENDING

```ts
readonly PENDING: "PENDING" = 'PENDING';
```

### RESOLVED

```ts
readonly RESOLVED: "RESOLVED" = 'RESOLVED';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

---

## Variable: JobKindEnum


```ts
const JobKindEnum: object;
```

The job kind.

## Type Declaration

### AD\_HOC\_SUB\_PROCESS

```ts
readonly AD_HOC_SUB_PROCESS: "AD_HOC_SUB_PROCESS" = 'AD_HOC_SUB_PROCESS';
```

### BPMN\_ELEMENT

```ts
readonly BPMN_ELEMENT: "BPMN_ELEMENT" = 'BPMN_ELEMENT';
```

### EXECUTION\_LISTENER

```ts
readonly EXECUTION_LISTENER: "EXECUTION_LISTENER" = 'EXECUTION_LISTENER';
```

### TASK\_LISTENER

```ts
readonly TASK_LISTENER: "TASK_LISTENER" = 'TASK_LISTENER';
```

---

## Variable: JobListenerEventTypeEnum


```ts
const JobListenerEventTypeEnum: object;
```

The listener event type of the job.

## Type Declaration

### ASSIGNING

```ts
readonly ASSIGNING: "ASSIGNING" = 'ASSIGNING';
```

### BEFORE\_ALL

```ts
readonly BEFORE_ALL: "BEFORE_ALL" = 'BEFORE_ALL';
```

### CANCEL

```ts
readonly CANCEL: "CANCEL" = 'CANCEL';
```

### CANCELING

```ts
readonly CANCELING: "CANCELING" = 'CANCELING';
```

### COMPLETING

```ts
readonly COMPLETING: "COMPLETING" = 'COMPLETING';
```

### CREATING

```ts
readonly CREATING: "CREATING" = 'CREATING';
```

### END

```ts
readonly END: "END" = 'END';
```

### START

```ts
readonly START: "START" = 'START';
```

### UNSPECIFIED

```ts
readonly UNSPECIFIED: "UNSPECIFIED" = 'UNSPECIFIED';
```

### UPDATING

```ts
readonly UPDATING: "UPDATING" = 'UPDATING';
```

---

## Variable: JobStateEnum


```ts
const JobStateEnum: object;
```

The state of the job.

## Type Declaration

### CANCELED

```ts
readonly CANCELED: "CANCELED" = 'CANCELED';
```

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### CREATED

```ts
readonly CREATED: "CREATED" = 'CREATED';
```

### ERROR\_THROWN

```ts
readonly ERROR_THROWN: "ERROR_THROWN" = 'ERROR_THROWN';
```

### FAILED

```ts
readonly FAILED: "FAILED" = 'FAILED';
```

### MIGRATED

```ts
readonly MIGRATED: "MIGRATED" = 'MIGRATED';
```

### PRIORITY\_UPDATED

```ts
readonly PRIORITY_UPDATED: "PRIORITY_UPDATED" = 'PRIORITY_UPDATED';
```

### RETRIES\_UPDATED

```ts
readonly RETRIES_UPDATED: "RETRIES_UPDATED" = 'RETRIES_UPDATED';
```

### TIMED\_OUT

```ts
readonly TIMED_OUT: "TIMED_OUT" = 'TIMED_OUT';
```

---

## Variable: MessageSubscriptionStateEnum


```ts
const MessageSubscriptionStateEnum: object;
```

The state of message subscription.

**Note for `START_EVENT` subscriptions:** The `CORRELATED` and `MIGRATED` states are not
tracked for these subscriptions. To query correlation history for process start events,
use the `/correlated-message-subscriptions/search` endpoint.

## Type Declaration

### CORRELATED

```ts
readonly CORRELATED: "CORRELATED" = 'CORRELATED';
```

### CREATED

```ts
readonly CREATED: "CREATED" = 'CREATED';
```

### DELETED

```ts
readonly DELETED: "DELETED" = 'DELETED';
```

### MIGRATED

```ts
readonly MIGRATED: "MIGRATED" = 'MIGRATED';
```

---

## Variable: MessageSubscriptionTypeEnum


```ts
const MessageSubscriptionTypeEnum: object;
```

The type of message subscription.
`START_EVENT` is definition-scoped (process start events). Always has a value; only
captured from Camunda 8.10 onwards.
`PROCESS_EVENT` is instance-scoped (intermediate catch events). Pre-8.10 entries have
no value stored; the API returns `PROCESS_EVENT` as a default for those entries.

## Type Declaration

### PROCESS\_EVENT

```ts
readonly PROCESS_EVENT: "PROCESS_EVENT" = 'PROCESS_EVENT';
```

### START\_EVENT

```ts
readonly START_EVENT: "START_EVENT" = 'START_EVENT';
```

---

## Variable: OwnerTypeEnum


```ts
const OwnerTypeEnum: object;
```

The type of the owner of permissions.

## Type Declaration

### CLIENT

```ts
readonly CLIENT: "CLIENT" = 'CLIENT';
```

### GROUP

```ts
readonly GROUP: "GROUP" = 'GROUP';
```

### MAPPING\_RULE

```ts
readonly MAPPING_RULE: "MAPPING_RULE" = 'MAPPING_RULE';
```

### ROLE

```ts
readonly ROLE: "ROLE" = 'ROLE';
```

### UNSPECIFIED

```ts
readonly UNSPECIFIED: "UNSPECIFIED" = 'UNSPECIFIED';
```

### USER

```ts
readonly USER: "USER" = 'USER';
```

---

## Variable: PermissionTypeEnum


```ts
const PermissionTypeEnum: object;
```

Specifies the type of permissions.

## Type Declaration

### ACCESS

```ts
readonly ACCESS: "ACCESS" = 'ACCESS';
```

### CANCEL\_PROCESS\_INSTANCE

```ts
readonly CANCEL_PROCESS_INSTANCE: "CANCEL_PROCESS_INSTANCE" = 'CANCEL_PROCESS_INSTANCE';
```

### CLAIM

```ts
readonly CLAIM: "CLAIM" = 'CLAIM';
```

### CLAIM\_USER\_TASK

```ts
readonly CLAIM_USER_TASK: "CLAIM_USER_TASK" = 'CLAIM_USER_TASK';
```

### COMPLETE

```ts
readonly COMPLETE: "COMPLETE" = 'COMPLETE';
```

### COMPLETE\_USER\_TASK

```ts
readonly COMPLETE_USER_TASK: "COMPLETE_USER_TASK" = 'COMPLETE_USER_TASK';
```

### CREATE

```ts
readonly CREATE: "CREATE" = 'CREATE';
```

### CREATE\_BATCH\_OPERATION\_CANCEL\_PROCESS\_INSTANCE

```ts
readonly CREATE_BATCH_OPERATION_CANCEL_PROCESS_INSTANCE: "CREATE_BATCH_OPERATION_CANCEL_PROCESS_INSTANCE" = 'CREATE_BATCH_OPERATION_CANCEL_PROCESS_INSTANCE';
```

### CREATE\_BATCH\_OPERATION\_DELETE\_DECISION\_DEFINITION

```ts
readonly CREATE_BATCH_OPERATION_DELETE_DECISION_DEFINITION: "CREATE_BATCH_OPERATION_DELETE_DECISION_DEFINITION" = 'CREATE_BATCH_OPERATION_DELETE_DECISION_DEFINITION';
```

### CREATE\_BATCH\_OPERATION\_DELETE\_DECISION\_INSTANCE

```ts
readonly CREATE_BATCH_OPERATION_DELETE_DECISION_INSTANCE: "CREATE_BATCH_OPERATION_DELETE_DECISION_INSTANCE" = 'CREATE_BATCH_OPERATION_DELETE_DECISION_INSTANCE';
```

### CREATE\_BATCH\_OPERATION\_DELETE\_PROCESS\_DEFINITION

```ts
readonly CREATE_BATCH_OPERATION_DELETE_PROCESS_DEFINITION: "CREATE_BATCH_OPERATION_DELETE_PROCESS_DEFINITION" = 'CREATE_BATCH_OPERATION_DELETE_PROCESS_DEFINITION';
```

### CREATE\_BATCH\_OPERATION\_DELETE\_PROCESS\_INSTANCE

```ts
readonly CREATE_BATCH_OPERATION_DELETE_PROCESS_INSTANCE: "CREATE_BATCH_OPERATION_DELETE_PROCESS_INSTANCE" = 'CREATE_BATCH_OPERATION_DELETE_PROCESS_INSTANCE';
```

### CREATE\_BATCH\_OPERATION\_MIGRATE\_PROCESS\_INSTANCE

```ts
readonly CREATE_BATCH_OPERATION_MIGRATE_PROCESS_INSTANCE: "CREATE_BATCH_OPERATION_MIGRATE_PROCESS_INSTANCE" = 'CREATE_BATCH_OPERATION_MIGRATE_PROCESS_INSTANCE';
```

### CREATE\_BATCH\_OPERATION\_MODIFY\_PROCESS\_INSTANCE

```ts
readonly CREATE_BATCH_OPERATION_MODIFY_PROCESS_INSTANCE: "CREATE_BATCH_OPERATION_MODIFY_PROCESS_INSTANCE" = 'CREATE_BATCH_OPERATION_MODIFY_PROCESS_INSTANCE';
```

### CREATE\_BATCH\_OPERATION\_RESOLVE\_INCIDENT

```ts
readonly CREATE_BATCH_OPERATION_RESOLVE_INCIDENT: "CREATE_BATCH_OPERATION_RESOLVE_INCIDENT" = 'CREATE_BATCH_OPERATION_RESOLVE_INCIDENT';
```

### CREATE\_BATCH\_OPERATION\_UPDATE\_JOB

```ts
readonly CREATE_BATCH_OPERATION_UPDATE_JOB: "CREATE_BATCH_OPERATION_UPDATE_JOB" = 'CREATE_BATCH_OPERATION_UPDATE_JOB';
```

### CREATE\_DECISION\_INSTANCE

```ts
readonly CREATE_DECISION_INSTANCE: "CREATE_DECISION_INSTANCE" = 'CREATE_DECISION_INSTANCE';
```

### CREATE\_PROCESS\_INSTANCE

```ts
readonly CREATE_PROCESS_INSTANCE: "CREATE_PROCESS_INSTANCE" = 'CREATE_PROCESS_INSTANCE';
```

### CREATE\_TASK\_LISTENER

```ts
readonly CREATE_TASK_LISTENER: "CREATE_TASK_LISTENER" = 'CREATE_TASK_LISTENER';
```

### DELETE

```ts
readonly DELETE: "DELETE" = 'DELETE';
```

### DELETE\_DECISION\_INSTANCE

```ts
readonly DELETE_DECISION_INSTANCE: "DELETE_DECISION_INSTANCE" = 'DELETE_DECISION_INSTANCE';
```

### DELETE\_DRD

```ts
readonly DELETE_DRD: "DELETE_DRD" = 'DELETE_DRD';
```

### DELETE\_FORM

```ts
readonly DELETE_FORM: "DELETE_FORM" = 'DELETE_FORM';
```

### DELETE\_PROCESS

```ts
readonly DELETE_PROCESS: "DELETE_PROCESS" = 'DELETE_PROCESS';
```

### DELETE\_PROCESS\_INSTANCE

```ts
readonly DELETE_PROCESS_INSTANCE: "DELETE_PROCESS_INSTANCE" = 'DELETE_PROCESS_INSTANCE';
```

### DELETE\_RESOURCE

```ts
readonly DELETE_RESOURCE: "DELETE_RESOURCE" = 'DELETE_RESOURCE';
```

### DELETE\_TASK\_LISTENER

```ts
readonly DELETE_TASK_LISTENER: "DELETE_TASK_LISTENER" = 'DELETE_TASK_LISTENER';
```

### EVALUATE

```ts
readonly EVALUATE: "EVALUATE" = 'EVALUATE';
```

### MODIFY\_PROCESS\_INSTANCE

```ts
readonly MODIFY_PROCESS_INSTANCE: "MODIFY_PROCESS_INSTANCE" = 'MODIFY_PROCESS_INSTANCE';
```

### READ

```ts
readonly READ: "READ" = 'READ';
```

### READ\_DECISION\_DEFINITION

```ts
readonly READ_DECISION_DEFINITION: "READ_DECISION_DEFINITION" = 'READ_DECISION_DEFINITION';
```

### READ\_DECISION\_INSTANCE

```ts
readonly READ_DECISION_INSTANCE: "READ_DECISION_INSTANCE" = 'READ_DECISION_INSTANCE';
```

### READ\_JOB\_METRIC

```ts
readonly READ_JOB_METRIC: "READ_JOB_METRIC" = 'READ_JOB_METRIC';
```

### READ\_PROCESS\_DEFINITION

```ts
readonly READ_PROCESS_DEFINITION: "READ_PROCESS_DEFINITION" = 'READ_PROCESS_DEFINITION';
```

### READ\_PROCESS\_INSTANCE

```ts
readonly READ_PROCESS_INSTANCE: "READ_PROCESS_INSTANCE" = 'READ_PROCESS_INSTANCE';
```

### READ\_TASK\_LISTENER

```ts
readonly READ_TASK_LISTENER: "READ_TASK_LISTENER" = 'READ_TASK_LISTENER';
```

### READ\_USAGE\_METRIC

```ts
readonly READ_USAGE_METRIC: "READ_USAGE_METRIC" = 'READ_USAGE_METRIC';
```

### READ\_USER\_TASK

```ts
readonly READ_USER_TASK: "READ_USER_TASK" = 'READ_USER_TASK';
```

### UPDATE

```ts
readonly UPDATE: "UPDATE" = 'UPDATE';
```

### UPDATE\_PROCESS\_INSTANCE

```ts
readonly UPDATE_PROCESS_INSTANCE: "UPDATE_PROCESS_INSTANCE" = 'UPDATE_PROCESS_INSTANCE';
```

### UPDATE\_TASK\_LISTENER

```ts
readonly UPDATE_TASK_LISTENER: "UPDATE_TASK_LISTENER" = 'UPDATE_TASK_LISTENER';
```

### UPDATE\_USER\_TASK

```ts
readonly UPDATE_USER_TASK: "UPDATE_USER_TASK" = 'UPDATE_USER_TASK';
```

---

## Variable: ProcessInstanceStateEnum


```ts
const ProcessInstanceStateEnum: object;
```

Process instance states

## Type Declaration

### ACTIVE

```ts
readonly ACTIVE: "ACTIVE" = 'ACTIVE';
```

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### TERMINATED

```ts
readonly TERMINATED: "TERMINATED" = 'TERMINATED';
```

---

## Variable: ResourceTypeEnum


```ts
const ResourceTypeEnum: object;
```

The type of resource to add/remove permissions to/from.

## Type Declaration

### AUDIT\_LOG

```ts
readonly AUDIT_LOG: "AUDIT_LOG" = 'AUDIT_LOG';
```

### AUTHORIZATION

```ts
readonly AUTHORIZATION: "AUTHORIZATION" = 'AUTHORIZATION';
```

### BATCH

```ts
readonly BATCH: "BATCH" = 'BATCH';
```

### CLUSTER\_VARIABLE

```ts
readonly CLUSTER_VARIABLE: "CLUSTER_VARIABLE" = 'CLUSTER_VARIABLE';
```

### COMPONENT

```ts
readonly COMPONENT: "COMPONENT" = 'COMPONENT';
```

### DECISION\_DEFINITION

```ts
readonly DECISION_DEFINITION: "DECISION_DEFINITION" = 'DECISION_DEFINITION';
```

### DECISION\_REQUIREMENTS\_DEFINITION

```ts
readonly DECISION_REQUIREMENTS_DEFINITION: "DECISION_REQUIREMENTS_DEFINITION" = 'DECISION_REQUIREMENTS_DEFINITION';
```

### DOCUMENT

```ts
readonly DOCUMENT: "DOCUMENT" = 'DOCUMENT';
```

### EXPRESSION

```ts
readonly EXPRESSION: "EXPRESSION" = 'EXPRESSION';
```

### GLOBAL\_LISTENER

```ts
readonly GLOBAL_LISTENER: "GLOBAL_LISTENER" = 'GLOBAL_LISTENER';
```

### GROUP

```ts
readonly GROUP: "GROUP" = 'GROUP';
```

### MAPPING\_RULE

```ts
readonly MAPPING_RULE: "MAPPING_RULE" = 'MAPPING_RULE';
```

### MESSAGE

```ts
readonly MESSAGE: "MESSAGE" = 'MESSAGE';
```

### PROCESS\_DEFINITION

```ts
readonly PROCESS_DEFINITION: "PROCESS_DEFINITION" = 'PROCESS_DEFINITION';
```

### RESOURCE

```ts
readonly RESOURCE: "RESOURCE" = 'RESOURCE';
```

### ROLE

```ts
readonly ROLE: "ROLE" = 'ROLE';
```

### SYSTEM

```ts
readonly SYSTEM: "SYSTEM" = 'SYSTEM';
```

### TENANT

```ts
readonly TENANT: "TENANT" = 'TENANT';
```

### USER

```ts
readonly USER: "USER" = 'USER';
```

### USER\_TASK

```ts
readonly USER_TASK: "USER_TASK" = 'USER_TASK';
```

---

## Variable: SPEC HASH

# Variable: SPEC\_HASH

```ts
const SPEC_HASH: "sha256:73ad42fb782f5c72dd84bdc40ef81313976c3f4083436c18c7019e7e0a3295cc";
```

---

## Variable: SortOrderEnum


```ts
const SortOrderEnum: object;
```

The order in which to sort the related field.

## Type Declaration

### ASC

```ts
readonly ASC: "ASC" = 'ASC';
```

### DESC

```ts
readonly DESC: "DESC" = 'DESC';
```

---

## Variable: TenantFilterEnum


```ts
const TenantFilterEnum: object;
```

The tenant filtering strategy for job activation. Determines whether to use tenant IDs provided in the request or tenant IDs assigned to the authenticated principal.

## Type Declaration

### ASSIGNED

```ts
readonly ASSIGNED: "ASSIGNED" = 'ASSIGNED';
```

### PROVIDED

```ts
readonly PROVIDED: "PROVIDED" = 'PROVIDED';
```

---

## Variable: UserTaskStateEnum


```ts
const UserTaskStateEnum: object;
```

The state of the user task.
Note: FAILED state is only for legacy job-worker-based tasks.

## Type Declaration

### ASSIGNING

```ts
readonly ASSIGNING: "ASSIGNING" = 'ASSIGNING';
```

### CANCELED

```ts
readonly CANCELED: "CANCELED" = 'CANCELED';
```

### CANCELING

```ts
readonly CANCELING: "CANCELING" = 'CANCELING';
```

### COMPLETED

```ts
readonly COMPLETED: "COMPLETED" = 'COMPLETED';
```

### COMPLETING

```ts
readonly COMPLETING: "COMPLETING" = 'COMPLETING';
```

### CREATED

```ts
readonly CREATED: "CREATED" = 'CREATED';
```

### CREATING

```ts
readonly CREATING: "CREATING" = 'CREATING';
```

### FAILED

```ts
readonly FAILED: "FAILED" = 'FAILED';
```

### UPDATING

```ts
readonly UPDATING: "UPDATING" = 'UPDATING';
```

---

## Variable: WaitStateElementTypeEnum


```ts
const WaitStateElementTypeEnum: object;
```

The BPMN element type of a waiting element instance.

## Type Declaration

### AD\_HOC\_SUB\_PROCESS

```ts
readonly AD_HOC_SUB_PROCESS: "AD_HOC_SUB_PROCESS" = 'AD_HOC_SUB_PROCESS';
```

### AD\_HOC\_SUB\_PROCESS\_INNER\_INSTANCE

```ts
readonly AD_HOC_SUB_PROCESS_INNER_INSTANCE: "AD_HOC_SUB_PROCESS_INNER_INSTANCE" = 'AD_HOC_SUB_PROCESS_INNER_INSTANCE';
```

### BOUNDARY\_EVENT

```ts
readonly BOUNDARY_EVENT: "BOUNDARY_EVENT" = 'BOUNDARY_EVENT';
```

### BUSINESS\_RULE\_TASK

```ts
readonly BUSINESS_RULE_TASK: "BUSINESS_RULE_TASK" = 'BUSINESS_RULE_TASK';
```

### CALL\_ACTIVITY

```ts
readonly CALL_ACTIVITY: "CALL_ACTIVITY" = 'CALL_ACTIVITY';
```

### END\_EVENT

```ts
readonly END_EVENT: "END_EVENT" = 'END_EVENT';
```

### EVENT\_BASED\_GATEWAY

```ts
readonly EVENT_BASED_GATEWAY: "EVENT_BASED_GATEWAY" = 'EVENT_BASED_GATEWAY';
```

### EVENT\_SUB\_PROCESS

```ts
readonly EVENT_SUB_PROCESS: "EVENT_SUB_PROCESS" = 'EVENT_SUB_PROCESS';
```

### EXCLUSIVE\_GATEWAY

```ts
readonly EXCLUSIVE_GATEWAY: "EXCLUSIVE_GATEWAY" = 'EXCLUSIVE_GATEWAY';
```

### INCLUSIVE\_GATEWAY

```ts
readonly INCLUSIVE_GATEWAY: "INCLUSIVE_GATEWAY" = 'INCLUSIVE_GATEWAY';
```

### INTERMEDIATE\_CATCH\_EVENT

```ts
readonly INTERMEDIATE_CATCH_EVENT: "INTERMEDIATE_CATCH_EVENT" = 'INTERMEDIATE_CATCH_EVENT';
```

### INTERMEDIATE\_THROW\_EVENT

```ts
readonly INTERMEDIATE_THROW_EVENT: "INTERMEDIATE_THROW_EVENT" = 'INTERMEDIATE_THROW_EVENT';
```

### MANUAL\_TASK

```ts
readonly MANUAL_TASK: "MANUAL_TASK" = 'MANUAL_TASK';
```

### MULTI\_INSTANCE\_BODY

```ts
readonly MULTI_INSTANCE_BODY: "MULTI_INSTANCE_BODY" = 'MULTI_INSTANCE_BODY';
```

### PARALLEL\_GATEWAY

```ts
readonly PARALLEL_GATEWAY: "PARALLEL_GATEWAY" = 'PARALLEL_GATEWAY';
```

### PROCESS

```ts
readonly PROCESS: "PROCESS" = 'PROCESS';
```

### RECEIVE\_TASK

```ts
readonly RECEIVE_TASK: "RECEIVE_TASK" = 'RECEIVE_TASK';
```

### SCRIPT\_TASK

```ts
readonly SCRIPT_TASK: "SCRIPT_TASK" = 'SCRIPT_TASK';
```

### SEND\_TASK

```ts
readonly SEND_TASK: "SEND_TASK" = 'SEND_TASK';
```

### SEQUENCE\_FLOW

```ts
readonly SEQUENCE_FLOW: "SEQUENCE_FLOW" = 'SEQUENCE_FLOW';
```

### SERVICE\_TASK

```ts
readonly SERVICE_TASK: "SERVICE_TASK" = 'SERVICE_TASK';
```

### START\_EVENT

```ts
readonly START_EVENT: "START_EVENT" = 'START_EVENT';
```

### SUB\_PROCESS

```ts
readonly SUB_PROCESS: "SUB_PROCESS" = 'SUB_PROCESS';
```

### TASK

```ts
readonly TASK: "TASK" = 'TASK';
```

### UNKNOWN

```ts
readonly UNKNOWN: "UNKNOWN" = 'UNKNOWN';
```

### UNSPECIFIED

```ts
readonly UNSPECIFIED: "UNSPECIFIED" = 'UNSPECIFIED';
```

### USER\_TASK

```ts
readonly USER_TASK: "USER_TASK" = 'USER_TASK';
```

---

## Variable: WaitStateTypeEnum


```ts
const WaitStateTypeEnum: object;
```

The type of waiting state an element instance is in.

## Type Declaration

### CONDITION

```ts
readonly CONDITION: "CONDITION" = 'CONDITION';
```

### JOB

```ts
readonly JOB: "JOB" = 'JOB';
```

### MESSAGE

```ts
readonly MESSAGE: "MESSAGE" = 'MESSAGE';
```

### SIGNAL

```ts
readonly SIGNAL: "SIGNAL" = 'SIGNAL';
```

### TIMER

```ts
readonly TIMER: "TIMER" = 'TIMER';
```

### USER\_TASK

```ts
readonly USER_TASK: "USER_TASK" = 'USER_TASK';
```

---

## TypeScript SDK API Reference

# Camunda 8 Orchestration Cluster TypeScript SDK

[![npm](https://img.shields.io/npm/v/@camunda8/orchestration-cluster-api)](https://www.npmjs.com/package/@camunda8/orchestration-cluster-api)
[![npm downloads](https://img.shields.io/npm/dw/@camunda8/orchestration-cluster-api)](https://www.npmjs.com/package/@camunda8/orchestration-cluster-api)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/camunda/orchestration-cluster-api-js/blob/main/LICENSE)
[![GitHub release](https://img.shields.io/github/v/release/camunda/orchestration-cluster-api-js)](https://github.com/camunda/orchestration-cluster-api-js/releases)

<!-- WARNING: The content and specific structure of this file drives Docusaurus generation in camunda-docs. Also, code examples are injected during build. Please refer to MAINTAINER.md before editing. -->

Type‑safe, promise‑based client for the Camunda 8 Orchestration Cluster REST API.

## Highlights

- Strong TypeScript models (requests, responses, discriminated unions)
- Branded key types to prevent mixing IDs at compile time
- Optional request/response schema validation (Zod) via a single env variable
- OAuth2 client‑credentials & Basic auth (token cache, early refresh, jittered retry, singleflight)
- Optional mTLS (Node) with inline or \*\_PATH environment variables
- Cancelable promises for all operations
- Eventual consistency helper for polling endpoints
- Immutable, deep‑frozen configuration accessible through a factory‑created client instance
- Automatic body-level tenantId defaulting: if a request body supports an optional tenantId and you omit it, the SDK fills it from CAMUNDA_DEFAULT_TENANT_ID (path params are never auto-filled)
- Automatic transient HTTP retry (429, 503, network) with exponential backoff + full jitter (configurable via CAMUNDA_SDK_HTTP_RETRY\*). Non-retryable 500s fail fast.
- Per-method retry override: disable or customize retry policy on any individual API call without changing global settings

## Install

```bash
npm install @camunda8/orchestration-cluster-api
```

Runtime support:

- Node 20+ (native fetch & File; Node 18 needs global File polyfill)
- Modern browsers (Chromium, Firefox, Safari) – global `fetch` & `File` available

For older Node versions supply a fetch ponyfill AND a `File` shim (or upgrade). For legacy browsers, add a fetch polyfill (e.g. `whatwg-fetch`).

### Versioning

This SDK has a different release cadence from the Camunda server. Features and fixes land in the SDK during a server release.

The major version of the SDK signals a 1:1 type coherence with the server API for a Camunda minor release.

SDK version `n.y.z` -> server version `8.n`, so the type surface of SDK version 9.y.z matches the API surface of Camunda 8.9.

Using a later SDK version, for example: SDK version 10.y.z with Camunda 8.9, means that the SDK contains additive surfaces that are not guaranteed at runtime, and the compiler cannot warn of unsupported operations.

Using an earlier SDK version, for example: SDK version 9.y.z with Camunda 8.10, results in slightly degraded compiler reasoning: exhaustiveness checks cannot be guaranteed by the compiler for any extended surfaces (principally, enums with added members).

In the vast majority of use-cases, this will not be an issue; but you should be aware that using the matching SDK major version for the server minor version provides the strongest compiler guarantees about runtime reliability.

**Recommended approach**:

- Check the [CHANGELOG](https://github.com/camunda/orchestration-cluster-api-js/releases).
- As a sanity check during server version upgrade, rebuild applications with the matching SDK major version to identify any affected runtime surfaces.

## Migrating from 8.8

SDK 9.x (for Camunda 8.9) introduces two categories of breaking type changes relative to SDK 8.x (for Camunda 8.8). Neither change affects runtime behavior — existing code that compiled against 8.x will run identically — but the compiler will flag type mismatches until you update.

### Search results: optional → required fields

The search result types changed several fields from **optional** to **required**:

**`SearchQueryPageResponse` (page metadata)**

| Field               | SDK 8.x (Camunda 8.8)         | SDK 9.x (Camunda 8.9)              |
| ------------------- | ----------------------------- | ---------------------------------- |
| `totalItems`        | `totalItems?: number`         | `totalItems: number`               |
| `hasMoreTotalItems` | `hasMoreTotalItems?: boolean` | `hasMoreTotalItems: boolean`       |
| `endCursor`         | `endCursor?: EndCursor`       | `endCursor: EndCursor \| null`     |
| `startCursor`       | `startCursor?: StartCursor`   | `startCursor: StartCursor \| null` |

**`*SearchQueryResult` types (result containers)**

| Field   | SDK 8.x (Camunda 8.8)            | SDK 9.x (Camunda 8.9)           |
| ------- | -------------------------------- | ------------------------------- |
| `items` | `items?: T[]`                    | `items: T[]`                    |
| `page`  | `page?: SearchQueryPageResponse` | `page: SearchQueryPageResponse` |

This reflects upstream OpenAPI spec changes where these fields are now always present in the response, with `null` indicating "no value" for cursors rather than being absent.

**What to change**: Update code that checks for these fields using optional chaining or `undefined` comparisons. The `items` array and `page` object are now always present, so optional chaining on them is unnecessary:

<!-- snippet-exempt: migration example showing before/after patterns -->

```ts
// Before (8.x) — checking for undefined
if (result.page?.endCursor !== undefined) {
  nextPage(result.page.endCursor);
}
const count = result.items?.length ?? 0;

// After (9.x) — page and items are always present; check cursors for null
if (result.page.endCursor !== null) {
  nextPage(result.page.endCursor);
}
const count = result.items.length;
```

If you have a custom `PagedResponse` type, update its `page` shape to match:

<!-- snippet-exempt: migration example showing type definition update -->

```ts
// Before (8.x)
type PagedResponse<T> = {
  items?: T[];
  page?: {
    totalItems?: number;
    endCursor?: string;
    startCursor?: string;
    hasMoreTotalItems?: boolean;
  };
};

// After (9.x)
type PagedResponse<T> = {
  items: T[];
  page: {
    totalItems: number;
    endCursor: EndCursor | null;
    startCursor: StartCursor | null;
    hasMoreTotalItems: boolean;
  };
};
```

### Branded key types for `tenantId`

The `tenantId` field on request types (e.g. `CreateDeploymentData`) changed from `string` to the branded `TenantId` type. A plain `string` is no longer assignable:

<!-- snippet-exempt: migration example showing branded type usage -->

```ts

// Before (8.x) — plain string worked
await camunda.createDeployment({
  tenantId: "my-tenant",
  resources: [file],
});

// After (9.x) — use the branded type helper
await camunda.createDeployment({
  tenantId: TenantId.assumeExists("my-tenant"),
  resources: [file],
});
```

`TenantId.assumeExists()` validates the string against the tenant ID pattern and returns a branded value. The branded value is just a string at runtime, but `assumeExists()` performs validation and can throw if the input is malformed. See [Branded Keys](#branded-keys) for more on this pattern.

> **Tip**: If your tenant ID comes from a validated source (environment variable, config file), call `TenantId.assumeExists()` once at startup and pass the branded value throughout your application.

## Migrating from 8.9

SDK 10.x (for Camunda 8.10) promotes several identifier and name fields from plain `string` to **branded types** via `CamundaKey<T>`. The wire format and runtime API are unchanged — branded values are still plain strings at runtime and are assignable anywhere a `string` is expected (template literals, logging, JSON serialization). Callers need to brand values using `.assumeExists()` (which performs validation) to satisfy the new types.

### New branded types

| Brand                 | Used for                   |
| --------------------- | -------------------------- |
| `RoleId`              | Role identifiers           |
| `GroupId`             | Group identifiers          |
| `ClientId`            | OAuth client identifiers   |
| `MappingRuleId`       | Mapping-rule identifiers   |
| `ClusterVariableName` | Cluster variable names     |
| `AgentInstanceKey`    | Agent-instance system keys |

### Migration

<!-- snippet-source: examples/readme.ts | regions: V9ToV10Migration -->

```ts
// v9 — plain strings were accepted
// await camunda.assignRoleToGroup({
//   roleId: 'developer',
//   groupId: 'engineering',
// });

// v10 — use the branded type helpers at the boundary
await camunda.assignRoleToGroup({
  roleId: RoleId.assumeExists("developer"),
  groupId: GroupId.assumeExists("engineering"),
});
```

Each branded type has an `.assumeExists()` method that validates the string and returns the branded value. Validation runs at call time and can throw if the input is malformed, so call it once at the boundary (startup, config parsing, API response) and pass the branded value through your application. See [Branded Keys](#branded-keys) for more on this pattern.

### What does NOT change

- The wire format is unchanged — all values are still strings on the wire.
- No method signatures changed name or arity.
- Branded values are assignable anywhere a `string` is expected (template literals, logging, JSON serialization), so existing string-handling code continues to work.

## Quick Start (Zero‑Config – Recommended)

Keep configuration out of application code. Let the factory read `CAMUNDA_*` variables from the environment (12‑factor style). This makes rotation, secret management, and environment promotion safer & simpler.

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeDefaultImport+ReadmeQuickStart -->

```ts

// Zero‑config construction: reads CAMUNDA_* from process.env. If no configuration is present, defaults to Camunda 8 Run on localhost.
const camunda = createCamundaClient();

const topology = await camunda.getTopology();
console.log("Brokers:", topology.brokers?.length ?? 0);
```

Typical `.env` (example):

```bash
CAMUNDA_REST_ADDRESS=https://cluster.example   # SDK will use https://cluster.example/v2/... unless /v2 already present
CAMUNDA_AUTH_STRATEGY=OAUTH
CAMUNDA_CLIENT_ID=***
CAMUNDA_CLIENT_SECRET=***
CAMUNDA_DEFAULT_TENANT_ID=<default>   # optional: override default tenant resolution
CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS=4  # optional: total attempts (initial + 3 retries)
CAMUNDA_SDK_HTTP_RETRY_BASE_DELAY_MS=100  # optional: base backoff (ms)
CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS=2000  # optional: cap (ms)
```

> Prefer environment / secret manager injection over hard‑coding values in source. Treat the SDK like a leaf dependency: construct once near process start, pass the instance where needed.

> **Why zero‑config?**
>
> - Separation of concerns: business code depends on an interface, not on secret/constants wiring.
> - 12‑Factor alignment: config lives in the environment → simpler promotion (dev → staging → prod).
> - Secret rotation & incident response: rotate credentials without a code change or redeploy of application containers built with baked‑in values.
> - Immutable start: single hydration pass prevents drift / mid‑request mutations.
> - Test ergonomics: swap an `.env.test` (or injected vars) without touching source; create multiple clients for multi‑tenant tests.
> - Security review: fewer code paths handling secrets; scanners & vault tooling work at the boundary.
> - Deploy portability: same artifact runs everywhere; only the environment differs.
> - Observability clarity: configuration diffing is an ops concern, not an application code diff.

### Advanced: Programmatic Overrides

Use only when you must supply or mutate configuration dynamically (e.g. multi‑tenant routing, tests, ephemeral preview environments) or in the browser. Keys mirror their `CAMUNDA_*` env names.

<!-- snippet-source: examples/readme.ts | regions: ReadmeOverrides -->

```ts
const camunda = createCamundaClient({
  config: {
    CAMUNDA_REST_ADDRESS: "https://cluster.example",
    CAMUNDA_AUTH_STRATEGY: "BASIC",
    CAMUNDA_BASIC_AUTH_USERNAME: "alice",
    CAMUNDA_BASIC_AUTH_PASSWORD: "secret",
  },
});
```

### Advanced: Custom Fetch Implementation

Inject a custom `fetch` to add tracing, mock responses, instrumentation, circuit breakers, etc.

<!-- snippet-source: examples/readme.ts | regions: ReadmeCustomFetch -->

```ts
const camunda = createCamundaClient({
  fetch: (input, init) => {
    // inspect / modify request here
    return fetch(input, init);
  },
});
```

### Reconfiguration At Runtime (Rare)

You can call `client.configure({ config: { ... } })` to re‑hydrate. The exposed `client.getConfig()` stays `Readonly` and deep‑frozen. Prefer creating a new client instead of mutating a shared one in long‑lived services.

## Validation

This allows you to validate that requests to the API from your application and responses from the API have the expected types and shape declared in the type system.

This protects your application from runtime bugs or errors in the type system leading to undefined states hitting your business logic.

Recommended to use `fanatical` or `strict` in development and then switch to `strict` or `warn` in production.

Or you can just YOLO it and leave it on `none` all the time.

Controlled by `CAMUNDA_SDK_VALIDATION` (or `config` override). Grammar:

```
none | warn | strict | req:<mode>[,res:<mode>] | res:<mode>[,req:<mode>]
<mode> = none|warn|strict|fanatical
```

Examples:

```bash
CAMUNDA_SDK_VALIDATION=warn           # warn on both
CAMUNDA_SDK_VALIDATION=req:strict,res:warn # strict on requests, warn on responses
CAMUNDA_SDK_VALIDATION=none
```

Behavior:

- `none` - no validation performed
- `warn` - emit warning on invalid shape
- `strict` - fail on type mismatch or missing required fields
- `fanatical` - fail on type mismatch, missing required fields, or unknown additional fields

> **Note on `int64` fields**: The upstream OpenAPI spec declares some fields (e.g. `totalItems`, `timeout`, `timestamp`) as `integer` with `format: int64`. The TypeScript types map these to `number`. JSON responses also deserialize as `number` (with precision loss beyond `Number.MAX_SAFE_INTEGER`). The Zod schemas use `z.coerce.number().int()` for these fields, preserving the integer constraint while keeping the runtime type aligned with TypeScript. All validation modes (`none`, `warn`, `strict`, `fanatical`) return `number`.

## Per-Method Retry Override

Every API method accepts an optional trailing `options` parameter that lets you override or disable the global retry policy for that single call.

### Disable Retry for a Single Call

<!-- snippet-source: examples/readme.ts | regions: ReadmeDisableRetry -->

```ts
// This call will not retry on transient errors
await camunda.completeJob({ jobKey }, { retry: false });
```

### Override Specific Retry Settings

Pass a partial `HttpRetryPolicy` to override individual fields. Unspecified fields inherit from the global configuration.

<!-- snippet-source: examples/readme.ts | regions: ReadmeRetryOverride -->

```ts
// More aggressive retry for this operation only
await camunda.createProcessInstance(
  { processDefinitionId },
  { retry: { maxAttempts: 8, maxDelayMs: 5000 } }
);

// Minimal retry: single retry with short backoff
await camunda.getTopology({ retry: { maxAttempts: 2, baseDelayMs: 50 } });
```

### How It Works

| `options.retry` value | Behavior                                                             |
| --------------------- | -------------------------------------------------------------------- |
| omitted / `undefined` | Uses global policy (`CAMUNDA_SDK_HTTP_RETRY_*` env vars)             |
| `false`               | Disables retry entirely (single attempt, no backoff)                 |
| `{ maxAttempts: 5 }`  | Merges with global policy — only the specified fields are overridden |

The `HttpRetryPolicy` fields available for override:

| Field         | Type     | Description                             |
| ------------- | -------- | --------------------------------------- |
| `maxAttempts` | `number` | Total attempts (initial + retries)      |
| `baseDelayMs` | `number` | Base delay for exponential backoff (ms) |
| `maxDelayMs`  | `number` | Maximum delay cap (ms)                  |

## Advanced HTTP Retry: Cockatiel Adapter (Optional)

For advanced resilience patterns beyond per-method overrides — circuit breakers, timeouts, custom classification, combining policies — you can integrate [cockatiel](https://github.com/connor4312/cockatiel).

> **Tip:** For most use cases, per-method retry override (above) is sufficient. Reach for Cockatiel when you need circuit breaking, hedging, or bulkhead controls.

### When To Use Cockatiel

- You want circuit breaking, hedging, timeout, or bulkhead controls
- You want to add custom classification (e.g. retry certain 5xx only on safe verbs)
- You need to compose multiple resilience policies together

### Disable Built‑In HTTP Retries

Set `CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS=1` so the SDK does only the initial attempt; then wrap operations with cockatiel.

### Minimal Example (Single Operation)

<!-- snippet-exempt: uses external cockatiel library -->

```ts

const client = createCamundaClient({
  config: {
    CAMUNDA_REST_ADDRESS: "https://cluster.example",
    CAMUNDA_AUTH_STRATEGY: "NONE",
    CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS: 1, // disable SDK automatic retries
  } as any,
});

// Policy: up to 5 attempts total (1 + 4 retries) with exponential backoff & jitter
const policy = retry(handleAll, {
  maxAttempts: 5,
  backoff: new ExponentialBackoff({
    initialDelay: 100,
    maxDelay: 2000,
    jitter: true,
  }),
});

// Wrap getTopology
const origGetTopology = client.getTopology.bind(client);
client.getTopology = (() => policy.execute(() => origGetTopology())) as any;

const topo = await client.getTopology();
console.log(topo.brokers?.length);
```

### Bulk Wrapping All Operations

<!-- snippet-exempt: uses external cockatiel library -->

```ts

const client = createCamundaClient({
  config: {
    CAMUNDA_REST_ADDRESS: "https://cluster.example",
    CAMUNDA_AUTH_STRATEGY: "OAUTH",
    CAMUNDA_CLIENT_ID: process.env.CAMUNDA_CLIENT_ID,
    CAMUNDA_CLIENT_SECRET: process.env.CAMUNDA_CLIENT_SECRET,
    CAMUNDA_OAUTH_URL: process.env.CAMUNDA_OAUTH_URL,
    CAMUNDA_TOKEN_AUDIENCE: "zeebe.camunda.io",
    CAMUNDA_SDK_HTTP_RETRY_MAX_ATTEMPTS: 1,
  } as any,
});

const retryPolicy = retry(handleAll, {
  maxAttempts: 4,
  backoff: new ExponentialBackoff({
    initialDelay: 150,
    maxDelay: 2500,
    jitter: true,
  }),
});

const skip = new Set([
  "logger",
  "configure",
  "getConfig",
  "withCorrelation",
  "deployResourcesFromFiles",
]);
for (const key of Object.keys(client)) {
  const val: any = (client as any)[key];
  if (typeof val === "function" && !key.startsWith("_") && !skip.has(key)) {
    const original = val.bind(client);
    (client as any)[key] = (...a: any[]) =>
      retryPolicy.execute(() => original(...a));
  }
}

// Now every public operation is wrapped.
```

## Support Logger (Node Only)

For diagnostics during support interactions you can enable an auxiliary file logger that captures a sanitized snapshot of environment & configuration plus selected runtime events.

Enable by setting one of:

```bash
CAMUNDA_SUPPORT_LOG_ENABLED=true        # canonical
```

Optional override for output path (default is `./camunda-support.log` in the current working directory):

```bash
CAMUNDA_SUPPORT_LOG_FILE_PATH=/var/log/camunda-support.log
```

Behavior:

- File is created eagerly on first client construction (one per process; if the path exists a numeric suffix is appended to avoid clobbering).
- Initial preamble includes SDK package version, timestamp, and redacted environment snapshot.
- Secrets (client secret, passwords, mTLS private key, etc.) are automatically masked or truncated.
- Designed to be low‑impact: append‑only, newline‑delimited JSON records may be added in future releases for deeper inspection (current version writes the preamble only unless additional events are wired).

Recommended usage:

```bash
CAMUNDA_SUPPORT_LOG_ENABLED=1 CAMUNDA_SDK_LOG_LEVEL=debug node app.js
```

Keep the file only as long as needed for troubleshooting; it may contain sensitive non‑secret operational metadata. Do not commit it to version control.

To disable, unset the env variable or set `CAMUNDA_SUPPORT_LOG_ENABLED=false`.

Refer to `./docs/CONFIG_REFERENCE.md` for the full list of related environment variables.

### Custom Classification Example

Retry only network errors + 429/503, plus optionally 500 on safe GET endpoints you mark:

<!-- snippet-exempt: uses external cockatiel library -->

```ts

const classify = handleWhen((err) => {
  const status = (err as any)?.status;
  if (status === 429 || status === 503) return true;
  if (status === 500 && (err as any).__opVerb === "GET") return true; // custom tagging optional
  return err?.name === "TypeError"; // network errors from fetch
});

const policy = retry(classify, {
  maxAttempts: 5,
  backoff: new ExponentialBackoff({
    initialDelay: 100,
    maxDelay: 2000,
    jitter: true,
  }),
});
```

### Notes

- Keep SDK retries disabled to prevent duplicate layers.
- SDK synthesizes `Error` objects with a `status` for retry-significant HTTP responses (429, 503, 500), enabling classification.
- You can tag errors (e.g. assign `err.__opVerb`) in a wrapper if verb-level logic is needed.
- For per-operation retry customization without external dependencies, use the built-in [per-method retry override](#per-method-retry-override) instead.

> Combine cockatiel retry with a circuit breaker, timeout, or bulkhead policy for more robust behavior in partial outages.

## Global Backpressure (Adaptive Concurrency)

The client now includes an internal global backpressure manager that adaptively throttles the number of _initiating_ in‑flight operations when the cluster signals resource exhaustion. It complements (not replaces) per‑request HTTP retry.

### Signals Considered

An HTTP response is treated as a backpressure signal when it is classified retryable **and** matches one of:

- `429` (Too Many Requests) – always
- `503` with `title === "RESOURCE_EXHAUSTED"`
- `500` whose RFC 9457 / 7807 `detail` text contains `RESOURCE_EXHAUSTED`

All other 5xx / 503 variants are treated as non‑retryable (fail fast) and do **not** influence the adaptive gate.

### How It Works

1. Normal state starts with effectively unlimited concurrency (no global semaphore enforced) until the first backpressure event.
2. On the first signal the manager boots with a provisional concurrency cap (e.g. 16) and immediately reduces it (soft state).
3. Repeated consecutive signals escalate severity to `severe`, applying a stronger reduction factor.
4. Successful (non‑backpressure) completions trigger passive recovery checks that gradually restore permits over time if the system stays quiet.
5. Quiet periods (no signals for a configurable decay interval) downgrade severity (`severe → soft → healthy`) and reset the consecutive counter when fully healthy.

The policy is intentionally conservative: it only engages after genuine pressure signals and recovers gradually to avoid oscillation.

### Exempt Operations

Certain operations that help drain work or complete execution are _exempt_ from gating so they are never queued behind initiating calls:

- `completeJob`
- `failJob`
- `throwJobError`
- `completeUserTask`

These continue immediately even during severe backpressure to promote system recovery.

### Interaction With HTTP Retry

Per‑request retry still performs exponential backoff + jitter for classified transient errors. The adaptive concurrency layer sits _outside_ retry:

1. A call acquires a permit (unless exempt) before its first attempt.
2. Internal retry re‑attempts happen _within_ the held permit.
3. On final success the permit is released and a healthy hint is recorded (possible gradual recovery).
4. On final failure (non‑retryable or attempts exhausted) the permit is released; a 429 on the terminal attempt still records backpressure.

This design prevents noisy churn (permits would not shrink/expand per retry attempt) and focuses on admission control of distinct logical operations.

### Observability

Enable debug logging (`CAMUNDA_SDK_LOG_LEVEL=debug` or `trace`) to see events emitted under the scoped logger `bp` (e.g. `backpressure.permits.scale`, `backpressure.permits.recover`, `backpressure.severity`). These are trace‑level; use `trace` for the most granular insight.

### Configuration

Current release ships with defaults tuned for conservative behavior. Adaptive gating is controlled by a profile (no separate boolean toggle). Use the `LEGACY` profile for observe‑only mode (no global gating, still records severity). Otherwise choose a tuning profile and optionally override individual knobs.

Tuning environment variables (all optional; defaults shown):

| Variable                                        | Default    | Description                                                                                     |
| ----------------------------------------------- | ---------- | ----------------------------------------------------------------------------------------------- |
| `CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX`          | `16`       | Bootstrap concurrency cap once the first signal is observed (null/unlimited before any signal). |
| `CAMUNDA_SDK_BACKPRESSURE_SOFT_FACTOR`          | `70`       | Percentage multiplier applied on each soft backpressure event (70 => 0.70x permits).            |
| `CAMUNDA_SDK_BACKPRESSURE_SEVERE_FACTOR`        | `50`       | Percentage multiplier when entering or re-triggering in severe state.                           |
| `CAMUNDA_SDK_BACKPRESSURE_RECOVERY_INTERVAL_MS` | `1000`     | Interval between passive recovery checks.                                                       |
| `CAMUNDA_SDK_BACKPRESSURE_RECOVERY_STEP`        | `1`        | Permits regained per recovery interval until reaching the bootstrap cap.                        |
| `CAMUNDA_SDK_BACKPRESSURE_DECAY_QUIET_MS`       | `2000`     | Quiet period to downgrade severity (`severe→soft→healthy`).                                     |
| `CAMUNDA_SDK_BACKPRESSURE_FLOOR`                | `1`        | Minimum concurrency floor while degraded.                                                       |
| `CAMUNDA_SDK_BACKPRESSURE_SEVERE_THRESHOLD`     | `3`        | Consecutive signals required to enter severe state.                                             |
| `CAMUNDA_SDK_BACKPRESSURE_PROFILE`              | `BALANCED` | Preset profile: BALANCED, CONSERVATIVE, AGGRESSIVE, LEGACY (LEGACY = observe-only, no gating).  |

#### Profiles

Profiles supply coordinated defaults when you don't want to reason about individual knobs. Any explicitly set knob env var overrides the profile value.

| Profile      | initialMax | softFactor% | severeFactor% | recoveryIntervalMs | recoveryStep | quietDecayMs | floor | severeThreshold | Intended Use                                                    |
| ------------ | ---------- | ----------- | ------------- | ------------------ | ------------ | ------------ | ----- | --------------- | --------------------------------------------------------------- |
| BALANCED     | 16         | 70          | 50            | 1000               | 1            | 2000         | 1     | 3               | General workloads with moderate spikes                          |
| CONSERVATIVE | 12         | 60          | 40            | 1200               | 1            | 2500         | 1     | 2               | Protect cluster under tighter capacity / cost constraints       |
| AGGRESSIVE   | 24         | 80          | 60            | 800                | 2            | 1500         | 2     | 4               | High throughput scenarios aiming to utilize headroom quickly    |
| LEGACY       | n/a        | 70          | 50            | 1000               | 1            | 2000         | 1     | 3               | Observe signals only (severity metrics) without adaptive gating |

Select via:

```bash
CAMUNDA_SDK_BACKPRESSURE_PROFILE=AGGRESSIVE
```

Then optionally override a single parameter, e.g.:

```bash
CAMUNDA_SDK_BACKPRESSURE_PROFILE=AGGRESSIVE
CAMUNDA_SDK_BACKPRESSURE_INITIAL_MAX=32
```

If the profile name is unrecognized the SDK falls back to BALANCED silently (future versions may emit a warning).

Factors use integer percentages to avoid floating point drift in env parsing; the SDK converts them to multipliers internally (e.g. `70` -> `0.7`).

If you have concrete tuning needs, open an issue describing workload patterns (operation mix, baseline concurrency, observed broker limits) to help prioritize which knobs to surface.

### What Should I Set?

If you're unsure about your workload shape, **don't set anything**. The default BALANCED profile activates automatically and outperforms no-gating (LEGACY) in most scenarios — on raw throughput alone, not just error reduction.

Benchmark results against a single-node local cluster with multiple independent clients (no shared state between them):

| Scenario                      | BALANCED        | LEGACY (no gating) |
| ----------------------------- | --------------- | ------------------ |
| Single-client (1K processes)  | **80.1 ops/s**  | 67.8 ops/s         |
| Single-client sustained (10K) | **119.6 ops/s** | 87.8 ops/s         |
| Multi-client 3+2 spike        | **86.3 ops/s**  | 48.0 ops/s         |
| Stress 8 clients ×1000        | 76.3 ops/s      | **106.4 ops/s**    |

BALANCED wins 3 of 4 on pure throughput. The only scenario where LEGACY is faster is extreme overload (800 concurrent requests against a single broker) — and in that case LEGACY accumulates 44,505 errors vs BALANCED's 15,527. The default just works.

## Typed Variable Map (DTO-driven search)

`searchVariablesAsDto` fetches process variables and binds them to a [Zod](https://zod.dev) schema that acts as the DTO. The schema's keys are the exact variable names to fetch, and its shape drives validation. Only the declared variables are queried (via a `name $in [...]` filter), so memory stays bound by the DTO shape rather than the total number of variables on the instance. Results are paged internally until every declared variable is found or the result set is exhausted.

The returned `VariableMap` offers two access modes:

- **Lenient** — `has(name)` / `get(name)` for defensive reads that never throw on missing variables.
- **Strict** — `validate()` returns a fully-typed object, or throws a `ZodError` when a required variable is missing or malformed.

If a declared variable is found at more than one scope (for example a local variable shadowing a process-level one), the search throws a `VariableScopeCollisionError` rather than silently picking one. Pass an explicit `scopeKey` to disambiguate.

<!-- snippet-source: examples/readme.ts | regions: ReadmeTypedVariables -->

```ts
// The Zod schema is the DTO: its keys are the variable names to fetch, and its
// shape drives validation. Only these declared variables are queried, so memory
// stays bound by the DTO — not by the total number of variables on the instance.
const OrderVariables = z.object({
  orderId: z.string(), // required
  amount: z.number().optional(), // optional
});

const map = await camunda.searchVariablesAsDto(OrderVariables, {
  processInstanceKey,
});

// Lenient access: defensive reads that never throw on missing variables.
if (map.has("amount")) {
  console.log("Amount:", map.get("amount"));
}

// Strict access: returns a fully-typed object, or throws a ZodError when a
// required variable is missing or malformed.
const order = map.validate(); // { orderId: string; amount?: number }
console.log("Order:", order.orderId);
```

## Job Workers (Polling API)

The SDK provides a lightweight polling job worker for service task job types using `createJobWorker`. It activates jobs in batches (respecting a concurrency limit), validates variables (optional), and offers action helpers on each job.

### Minimal Example

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeJobWorkerImport+ReadmeJobWorkerMinimal -->

```ts

const client = createCamundaClient();

// Define schemas (optional)
const Input = z.object({ orderId: z.string() });
const Output = z.object({ processed: z.boolean() });

const worker = client.createJobWorker({
  jobType: "process-order",
  maxParallelJobs: 10,
  jobTimeoutMs: 15_000, // long‑poll timeout (server side requestTimeout)
  pollIntervalMs: 100, // delay between polls when no jobs / at capacity
  // Optional: only fetch specific variables during activation
  fetchVariables: ["orderId"],
  inputSchema: Input, // validates incoming variables if validateSchemas true
  outputSchema: Output, // validates variables passed to complete(...)
  validateSchemas: true, // set false for max throughput (skip Zod)
  autoStart: true, // default true; start polling immediately
  startupJitterMaxSeconds: 5, // random delay up to 5s before first poll (default 0)
  jobHandler: (job) => {
    // Access typed variables
    const vars = job.variables; // inferred from Input schema
    console.log(`Processing order: ${vars.orderId}`);
    // Do work...
    return job.complete({ processed: true });
  },
});

// Later, on shutdown:
process.on("SIGINT", () => {
  worker.stop();
});
```

Note on variable fetching:

- `fetchVariables: string[]` limits variables returned on activated jobs to the specified keys. If omitted, all visible variables at activation scope are returned. This maps to the REST API field `fetchVariable`.

TypeScript inference:

- When you provide `inputSchema`, the type of `fetchVariables` is constrained to the keys of the inferred `variables` type from that schema. Example:

<!-- snippet-source: examples/readme.ts | regions: ReadmeJobWorkerInference -->

```ts
const Input = z.object({ orderId: z.string(), amount: z.number() });
client.createJobWorker({
  jobType: "process-order",
  maxParallelJobs: 5,
  jobTimeoutMs: 30_000,
  inputSchema: Input,
  // Only allows 'orderId' | 'amount' here at compile-time
  fetchVariables: ["orderId", "amount"],
  jobHandler: async (job) => job.complete(),
});
```

- Without `inputSchema`, `fetchVariables` defaults to `string[]`.

### Job Handler Semantics

Your `jobHandler` must ultimately invoke exactly one of:

- `job.complete(variables?, result?)` OR `job.complete()`
- `job.fail({ errorMessage, retries?, retryBackoff? })`
- `job.cancelWorkflow({})` (cancels the process instance)
- `job.error({ errorCode, errorMessage? })` (throws a business error)
- `job.ignore()` (marks as done locally without reporting to broker – can be used for decoupled flows)

Each action returns an opaque unique symbol receipt (`JobActionReceipt`). The handler's declared return type (`Promise<JobActionReceipt>`) is intentional:

Why this design:

- Enforces a single terminal code path: every successful handler path should end by returning the sentinal obtained by invoking an action.
- Enables static reasoning: TypeScript can identify if your handler has a code path that does not acknowledge the job (catch unintended behavior early).
- Makes test assertions simple: e.g. `expect(await job.complete()).toBe(JobActionReceipt)`.

Acknowledgement lifecycle:

- Calling any action (`complete`, `fail`, `cancelWorkflow`, `ignore`) sets `job.acknowledged = true` internally. This surfaces multiple job resolution code paths at runtime.
- If the handler resolves (returns the symbol manually or via an action) without any acknowledgement having occurred, the worker logs `job.handler.noAction` and locally marks the job finished WITHOUT informing the broker (avoids a leak of the in-memory slot, but the broker will eventually time out and re-dispatch the job).

Recommended usage:

- Always invoke an action; if you truly mean to skip broker acknowledgement (for example: forwarding a job to another system which will complete it) use `job.ignore()`.

Example patterns:

<!-- snippet-source: examples/readme.ts | regions: ReadmeJobCompletionPatterns -->

```ts
// GOOD: explicit completion
return job.complete({ variables: { processed: true } });

// GOOD: No-arg completion example, sentinel stored for ultimate return
// biome-ignore lint/correctness/noUnreachable: intentional — showing multiple completion patterns
const ack = await job.complete();
// ...
return ack;

// GOOD: explicit ignore
const ack2 = await job.ignore();
```

### Job Corrections (User Task Listeners)

When a job worker handles a [user task listener](https://docs.camunda.io/docs/components/concepts/user-task-listeners/), it can correct task properties (assignee, due date, candidate groups, etc.) by passing a `result` to `job.complete()`:

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeJobCorrectionsImport+ReadmeJobCorrections -->

```ts

const worker = client.createJobWorker({
  jobType: "io.camunda:userTaskListener",
  jobTimeoutMs: 30_000,
  maxParallelJobs: 5,
  jobHandler: async (job) => {
    const result: JobResult = {
      type: "userTask",
      corrections: {
        assignee: "corrected-user",
        priority: 80,
      },
    };
    return job.complete({}, result);
  },
});
```

To deny a task completion (reject the work):

<!-- snippet-source: examples/readme.ts | regions: ReadmeJobCorrectionsDenial -->

```ts
return job.complete(
  {},
  {
    type: "userTask",
    denied: true,
    deniedReason: "Insufficient documentation",
  }
);
```

| Correctable attribute | Type                | Clear value       |
| --------------------- | ------------------- | ----------------- |
| `assignee`            | `string`            | Empty string `""` |
| `dueDate`             | `string` (ISO 8601) | Empty string `""` |
| `followUpDate`        | `string` (ISO 8601) | Empty string `""` |
| `candidateUsers`      | `string[]`          | Empty array `[]`  |
| `candidateGroups`     | `string[]`          | Empty array `[]`  |
| `priority`            | `number` (0–100)    | —                 |

Omitting an attribute or passing `null` preserves the persisted value.

### Concurrency & Backpressure

Set `maxParallelJobs` to the maximum number of jobs you want actively processing concurrently. The worker will long‑poll for up to the remaining capacity each cycle. Global backpressure (adaptive concurrency) still applies to the underlying REST calls; activation itself is a normal operation.

### Validation

If `validateSchemas` is true:

- Incoming `variables` are parsed with `inputSchema` (fail => job is failed with a validation error message).
- Incoming `customHeaders` parsed with `customHeadersSchema` if provided.
- Completion payload `variables` parsed with `outputSchema` (warns & proceeds on failure).

### Graceful Shutdown

Use `await worker.stopGracefully({ waitUpToMs?, checkIntervalMs? })` to drain without force‑cancelling the current activation request.

<!-- snippet-source: examples/readme.ts | regions: ReadmeJobWorkerGraceful -->

```ts
// Attempt graceful drain for up to 8 seconds
const { remainingJobs, timedOut } = await worker.stopGracefully({
  waitUpToMs: 8000,
});
if (timedOut) {
  console.warn("Graceful stop timed out; remaining jobs:", remainingJobs);
}
```

Behavior:

- Stops scheduling new polls immediately.
- Lets any in‑flight activation finish (not cancelled proactively).
- Waits for active jobs to acknowledge (complete/fail/cancelWorkflow/ignore).
- On timeout: falls back to hard stop semantics (cancels activation) and logs `worker.gracefulStop.timeout` at debug.

For immediate termination call `worker.stop()` (or `client.stopAllWorkers()`) which cancels the in‑flight activation if present.

Activation cancellations during stop are logged at debug (`activation.cancelled`) instead of error noise.

### Multiple Workers

You can register multiple workers on a single client instance—one per job type is typical. The client exposes `client.getWorkers()` for inspection and `client.stopAllWorkers()` for coordinated shutdown.

### Startup Jitter

When deploying multiple application instances simultaneously (e.g. a rolling restart or scale-up), all workers start polling at the same time and can saturate the server with activation requests. Set `startupJitterMaxSeconds` to spread out the initial poll across a random window:

<!-- snippet-source: examples/readme.ts | regions: ReadmeJobWorkerJitter -->

```ts
client.createJobWorker({
  jobType: "process-order",
  maxParallelJobs: 10,
  jobTimeoutMs: 30_000,
  startupJitterMaxSeconds: 5, // each instance delays 0–5s before first poll
  jobHandler: async (job) => job.complete(),
});
```

A value of `0` (the default) means no delay.

### Heritable Worker Defaults

When running many workers with the same base configuration, you can set global defaults via environment variables (or equivalent keys in `CamundaOptions.config`). These apply to every worker created by the client (both `createJobWorker` and `createThreadedJobWorker`) unless the individual worker config explicitly overrides them.

| Environment Variable                        | Worker Config Field       | Type   |
| ------------------------------------------- | ------------------------- | ------ |
| `CAMUNDA_WORKER_TIMEOUT`                    | `jobTimeoutMs`            | number |
| `CAMUNDA_WORKER_MAX_CONCURRENT_JOBS`        | `maxParallelJobs`         | number |
| `CAMUNDA_WORKER_REQUEST_TIMEOUT`            | `pollTimeoutMs`           | number |
| `CAMUNDA_WORKER_NAME`                       | `workerName`              | string |
| `CAMUNDA_WORKER_STARTUP_JITTER_MAX_SECONDS` | `startupJitterMaxSeconds` | number |

**Precedence:** explicit worker config value > `CAMUNDA_WORKER_*` (from environment variables or `CamundaOptions.config` overrides) > hardcoded default (where applicable).

Example — set defaults via environment:

```bash
export CAMUNDA_WORKER_TIMEOUT=30000
export CAMUNDA_WORKER_MAX_CONCURRENT_JOBS=8
export CAMUNDA_WORKER_NAME=order-service
```

<!-- snippet-source: examples/readme.ts | regions: ReadmeWorkerDefaultsEnv -->

```ts
// Workers inherit timeout, concurrency, and name from environment
const w1 = client.createJobWorker({
  jobType: "validate-order",
  jobHandler: async (job) => job.complete(),
});

const w2 = client.createJobWorker({
  jobType: "ship-order",
  jobHandler: async (job) => job.complete(),
});

// Per-worker override: this worker uses 32 concurrent jobs instead of the global 8
const w3 = client.createJobWorker({
  jobType: "bulk-import",
  maxParallelJobs: 32,
  jobHandler: async (job) => job.complete(),
});
```

You can also pass defaults programmatically via the client constructor:

<!-- snippet-source: examples/readme.ts | regions: ReadmeWorkerDefaultsClient -->

```ts
const client = createCamundaClient({
  config: {
    CAMUNDA_WORKER_TIMEOUT: 30000,
    CAMUNDA_WORKER_MAX_CONCURRENT_JOBS: 8,
  },
});
```

### Receipt Type (Unique Symbol)

Action methods return a unique symbol (not a string) to avoid accidental misuse and allow internal metrics. If you store the receipt, annotate its type as `JobActionReceipt` to preserve uniqueness:

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeReceiptImport+ReadmeReceipt -->

```ts

const receipt: JobActionReceipt = await job.complete({ processed: true });
```

If you ignore the return value you don’t need to import the symbol.

### When Not To Use The Worker

- Extremely latency‑sensitive tasks where a push mechanism or streaming protocol is required.
- Massive fan‑out requiring custom partitioning strategies (implement a custom activator loop instead).
- Browser environments (long‑lived polling + secret handling often unsuitable).

For custom strategies you can still call `client.activateJobs(...)`, manage concurrency yourself, and use `completeJob` / `failJob` directly.

### Guarantees & Caveats

- Never increases latency for healthy clusters (no cap until first signal).
- Cannot create fairness across multiple _processes_; it is per client instance in a single process. Scale your worker pool with that in mind.
- Not a replacement for server‑side quotas or external rate limiters—it's a cooperative adaptive limiter.

### Opt‑Out

To bypass adaptive concurrency while still collecting severity metrics use:

```bash
CAMUNDA_SDK_BACKPRESSURE_PROFILE=LEGACY
```

This reverts to only per‑request retry for transient errors (no global gating) while keeping observability.

### Inspecting State Programmatically

Call `client.getBackpressureState()` to obtain:

<!-- snippet-source: examples/readme.ts | regions: ReadmeBackpressureState -->

```ts
const state = client.getBackpressureState();
// state.severity: 'healthy' | 'soft' | 'severe'
// state.consecutive: number — consecutive backpressure signals observed
// state.permitsMax: number | null — current concurrency cap (null => unlimited/not engaged)
// state.permitsCurrent: number — currently acquired permits
// state.waiters: number — queued operations waiting for a permit
```

### Threaded Job Workers (Node.js Only)

For CPU-intensive job handlers, `createThreadedJobWorker` offloads handler execution to a pool of Node.js `worker_threads`. Polling and I/O remain on the main event loop, while handler logic runs in parallel threads — dramatically improving throughput when the handler does CPU-bound work (JSON processing, validation, transformation, cryptography).

#### When to use

- Your handler spends significant time on CPU work (not just waiting for HTTP responses)
- You observe that a single-threaded worker saturates one CPU core while throughput plateaus
- You need to process more jobs per second without deploying additional instances

If your handler is mostly I/O-bound (HTTP calls, database queries), the standard `createJobWorker` is sufficient.

#### Handler module

The handler must be a **separate file** (not an inline function) that exports a default async function:

<!-- snippet-exempt: pseudo-code referencing heavyComputation which cannot be type-checked -->

```ts
// my-handler.ts (or my-handler.js)

const handler: ThreadedJobHandler = async (job, client) => {
  const { orderId } = job.variables;
  // CPU-intensive work here...
  const result = heavyComputation(orderId);
  return job.complete({ result });
};
export default handler;
```

Typing your handler as `ThreadedJobHandler` gives full intellisense for `job` (variables, action methods like `complete()`, `fail()`, `error()`) and `client` (every `CamundaClient` API method).

The handler receives two arguments:

1. **`job`** — a proxy with the same shape as a regular job worker job (`variables`, `customHeaders`, `jobKey`, plus action methods: `complete()`, `fail()`, `error()`, `cancelWorkflow()`, `ignore()`)
2. **`client`** — a proxy to the `CamundaClient` on the main thread. You can call any SDK method (e.g. `client.publishMessage(...)`, `client.createProcessInstance(...)`) and it will be forwarded to the main thread and executed there.

#### Minimal example

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeThreadedWorkerImport+ReadmeThreadedWorker -->

```ts

const client = createCamundaClient();

const worker = client.createThreadedJobWorker({
  jobType: "cpu-heavy-task",
  handlerModule: path.join(
    path.dirname(fileURLToPath(import.meta.url)),
    "my-handler.js"
  ),
  maxParallelJobs: 32,
  jobTimeoutMs: 30_000,
});
```

#### Configuration

`createThreadedJobWorker` accepts all the same options as `createJobWorker` (except `jobHandler`), plus:

| Option           | Type     | Default                     | Description                                                      |
| ---------------- | -------- | --------------------------- | ---------------------------------------------------------------- |
| `handlerModule`  | `string` | (required)                  | Path to handler module (absolute or relative to `process.cwd()`) |
| `threadPoolSize` | `number` | `os.availableParallelism()` | Number of worker threads in the pool                             |

Other familiar options: `jobType`, `maxParallelJobs`, `jobTimeoutMs`, `pollIntervalMs`, `pollTimeoutMs`, `fetchVariables`, `inputSchema`, `outputSchema`, `customHeadersSchema`, `validateSchemas`, `autoStart`, `startupJitterMaxSeconds`, `workerName`.

#### Lifecycle

Threaded workers integrate with the same lifecycle as regular workers:

<!-- snippet-source: examples/readme.ts | regions: ReadmeThreadedLifecycle -->

```ts
// Returned by getWorkers()
const allWorkers = client.getWorkers();

// Stopped by stopAllWorkers()
client.stopAllWorkers();
```

<!-- snippet-source: examples/readme.ts | regions: ReadmeThreadedGraceful -->

```ts
// Graceful shutdown (waits for in-flight jobs to finish)
const { timedOut, remainingJobs } = await worker.stopGracefully({
  waitUpToMs: 10_000,
});
```

#### Pool stats

<!-- snippet-source: examples/readme.ts | regions: ReadmePoolStats -->

```ts
worker.poolSize; // number of threads
worker.busyThreads; // threads currently processing a job
worker.activeJobs; // total jobs dispatched but not yet completed
```

#### How it works

1. The main thread polls `activateJobs` using the same mechanism as `createJobWorker`
2. Activated jobs are serialized and dispatched to an idle thread via `MessageChannel`
3. The thread loads the handler module (lazy, on first job), creates a proxy for `job` action methods and `client` API calls
4. Action methods (`job.complete()`, `job.fail()`, etc.) and client calls are forwarded back to the main thread over the `MessagePort` and executed there
5. The result is relayed back, and the thread is marked idle for the next job

#### Constraints

- **Node.js only**: `worker_threads` is not available in browsers or Deno
- **Handler must be a file module**: Inline functions cannot be transferred to threads
- **Job variables must be JSON-serializable**: Functions and class instances on the job are stripped during transfer
- **Client calls are async round-trips**: Each `client.xyz()` call crosses a thread boundary, adding a small amount of latency per call

---

## Authentication

Set `CAMUNDA_AUTH_STRATEGY` to `NONE` (default), `BASIC`, or `OAUTH`.

Basic:

```
CAMUNDA_AUTH_STRATEGY=BASIC
CAMUNDA_BASIC_AUTH_USERNAME=alice
CAMUNDA_BASIC_AUTH_PASSWORD=supersecret
```

OAuth (client credentials):

```
CAMUNDA_AUTH_STRATEGY=OAUTH
CAMUNDA_CLIENT_ID=yourClientId
CAMUNDA_CLIENT_SECRET=yourSecret
CAMUNDA_OAUTH_URL=https://idp.example/oauth/token   # if required by your deployment
```

Optional audience / retry / timeout vars are also read if present (see generated config reference).

Auth helper features (automatic inside the client):

- Disk + memory token cache
- Early refresh with skew handling
- Exponential backoff & jitter
- Singleflight suppression of concurrent refreshes
- Hook: `client.onAuthHeaders(h => ({ ...h, 'X-Trace': 'abc' }))`
- Force refresh: `await client.forceAuthRefresh()`
- Clear caches: `client.clearAuthCache({ disk: true, memory: true })`

### Token Caching & Persistence

The SDK always keeps the active OAuth access token in memory. Optional disk persistence (Node only) is enabled by setting:

```bash
CAMUNDA_OAUTH_CACHE_DIR=/path/to/cache
```

When present and running under Node, each distinct credential context (combination of `oauthUrl | clientId | audience | scope`) is hashed to a filename:

```
<CAMUNDA_OAUTH_CACHE_DIR>/camunda_oauth_token_cache_<hash>.json
```

Writes are atomic (`.tmp` + rename) and use file mode `0600` (owner read/write). On process start the SDK attempts to load the persisted file to avoid an unnecessary token fetch; if the token is near expiry it will still perform an early refresh (5s skew window plus additional safety buffer based on 5% or 30s minimum).

Clearing / refreshing:

- Programmatic clear: `client.clearAuthCache({ disk: true, memory: true })`
- Memory only: `client.clearAuthCache({ memory: true, disk: false })`
- Force new token (ignores freshness): `await client.forceAuthRefresh()`

Disable disk persistence by simply omitting `CAMUNDA_OAUTH_CACHE_DIR` (memory cache still applies). For short‑lived or serverless functions you may prefer no disk cache to minimize I/O; for long‑running workers disk caching reduces cold‑start latency and load on the identity provider across restarts / rolling deploys.

Security considerations:

- Ensure the directory has restrictive ownership/permissions; the SDK creates files with `0600` but will not alter parent directory permissions.
- Tokens are bearer credentials; treat the directory like a secrets store and avoid including it in container image layers or backups.
- If you rotate credentials (client secret) the filename hash changes; old cache files become unused and can be pruned safely.

Browser usage: There is no disk concept—if executed in a browser the SDK (when strategy OAUTH) attempts to store the token in `sessionStorage` (tab‑scoped). Closing the tab clears the cache; a new tab will fetch a fresh token.

If you need a custom persistence strategy (e.g. Redis / encrypted keychain), wrap the client and periodically call `client.forceAuthRefresh()` while storing and re‑injecting the token via a headers hook; first measure whether the built‑in disk cache already meets your needs.

## Self-signed TLS / mTLS (Node only)

The SDK supports custom TLS certificates via environment variables. This is useful for:

- **Self-signed server certificates** — trust a CA that signed your server's certificate, without presenting a client identity.
- **Mutual TLS (mTLS)** — present a client certificate and key to prove the client's identity.
- **Both** — trust a custom CA _and_ present client credentials.

### Trusting a self-signed server certificate

Set only the CA certificate to trust the server's self-signed certificate:

```bash
# Path to PEM file:
CAMUNDA_MTLS_CA_PATH=/path/to/ca.pem

# Or inline PEM (must contain real newlines, not literal '\n'):
CAMUNDA_MTLS_CA="$(cat /path/to/ca.pem)"
```

### Mutual TLS (client certificate)

To present a client certificate for mutual TLS, provide both the certificate and private key:

```bash
CAMUNDA_MTLS_CERT_PATH=/path/to/client.crt
CAMUNDA_MTLS_KEY_PATH=/path/to/client.key

# Optional — passphrase if the key is encrypted:
# CAMUNDA_MTLS_KEY_PASSPHRASE=secret
```

### Full mTLS with custom CA

Combine a custom CA with client credentials:

```bash
CAMUNDA_MTLS_CA_PATH=/path/to/ca.pem
CAMUNDA_MTLS_CERT_PATH=/path/to/client.crt
CAMUNDA_MTLS_KEY_PATH=/path/to/client.key
```

Inline PEM values (`CAMUNDA_MTLS_CERT`, `CAMUNDA_MTLS_KEY`, `CAMUNDA_MTLS_CA`) take precedence over their `_PATH` counterparts. An `https.Agent` is attached to all outbound calls (including token fetches).

## Branded Keys

Import branded key helpers directly:

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeBrandedKeysImport+ReadmeBrandedKeys -->

```ts

  ProcessDefinitionKey,
  ProcessInstanceKey,
} from "@camunda8/orchestration-cluster-api";

const defKey = ProcessDefinitionKey.assumeExists("2251799813686749");
// @ts-expect-error – cannot assign def key to instance key
const bad: ProcessInstanceKey = defKey;
```

They are zero‑cost runtime strings with compile‑time separation.

## Cancelable Operations

All methods return a `CancelablePromise<T>`:

<!-- snippet-source: examples/readme.ts | regions: ReadmeCancelable -->

```ts
const p = camunda.searchProcessInstances(
  { filter: { processDefinitionKey: defKey } },
  { consistency: { waitUpToMs: 0 } }
);
setTimeout(() => p.cancel(), 100); // best‑effort cancel
try {
  await p; // resolves if not cancelled
} catch (e) {
  if (isSdkError(e) && e.name === "CancelSdkError") {
    console.log("Operation cancelled");
  } else throw e;
}
```

Notes:

- Rejects with `CancelSdkError`.
- Cancellation classification runs first so aborted fetches are never downgraded to generic network errors.
- Abort is immediate and idempotent; underlying fetch is signalled.

## Functional (fp-ts style) Surface (Opt-In Subpath)

@experimental - this feature is not guaranteed to be tested or stable.

> **Peer dependency:** `fp-ts` is an optional peer dependency. If you use real `fp-ts` functions
> (e.g. `pipe`, `TE.match`) alongside this subpath, install it separately:
>
> ```sh
> npm install fp-ts
> ```
>
> The `/fp` subpath works without `fp-ts` installed — it exposes structurally-compatible
> `Either`/`TaskEither` shapes that interoperate with `fp-ts` but do not require it at runtime.

The main entry stays minimal. To opt in to a TaskEither-style facade & helper combinators import from the dedicated subpath:

<!-- snippet-exempt: uses SDK /fp subpath not available in examples project -->

```ts

  createCamundaFpClient,
  retryTE,
  withTimeoutTE,
  eventuallyTE,
  isLeft,
} from "@camunda8/orchestration-cluster-api/fp";

const fp = createCamundaFpClient();
const deployTE = fp.deployResourcesFromFiles(["./bpmn/process.bpmn"]);
const deployed = await deployTE();
if (isLeft(deployed)) throw deployed.left; // DomainError union

// Chain with fp-ts (optional) – the returned thunks are structurally compatible with TaskEither
// import { pipe } from 'fp-ts/function'; import * as TE from 'fp-ts/TaskEither';
```

Why a subpath?

- Keeps base bundle lean for the 80% use case.
- No hard dependency on `fp-ts` at runtime; only structural types.
- Advanced users can compose with real `fp-ts` without pulling the effect model into the default import path.

Exports available from `.../fp`:

- `createCamundaFpClient` – typed facade (methods return `() => Promise<Either<DomainError,T>>`).
- Type guards: `isLeft`, `isRight`.
- Error / type aliases: `DomainError`, `TaskEither`, `Either`, `Left`, `Right`, `Fpify`.
- Combinators: `retryTE`, `withTimeoutTE`, `eventuallyTE`.

DomainError union currently includes:

- `CamundaValidationError`
- `EventualConsistencyTimeoutError`
- HTTP-like error objects (status/body/message) produced by transport
- Generic `Error`

You can refine left-channel typing later by mapping HTTP status codes or discriminator fields.

## Eventual Consistency Polling

Some endpoints accept consistency management options. Pass a `consistency` block (where supported) with `waitUpToMs` and optional `pollIntervalMs` (default 500). If the condition is not met within timeout an `EventualConsistencyTimeoutError` is thrown.

To consume eventual polling in a non‑throwing fashion set the client error mode before invoking an eventually consistent method:
At present the canonical client operates in throwing mode. Non‑throwing adaptation (Result / fp-ts) is achieved via the functional wrappers rather than mutating the base client.

### Options

`consistency` object fields (all optional except `waitUpToMs`):

| Field            | Type                                      | Description                                                                                                                                                                                                      |
| ---------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `waitUpToMs`     | `number`                                  | Maximum total time to wait before failing. `0` disables polling and returns the first response immediately.                                                                                                      |
| `pollIntervalMs` | `number`                                  | Base delay between attempts (minimum enforced at 10ms). Defaults to `500` or the value of `CAMUNDA_SDK_EVENTUAL_POLL_DEFAULT_MS` if provided.                                                                    |
| `predicate`      | `(result) => boolean \| Promise<boolean>` | Custom success condition. If omitted, non-GET endpoints default to: first 2xx body whose `items` array (if present) is non-empty.                                                                                |
| `trace`          | `boolean`                                 | When true, logs each 200 response body (truncated ~1KB) before predicate evaluation and emits a success line with elapsed time when the predicate passes. Requires log level `debug` (or `trace`) to see output. |
| `onAttempt`      | `(info) => void`                          | Callback after each attempt: `{ attempt, elapsedMs, remainingMs, status, predicateResult, nextDelayMs }`.                                                                                                        |
| `onComplete`     | `(info) => void`                          | Callback when predicate succeeds: `{ attempts, elapsedMs }`. Not called on timeout.                                                                                                                              |

### Trace Logging

Enable by setting `trace: true` inside `consistency`. Output appears under the `eventual` log scope at level `debug` so you must raise the SDK log level (e.g. `CAMUNDA_SDK_LOG_LEVEL=debug`).

Emitted lines (examples):

```
[camunda-sdk][debug][eventual] op=searchJobs attempt=3 trace body={"items":[]}
[camunda-sdk][debug][eventual] op=searchJobs attempt=5 status=200 predicate=true elapsed=742ms totalAttempts=5
```

Use this to understand convergence speed and data shape evolution during tests or to diagnose slow propagation.

### Example

<!-- snippet-source: examples/readme.ts | regions: ReadmeEventualConsistency -->

```ts
const jobs = await camunda.searchJobs(
  {
    filter: { type: "payment" },
  },
  {
    consistency: {
      waitUpToMs: 5000,
      pollIntervalMs: 200,
      trace: true,
      predicate: (r) =>
        Array.isArray(r.items) && r.items.some((j) => j.state === "CREATED"),
    },
  }
);
```

On timeout an `EventualConsistencyTimeoutError` includes diagnostic fields: `{ attempts, elapsedMs, lastStatus, lastResponse, operationId }`.

## Logging

Per‑client logger; no global singleton. The level defaults from `CAMUNDA_SDK_LOG_LEVEL` (default `error`).

<!-- snippet-source: examples/readme.ts | regions: ReadmeLogging -->

```ts
const client = createCamundaClient({
  log: {
    level: "info",
    transport: (evt) => {
      // evt: { level, scope, ts, args, code?, data? }
      console.log(JSON.stringify(evt));
    },
  },
});

const log = client.logger("worker");
log.debug(() => ["expensive detail only if enabled", { meta: 1 }]);
log.code("info", "WORK_START", "Starting work loop", { pid: process.pid });
```

Lazy args (functions with zero arity) are only invoked if the level is enabled.

Update log level / transport at runtime via `client.configure({ log: { level: 'debug' } })`.

### Default Behaviour

Without any explicit `log` option:

- Level = `error` (unless `CAMUNDA_SDK_LOG_LEVEL` is set)
- Transport = console (`console.error` / `console.warn` / `console.log`)
- Only `error` level internal events are emitted (e.g. strict validation failure summaries, fatal auth issues)
- No info/debug/trace noise by default

To silence everything set level to `silent`:

```bash
CAMUNDA_SDK_LOG_LEVEL=silent
```

To enable debug logs via env:

```bash
CAMUNDA_SDK_LOG_LEVEL=debug
```

### Unsafe Deep Diagnostics (`silly`)

Setting `CAMUNDA_SDK_LOG_LEVEL=silly` enables the deepest diagnostics. In addition to everything at `trace`, the SDK will emit HTTP request and response body previews for all HTTP methods under the `telemetry` scope (log line contains `http.body`). This can leak sensitive information (secrets, PII). A warning (`log.level.silly.enabled`) is emitted on client construction. Use only for short‑lived local debugging; never enable in production or share captured logs externally. Body output is truncated (max ~4KB) and form-data parts identify uploaded files as `[File]`.

### Bring Your Own Logger

Provide a `transport` function to forward structured `LogEvent` objects into any logging library.

#### Pino

<!-- snippet-exempt: uses external pino dependency -->

```ts

const p = pino();
const client = createCamundaClient({
  log: {
    level: 'info',
    transport: e => {
      const lvl = e.level === 'trace' ? 'debug' : e.level; // map trace
      p.child({ scope: e.scope, code: e.code }).[lvl]({ ts: e.ts, data: e.data, args: e.args }, e.args.filter(a=>typeof a==='string').join(' '));
    }
  }
});
```

#### Winston

<!-- snippet-exempt: uses external winston dependency -->

```ts

const w = winston.createLogger({
  transports: [new winston.transports.Console()],
});
const client = createCamundaClient({
  log: {
    level: "debug",
    transport: (e) => {
      const lvl = e.level === "trace" ? "silly" : e.level; // winston has 'silly'
      w.log({
        level: lvl,
        message: e.args.filter((a) => typeof a === "string").join(" "),
        scope: e.scope,
        code: e.code,
        data: e.data,
        ts: e.ts,
      });
    },
  },
});
```

#### loglevel

<!-- snippet-exempt: uses external loglevel dependency -->

```ts

log.setLevel("info"); // host app level
const client = createCamundaClient({
  log: {
    level: "info",
    transport: (e) => {
      if (e.level === "silent") return;
      const method = (
        ["error", "warn", "info", "debug"].includes(e.level) ? e.level : "debug"
      ) as "error" | "warn" | "info" | "debug";
      (log as any)[method](
        `[${e.scope}]`,
        e.code ? `${e.code}:` : "",
        ...e.args
      );
    },
  },
});
```

#### Notes

- Map `trace` to the nearest available level if your logger lacks it.
- Use `log.code(level, code, msg, data)` for machine-parsable events.
- Redact secrets before logging if you add token contents to custom messages.
- Reconfigure later: `client.configure({ log: { level: 'warn' } })` updates only that client.
- When the effective level is `debug` (or `trace`), the client emits a lazy `config.hydrated` event on construction and `config.reconfigured` on `configure()`, each containing the redacted effective configuration `{ config: { CAMUNDA_... } }`. Secrets are already masked using the SDK's redaction rules.

## Errors

May throw:

- Network / fetch failures
- Non‑2xx HTTP responses
- Validation errors (strict mode)
- `EventualConsistencyTimeoutError`
- `CancelSdkError` on cancellation

### Typed Error Handling

All SDK-thrown operational errors normalize to a discriminated union (`SdkError`) when they originate from HTTP, network, auth, or validation layers. Use the guard `isSdkError` to narrow inside a catch:

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeErrorHandlingImport+ReadmeErrorHandling -->

```ts

  createCamundaClient,
  isSdkError,
} from "@camunda8/orchestration-cluster-api";

const client = createCamundaClient();

try {
  await client.getTopology();
} catch (e) {
  if (isSdkError(e)) {
    switch (e.name) {
      case "HttpSdkError":
        console.error("HTTP failure", e.status, e.operationId);
        break;
      case "ValidationSdkError":
        console.error("Validation issue on", e.operationId, e.side, e.issues);
        break;
      case "AuthSdkError":
        console.error("Auth problem", e.message, e.status);
        break;
      case "CancelSdkError":
        console.error("Operation cancelled", e.operationId);
        break;
      case "NetworkSdkError":
        console.error("Network layer error", e.message);
        break;
    }
    return;
  }
  // Non-SDK (programmer) error; rethrow or wrap
  throw e;
}
```

Guarantees:

- HTTP errors expose `status` and optional `operationId`.
- If the server returns RFC 9457 / RFC 7807 Problem Details JSON (`type`, `title`, `status`, `detail`, `instance`) these fields are passed through on the `HttpSdkError` when present.
- Validation errors expose `side` and `operationId`.
- Classification is best-effort; unknown shapes fall back to `NetworkSdkError`.

> Advanced: You can still layer your own domain errors on top (e.g. translate certain status codes) by mapping `SdkError` into custom discriminants.

### Functional / Non‑Throwing Variant - EXPERIMENTAL

_Note that this feature is experimental and subject to change._

If you prefer FP‑style explicit error handling instead of exceptions, use the result client wrapper:

<!-- snippet-source: examples/readme-imports.txt,examples/readme.ts | regions: ReadmeResultClientImport+ReadmeResultClient -->

```ts

  createCamundaResultClient,
  isOk,
} from "@camunda8/orchestration-cluster-api";

const camundaR = createCamundaResultClient();
const res = await camundaR.createDeployment({ resources: [file] });
if (isOk(res)) {
  console.log("Deployment key", res.value.deploymentKey);
} else {
  console.error("Deployment failed", res.error);
}
```

API surface differences:

- All async operation methods return `Promise<Result<T>>` where `Result<T> = { ok: true; value: T } | { ok: false; error: unknown }`.
- No exceptions are thrown for HTTP / validation errors (cancellation and programmer errors like invalid argument sync throws are still converted to `{ ok:false }`).
- The original throwing client is available via `client.inner` if you need to mix styles.

Helpers:

<!-- snippet-exempt: one-liner import example -->

```ts

```

When to use:

- Integrating with algebraic effects / functional pipelines.
- Avoiding try/catch nesting in larger orchestration flows.
- Converting to libraries expecting an Either/Result pattern.

### fp-ts Adapter (TaskEither / Either) - EXPERIMENTAL

_Note that this feature is experimental and subject to change._

For projects using `fp-ts`, wrap the throwing client in a lazy `TaskEither` facade:

<!-- snippet-exempt: requires external fp-ts dependency -->

```ts

const fp = createCamundaFpClient();

const deployTE = fp.createDeployment({ resources: [file] }); // TaskEither<unknown, ExtendedDeploymentResult>

pipe(
  deployTE(), // invoke the task (returns Promise<Either>)
  (then) => then // typical usage would use TE.match / TE.fold; shown expanded for clarity
);

// With helpers
const task = fp.createDeployment({ resources: [file] });
const either = await task();
if (either._tag === "Right") {
  console.log(either.right.deployments.length);
} else {
  console.error("Error", either.left);
}
```

Notes:

- No runtime dependency on `fp-ts`; adapter implements a minimal `Either` shape. Structural typing lets you lift into real `fp-ts` functions (`fromEither`, etc.).
- Each method becomes a function returning `() => Promise<Either<E,A>>` (a `TaskEither` shape). Invoke it later to execute.
- Cancellation: calling `.cancel()` on the original promise isn’t surfaced; if you need cancellation use the base client directly.
- For richer interop, you can map the returned factory to `TE.tryCatch` in userland.

## Pagination

Search endpoints expose typed request bodies that include pagination fields. Provide the desired page object; auto‑pagination is not (yet) bundled.

## Configuration Reference

Generated doc enumerating all supported environment variables (types, defaults, conditional requirements, redaction rules) is produced at build time:

```
./docs/CONFIG_REFERENCE.md
```

## Deploying Resources (File-only)

The deployment endpoint requires each resource to have a filename (extension used to infer type: `.bpmn`, `.dmn`, `.form` / `.json`). Extensions influence server classification; incorrect or missing extensions may yield unexpected results. Pass an array of `File` objects (NOT plain `Blob`).

### Browser

<!-- snippet-source: examples/readme.ts | regions: ReadmeDeployBrowser -->

```ts
const bpmnXml = `<definitions id="process" xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL">...</definitions>`;
const file = new File([bpmnXml], "order-process.bpmn", {
  type: "application/xml",
});
const result = await camunda.createDeployment({ resources: [file] });
console.log(result.deployments.length);
```

From an existing Blob:

<!-- snippet-exempt: uses hypothetical getBlob() function -->

```ts
const blob: Blob = getBlob();
const file = new File([blob], "model.bpmn");
await camunda.createDeployment({ resources: [file] });
```

### Node (Recommended Convenience)

Use the built-in helper `deployResourcesFromFiles(...)` to read local files and create `File` objects automatically. It returns the enriched `ExtendedDeploymentResult` (adds typed arrays: `processes`, `decisions`, `decisionRequirements`, `forms`, `resources`).

<!-- snippet-source: examples/readme.ts | regions: ReadmeDeployNode -->

```ts
const result = await camunda.deployResourcesFromFiles([
  "./bpmn/order-process.bpmn",
  "./dmn/discount.dmn",
  "./forms/order.form",
]);

console.log(result.processes.map((p) => p.processDefinitionId));
console.log(result.decisions.length);
```

With explicit tenant (overriding tenant from configuration):

<!-- snippet-exempt: small variant of injected deploy example above -->

```ts
await camunda.deployResourcesFromFiles(["./bpmn/order-process.bpmn"], {
  tenantId: "tenant-a",
});
```

Error handling:

<!-- snippet-exempt: small variant of injected deploy example above -->

```ts
try {
  await camunda.deployResourcesFromFiles([]); // throws (empty array)
} catch (e) {
  console.error("Deployment failed:", e);
}
```

Manual construction alternative (if you need custom logic):

<!-- snippet-exempt: alternative construction pattern using node:buffer -->

```ts

const bpmnXml =
  '<definitions id="process" xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"></definitions>';
const file = new File([Buffer.from(bpmnXml)], "order-process.bpmn", {
  type: "application/xml",
});
await camunda.createDeployment({ resources: [file] });
```

Helper behavior:

- Dynamically imports `node:fs/promises` & `node:path` (tree-shaken from browser bundles)
- Validates Node environment (throws in browsers)
- Lightweight MIME inference: `.bpmn|.dmn|.xml -> application/xml`, `.json|.form -> application/json`, fallback `application/octet-stream`
- Rejects empty path list

Empty arrays are rejected. Always use correct extensions so the server can classify each resource.

## Testing Patterns

Create isolated clients per test file:

<!-- snippet-source: examples/readme.ts | regions: ReadmeTestingClient -->

```ts
const client = createCamundaClient({
  config: {
    CAMUNDA_REST_ADDRESS: "http://localhost:8080",
    CAMUNDA_AUTH_STRATEGY: "NONE",
  },
});
```

Inject a mock fetch:

<!-- snippet-source: examples/readme.ts | regions: ReadmeTestingMock -->

```ts
const client = createCamundaClient({
  fetch: async (_input, _init) =>
    new Response(JSON.stringify({ ok: true }), { status: 200 }),
});
```

## API Documentation

Generate an HTML API reference site with TypeDoc (public entry points only):

```bash
npm run docs:api
```

Output: static site in `docs/api` (open `docs/api/index.html` in a browser or serve the folder, e.g. `npx http-server docs/api`). Entry points: `src/index.ts`, `src/logger.ts`, `src/fp/index.ts`. Internal generated code, scripts, tests are excluded and private / protected members are filtered. Regenerate after changing public exports.

## Contributing

We welcome issues and pull requests. Please read the [CONTRIBUTING.md](https://github.com/camunda/orchestration-cluster-api-js/blob/main/CONTRIBUTING.md) guide before opening a PR to understand:

- Deterministic builds policy (no committed timestamps) – see CONTRIBUTING
- Commit message conventions (Conventional Commits with enforced subject length)
- Release workflow & how to dry‑run semantic‑release locally
- Testing strategy (unit vs integration)
- Performance and security considerations

## License

Apache 2.0

---

## Function: createLogger()


```ts
function createLogger(opts?): Logger;
```

## Parameters

### opts?

[`CreateLoggerOptions`](../../index/interfaces/CreateLoggerOptions.md) = `{}`

## Returns

[`Logger`](../interfaces/Logger.md)

---

## logger


## Interfaces

- [LogEvent](interfaces/LogEvent.md)
- [Logger](interfaces/Logger.md)

## Type Aliases

- [LogLevel](type-aliases/LogLevel.md)
- [LogTransport](type-aliases/LogTransport.md)

## Functions

- [createLogger](functions/createLogger.md)

---

## Interface: LogEvent


## Properties

### args

```ts
args: any[];
```

---

### code?

```ts
optional code?: string;
```

---

### data?

```ts
optional data?: any;
```

---

### level

```ts
level: LogLevel;
```

---

### scope

```ts
scope: string;
```

---

### ts

```ts
ts: number;
```

---

## Interface: Logger


## Methods

### code()

```ts
code(
   level,
   code,
   msg,
   data?): void;
```

#### Parameters

##### level

[`LogLevel`](../type-aliases/LogLevel.md)

##### code

`string`

##### msg

`string`

##### data?

`any`

#### Returns

`void`

---

### debug()

```ts
debug(...a): void;
```

#### Parameters

##### a

...`any`[]

#### Returns

`void`

---

### error()

```ts
error(...a): void;
```

#### Parameters

##### a

...`any`[]

#### Returns

`void`

---

### info()

```ts
info(...a): void;
```

#### Parameters

##### a

...`any`[]

#### Returns

`void`

---

### level()

```ts
level(): LogLevel;
```

#### Returns

[`LogLevel`](../type-aliases/LogLevel.md)

---

### scope()

```ts
scope(child): Logger;
```

#### Parameters

##### child

`string`

#### Returns

`Logger`

---

### setLevel()

```ts
setLevel(level): void;
```

#### Parameters

##### level

[`LogLevel`](../type-aliases/LogLevel.md)

#### Returns

`void`

---

### setTransport()

```ts
setTransport(t?): void;
```

#### Parameters

##### t?

[`LogTransport`](../type-aliases/LogTransport.md)

#### Returns

`void`

---

### silly()

```ts
silly(...a): void;
```

#### Parameters

##### a

...`any`[]

#### Returns

`void`

---

### trace()

```ts
trace(...a): void;
```

#### Parameters

##### a

...`any`[]

#### Returns

`void`

---

### warn()

```ts
warn(...a): void;
```

#### Parameters

##### a

...`any`[]

#### Returns

`void`

---

## Type Alias: LogLevel


```ts
type LogLevel =
  "silent" | "error" | "warn" | "info" | "debug" | "trace" | "silly";
```

---

## Type Alias: LogTransport


```ts
type LogTransport = (e) => void;
```

## Parameters

### e

[`LogEvent`](../interfaces/LogEvent.md)

## Returns

`void`

---

## @camunda8/orchestration-cluster-api


## Modules

- [fp](fp/index.md)
- [index](index/index.md)
- [logger](logger/index.md)

---

## Manage backpressure with the TypeScript SDK

Learn how to manage backpressure with the TypeScript SDK.

## Manage backpressure

The Orchestration Cluster REST API client implements adaptive backpressure management.

- It automatically handles retries and backoff in response to backpressure signals from the server.
- The SDK applies global backpressure management to throttle operations when the server returns backpressure.

:::info
To learn more about backpressure in Camunda 8, see [backpressure](/self-managed/components/orchestration-cluster/zeebe/operations/backpressure.md).
:::

### Enable backpressure management

This behavior is controlled by the `CAMUNDA_SDK_BACKPRESSURE_PROFILE` environment variable and is enabled by default.

- When enabled, SDK calls do not fail when the server responds with a backpressure signal. Instead, the SDK retries these calls after an increasing backoff period. Additional SDK calls made during backpressure are delayed proactively rather than each needing to receive a backpressure signal.

- When a retried operation succeeds, the SDK reduces its internal backpressure status and removes throttling. This allows the SDK to match the server’s capacity and optimize throughput.

- This adaptive mechanism can lead to 2x–5x higher performance under load. See [Patterns to use today to make Camunda 8 apps even more reliable](https://www.camundacon.com/event-session/camundacon-new-york-2025/patterns-to-use-today-to-make-camunda-8-apps-even-more-reliable?on_demand=true) for a demonstration.

### Disable backpressure management

To disable SDK backpressure management and throw immediately when the server responds with a backpressure signal, set `CAMUNDA_SDK_BACKPRESSURE_PROFILE=LEGACY`.

---

## TypeScript SDK

Use the TypeScript SDK to connect to Camunda 8, deploy process models, and work with the Orchestration Cluster API.

## About this SDK

The TypeScript SDK provides typed access to Camunda 8 APIs.

- It includes IntelliSense support and works in both JavaScript and TypeScript projects.
- The [Camunda 8 TypeScript SDK for Node.js](https://github.com/camunda/camunda-8-js-sdk) is available via [npm](https://www.npmjs.com/package/@camunda8/sdk).

### When to use this package

Use the [`@camunda8/sdk`](https://www.npmjs.com/package/@camunda8/sdk) package if:

- You need to use the gRPC API for job streaming.
- Your server target is Camunda 8.7 or earlier.
- You want to migrate an existing application to the Orchestration Cluster API.

:::info
If you do not need to use gRPC, use the [Orchestration Cluster API TypeScript client](oca-client.md).
:::

## Prerequisites

The following prerequisites are required to use the TypeScript SDK:

| Prerequisite | Description                                                                                                                                                                                                                                                                                                                                                                              |
| :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Node.js      | The SDK runs in Node.js and cannot run in a web browser due to [technical limitations](https://github.com/camunda/camunda-8-js-sdk/issues/79).If you want to write an application in the web browser, use `@camunda8/orchestration-cluster-api`.See [Get started with the Orchestration Cluster API TypeScript client](./oca-client.md). |

## Get started

Get started with the Orchestration Cluster API.

1. Create a new Node.js project that uses TypeScript:

   ```bash
   npm init -y
   npm install -D typescript
   npx tsc --init
   ```

2. Install the SDK as a dependency:

   ```bash
   npm i @camunda8/sdk
   ```

:::info

- A complete working version of the quickstart code is [available on GitHub](https://github.com/camunda-community-hub/c8-sdk-demo).
- For earlier versions (Camunda 8.7 and below), refer to the [SDK README file](https://github.com/camunda/camunda-8-js-sdk).

:::

## Configure the connection

Choose one of the following configuration options:

- Explicit configuration in code
- Zero-configuration constructor with environment variables

The recommended configuration is via the zero-configuration constructor, with all values for configuration supplied via environment variables. This makes rotation, secret management, and environment promotion safer and simpler.

**The environment variables you must set are outlined below. Replace these with your secrets and URLs.**

:::info
To configure a client and capture these values when creating the client, see [setting up client connection credentials](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client).
:::

### Self-managed configuration

Minimal configuration:

```bash
# Self-Managed with Orchestration Cluster API
export ZEEBE_REST_ADDRESS='http://localhost:8080/v2'
```

With OAuth:

```bash
export ZEEBE_REST_ADDRESS='http://localhost:8080/v2'
export ZEEBE_GRPC_ADDRESS='grpc://localhost:26500'
export ZEEBE_CLIENT_ID='zeebe'
export ZEEBE_CLIENT_SECRET='zecret'
export CAMUNDA_OAUTH_URL='http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token'
```

If you are running with multi-tenancy enabled:

```bash
export CAMUNDA_TENANT_ID='my-tenant' # tenant <default> used by default if none set
```

### Camunda SaaS configuration

```bash
export ZEEBE_REST_ADDRESS='5c34c0a7-...-125615f7a9b9.syd-1.zeebe.camunda.io'
export ZEEBE_GRPC_ADDRESS='grpcs://5c34c0a7-...-125615f7a9b9.syd-1.zeebe.camunda.io:443'
export ZEEBE_CLIENT_ID='yvvURO...'
export ZEEBE_CLIENT_SECRET='iJJu-SHg...'
export CAMUNDA_OAUTH_URL='https://login.cloud.camunda.io/oauth/token'
```

:::caution
To set these values explicitly in code (not recommended), pass them with the same key names to the `Camunda8` constructor.
:::

## Use the SDK

1. Create a file `index.ts` in your IDE.
2. Import the SDK:

   ```typescript

   const clientFactory = new Camunda8();
   ```

3. Get an Orchestration API client. This is used to deploy process models and start process instances:

   ```typescript
   const camunda = clientFactory.getOrchestrationClusterApiClient();
   ```

### Deploy a process model

Next, deploy a process model. Network operations are asynchronous and methods that operate over the network return promises. Wrap the main function in an `async` function:

```typescript
async function main() {
  const deployResponse = await camunda.deployResourcesFromFiles([
    path.join(process.cwd(), "process.bpmn"),
  ]);
  console.log(
    `[Camunda] Deployed process ${deployResponse.processes[0].processDefinitionId}`
  );
}

main(); // remember to invoke the function
```

Paste the process model XML below into a file named `process.bpmn`:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:zeebe="http://camunda.org/schema/zeebe/1.0" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:modeler="http://camunda.org/schema/modeler/1.0" id="Definitions_14f3xb6" targetNamespace="http://bpmn.io/schema/bpmn" exporter="Camunda Modeler" exporterVersion="5.36.1" modeler:executionPlatform="Camunda Cloud" modeler:executionPlatformVersion="8.8.0">
  <bpmn:process id="c8-sdk-demo" name="C8 SDK Demo" isExecutable="true">
    <bpmn:startEvent id="StartEvent_1">
      <bpmn:outgoing>Flow_0yqo0wz</bpmn:outgoing>
    </bpmn:startEvent>
    <bpmn:sequenceFlow id="Flow_0yqo0wz" sourceRef="StartEvent_1" targetRef="Activity_1gwbbuy" />
    <bpmn:sequenceFlow id="Flow_0qugen1" sourceRef="Activity_1gwbbuy" targetRef="Activity_0tp91ve" />
    <bpmn:endEvent id="Event_0j28rou">
      <bpmn:incoming>Flow_03qgl0x</bpmn:incoming>
    </bpmn:endEvent>
    <bpmn:sequenceFlow id="Flow_03qgl0x" sourceRef="Activity_0tp91ve" targetRef="Event_0j28rou" />
    <bpmn:serviceTask id="Activity_1gwbbuy" name="Service worker task">
      <bpmn:extensionElements>
        <zeebe:taskDefinition type="service-task" />
      </bpmn:extensionElements>
      <bpmn:incoming>Flow_0yqo0wz</bpmn:incoming>
      <bpmn:outgoing>Flow_0qugen1</bpmn:outgoing>
    </bpmn:serviceTask>
    <bpmn:userTask id="Activity_0tp91ve" name="User task">
      <bpmn:extensionElements>
        <zeebe:userTask />
      </bpmn:extensionElements>
      <bpmn:incoming>Flow_0qugen1</bpmn:incoming>
      <bpmn:outgoing>Flow_03qgl0x</bpmn:outgoing>
    </bpmn:userTask>
  </bpmn:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
    <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="c8-sdk-demo">
      <bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">
        <dc:Bounds x="179" y="99" width="36" height="36" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Event_0j28rou_di" bpmnElement="Event_0j28rou">
        <dc:Bounds x="592" y="99" width="36" height="36" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_1rvlo9s_di" bpmnElement="Activity_1gwbbuy">
        <dc:Bounds x="270" y="77" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_1wxn0pq_di" bpmnElement="Activity_0tp91ve">
        <dc:Bounds x="430" y="77" width="100" height="80" />
        <bpmndi:BPMNLabel />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge id="Flow_0yqo0wz_di" bpmnElement="Flow_0yqo0wz">
        <di:waypoint x="215" y="117" />
        <di:waypoint x="270" y="117" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0qugen1_di" bpmnElement="Flow_0qugen1">
        <di:waypoint x="370" y="117" />
        <di:waypoint x="430" y="117" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_03qgl0x_di" bpmnElement="Flow_03qgl0x">
        <di:waypoint x="530" y="117" />
        <di:waypoint x="592" y="117" />
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</bpmn:definitions>
```

For reference, this is the model you use in this example:

![Example BPMN process model](../img/process-model.png)

Run the program to deploy the process model to Camunda:

```bash
npx tsx index.ts
```

If your configuration is correct, you should see output similar to the following:

```
[Camunda] Deployed process c8-sdk-demo
```

### Create a service worker

Outside the main function, add the following code:

```typescript
console.log("Starting worker...");
const worker = camunda.createJobWorker({
  jobType: "service-task",
  workerName: "test-worker",
  maxParallelJobs: 20,
  pollIntervalMs: 1000,
  pollTimeoutMs: 50_000,
  jobTimeoutMs: 5000,
  jobHandler: (job) => {
    console.log(
      `[worker]: Completing job ${job.jobKey} from process ${job.processInstanceKey}\n`
    );
    return job.complete({
      serviceTaskOutcome: "We did it!",
    });
  },
});
```

This code starts a service task worker that runs in an asynchronous loop and invokes `jobHandler` when a job of type `service-task` becomes available.

The handler must return a job completion function such as `fail`, `complete`, `error`, or `ignore`. The type system enforces this to ensure every code path responds to Zeebe after taking a job. The `job.complete` function can take an object with variables to update.

### Create a programmatic user task worker

The process has a [user task](/guides/getting-started-orchestrate-human-tasks.md) after the service task. The service task worker completes the service task job. You complete the user task using the Tasklist API client.

Add the following code below the service worker:

```typescript
// User task poller
const last = new Set<OrchestrationLifters.UserTaskKey>();
const userTaskPoller = camunda.searchUserTasks(
  {
    filter: {
      state: "CREATED",
    },
  },
  {
    // To set up a subscription, set waitUpToMs to Infinity
    consistency: {
      waitUpToMs: Infinity,
      pollIntervalMs: 1_000,
      // predicate now becomes a polling subscription function
      predicate: async (results) => {
        // polling memoization - handles idempotency with eventually consistent mutation
        const current = results.items.filter(
          (item) => !last.has(item.userTaskKey)
        );
        last.clear();
        results.items.forEach((task) => last.add(task.userTaskKey));
        for (const userTask of current) {
          console.log(
            `[usertask poller]: Claiming task ${userTask.userTaskKey} from process ${userTask.processInstanceKey}\n`
          );
          await camunda.assignUserTask({
            userTaskKey: userTask.userTaskKey,
            assignee: "jwulf",
          });

          console.log(
            `[usertask poller]: Completing user task ${userTask.userTaskKey} from process ${userTask.processInstanceKey}\n`
          );
          await camunda.completeUserTask({
            userTaskKey: userTask.userTaskKey,
            variables: {
              userTaskStatus: "Got done",
            },
          });
        }
        return false; // return false to keep polling
      },
    },
  }
);
```

You now have an asynchronously polling service and user task worker.

The final step is to create a process instance.

### Create a process instance

There are two options for creating a process instance:

- For long-running processes, use `createProcessInstance`. It returns as soon as the process instance is created with the process instance ID.
- For the shorter-running process we are using, set `awaitCompletion: true`. It awaits the completion of the process and returns with the final variable values.

1. Locate the following line in the `main` function:

   ```typescript
   console.log(
     `[Zeebe] Deployed process ${res.deployments[0].process.bpmnProcessId}`
   );
   ```

2. Inside the `main` function, add the following:

   ```typescript
   const result = await camunda.createProcessInstanceWithResult({
     processDefinitionId,
     variables: {
       userTaskStatus: "Needs doing",
     },
     awaitCompletion: true,
   });
   console.log(
     `[Camunda] Finished Process Instance ${result.processInstanceKey}`
   );
   console.log(
     `[Camunda] userTaskStatus is "${result.variables.userTaskStatus}"`
   );
   console.log(
     `[Camunda] serviceTaskOutcome is "${result.variables.serviceTaskOutcome}"`
   );
   worker.stop();
   userTaskPoller.catch((e) => e); // Swallow cancel exception
   userTaskPoller.cancel(); // Cancel poller to exit app
   ```

3. Run the program with the following command:

   ```bash
   npx tsx index.ts
   ```

You see output similar to the following:

```
[Camunda] Deployed process c8-sdk-demo
[worker]: Completing job 4503599632829668 from process 4503599632829662
[usertask poller]: Claiming task 4503599632829678 from process 4503599632829662
[usertask poller]: Completing user task 4503599632829678 from process 4503599632829662
[Camunda] Finished Process Instance 4503599632829662
[Camunda] userTaskStatus is "Got done"
[Camunda] serviceTaskOutcome is "We did it!"
```

The program continues running until you press `Ctrl+C` because both the service worker and the user task poller run in continuous loops.

To explore more SDK functionality, use the examples below.

### Retrieve a process instance

When you create a long-running process instance, you typically use `createProcessInstance` and get back the process instance key of the running process immediately instead of waiting for it to complete.

To examine the process instance status, use the process instance key to query the Operate API. You can also check completed process instances in the same way. In the following example, you query the process instance created earlier.

1. Locate the following line in the `main` function:

   ```typescript
   console.log(
     `[Camunda] serviceTaskOutcome is "${result.variables.serviceTaskOutcome}"`
   );
   ```

2. Add the following after this line and inside the `main` function:

   ```typescript
   const historicalProcessInstance = await camunda.getProcessInstance(
     {
       processInstanceKey: result.processInstanceKey,
     },
     { consistency: { waitUpToMs: 5000 } }
   );
   console.log("[Camunda]", JSON.stringify(historicalProcessInstance, null, 2));
   ```

When you run the program now, you should see additional output similar to the following:

```
{
  processInstanceKey: 4503599632829662,
  processVersion: 1,
  processDefinitionId: 'c8-sdk-demo',
  startDate: '2025-11-08T09:11:06.157+0000',
  endDate: '2025-11-08T09:11:12.403+0000',
  state: 'COMPLETED',
  processDefinitionKey: 2251799814900879,
}
```

The state may appear as `ACTIVE` rather than `COMPLETED`. This happens because the data read over the API is historical data from the Zeebe exporter, and lags behind the actual state of the system. It is _eventually consistent_.

## Further resources

See the [complete API documentation for the SDK](https://camunda.github.io/camunda-8-js-sdk/) and the [Orchestration Cluster API client](https://camunda.github.io/orchestration-cluster-api-js/classes/index.CamundaClient.html).

---

## Manage Orchestration Cluster API data consistency

Learn how to manage eventually consistent data when using the Orchestration Cluster API.

## About eventual consistency

Data in Camunda 8 is [eventually consistent](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-data-fetching.md#data-consistency).

- To ensure that your applications behave explicitly and deterministically at runtime under different load scenarios, Orchestration Cluster API methods that access eventually consistent data take a required second parameter `consistency`.

- This parameter lets you either ignore eventual consistency or manage how your application interacts with it.

For example, if you search for a process instance immediately after you create it, the response may contain the new instance. If the data is not yet available, the search may return an empty result or a 404 error.

```typescript

const camunda = createCamundaClient();

async function main() {
  const deploymentResponse = await camunda.deployResourcesFromFile([
    "./process.bpmn",
  ]);
  const { processDefinitionKey } = deploymentResponse.processes[0];

  const { processInstanceKey } = await camunda.createProcessInstance({
    processDefinitionKey,
  });

  // May return the process instance, but more likely will return an empty set
  const runningProcessInstance = await camunda.searchProcessInstances(
    {
      filter: {
        processInstanceKey,
      },
    },
    { consistencyManagement: { waitUpToMs: 0 } }
  );
  console.log(JSON.stringify(runningProcessInstance, null, 2));
}

main();
```

To ignore eventual consistency, set `waitUpToMs` to 0. The operation returns immediately with the current API response.

In this scenario, you are more likely to receive an empty set for a search operation or a 404 error for a get operation than to find the process instance you just created. Even though the system already created the process instance and returned its key, you might still receive a result such as:

```json
{
  "items": []
}
```

In some situations, you may want to wait for eventual consistency to settle. The SDK provides you with an ergonomic surface for this.

## Manage eventual consistency

If `waitUpToMs` is set to a value greater than `0` (for example, `10_000`), the SDK polls every 500 ms for up to that duration and returns a value as soon as one is available.

For search operations, this is when the result set has a length > 0. For get operations, it is when the API returns 200 rather than 404.

If no results appear within the specified time, the operation will throw an `EventualConsistencyTimeoutError`.

This means eventually consistent operations return either a value or an error:

```typescript
// get, 0: Value or 'NOT_FOUND' exception
await camunda.getProcessInstance(
  {
    processInstanceKey,
  },
  { consistency: { waitForMs: 0 } }
);

// get, > 0: Value or EventualConsistencyTimeoutError
await camunda.getProcessInstance(
  {
    processInstanceKey,
  },
  { consistency: { waitForMs: 1_000 } }
);

// search, 0: Value, including empty set
await camunda.searchProcessInstances(
  {
    processInstanceKey,
  },
  { consistency: { waitForMs: 0 } }
);

// search, >0: Expected value or EventualConsistencyTimeoutError
await camunda.searchProcessInstances(
  {
    processInstanceKey,
  },
  { consistency: { waitForMs: 1_000 } }
);
```

Change the polling interval using the `pollIntervalMs` parameter.

For query operations, optionally provide a custom predicate via the `predicate` parameter. The predicate function receives the current result set, and returns a boolean: `false` to continue polling or `true` to accept and propagate the current results. You can use this for advanced client-side filtering or to build a subscription mechanism.

Eventually consistent operations return a cancelable promise. Calling `cancel` stops polling and cancels any in-flight network operation, then throws a `CancelSdkError`.

---

## Migrate to the Orchestration Cluster API(Typescript)

Migrate an existing Camunda 8 TypeScript application from `@camunda8/sdk` to use the `@camunda8/orchestration-cluster-api`.

## Choose a client option

For existing applications using `@camunda8/sdk`, the SDK includes the Orchestration Cluster API client by depending on the `@camunda8/orchestration-cluster-api` package and normalizing configuration to ensure forward compatibility without requiring configuration changes. Use the following guidance to choose between the SDK-bundled client and the focused `@camunda8/orchestration-cluster-api` package.

Use the bundled client if:

- You depend on APIs not supported by the focused client, such as gRPC.
- You do not care about application size and do not want to modify your environment configuration.

Import the focused client directly alongside the SDK if:

- You do not use the gRPC API.
- Your application targets Camunda 8.9 or later.
- You intend to migrate completely to the Orchestration Cluster API and remove all other API usage in your application.
- You do not mind changing or extending your application configuration.

### Key differences

Using the bundled client in `@camunda8/sdk`:

- Will always pull in as dependencies all the other API clients and their dependencies.
- Uses the same configuration variables across the various clients (the SDK normalizes configuration).

```typescript

const clientFactory = new Camunda8();
// Get a strongly typed CamundaClient
const camunda = clientFactory.getOrchestrationClusterApiClient();

// Get a loosely typed CamundaClient
const camundaLoose = clientFactory.getOrchestrationClusterApiClient();
```

Using the focused client in `@camunda8/orchestration-cluster-api`:

- Allows you to reduce the application dependency to the Orchestration Cluster API client only.
- Requires you to change the environment configuration (the focused client uses distinct configuration).

```typescript

  createCamundaClient,
  createCamundaClientLoose,
} from "@camunda8/orchestration-cluster-api";

// Get a strongly-typed CamundaClient
const camunda = createCamundaClient();

// Get a loosely-typed CamundaClient
const camundaLoose = createCamundaClientLoose();
```

As a middle ground, you can use the bundled client initially and then switch to the focused client when you are ready to update the configuration.

## Strong vs. loose typing

A feature of the Orchestration Cluster API is strong domain types. Request and response fields such as `ProcessDefinitionKey` and `ProcessDefinitionId` are distinct types, leading to better static analysis, enhanced IDE completion, more powerful refactoring, and early detection of runtime bugs.

The client implements this using [nominal typing](https://en.wikipedia.org/wiki/Nominal_type_system). You can pass a `ProcessDefinitionId` wherever a string is expected, but cannot pass a free string or a `ProcessDefinitionKey` where a `ProcessDefinitionId` is expected — even though structurally they are all type `string`.

```typescript

const camunda = new Camunda8().getOrchestrationClusterApiClient();

async function main() {
  const deploymentResponse = await camunda.deployResourcesFromFile([
    "./process.bpmn",
  ]);
  const { processDefinitionKey } = deploymentResponse.processes[0]; // nominal type is ProcessDefinitionKey
  console.log(typeof processDefinitionKey); // works — structural type is 'string'
  await camunda.createProcessInstance({
    processDefinitionId: processDefinitionKey,
  }); // error — incompatible types
}

main();
```

This approach makes output from the Orchestration Cluster API client compatible with input fields of earlier clients, but the reverse is not true. The earlier clients accept the structural types of the new client, and do not examine the nominal types at all.

```typescript

const factory = new Camunda8();
const camunda = new factory.getOrchestrationClusterApiClient();
const camundaLegacy = new factory.getCamundaRestClient();

async function main() {
  const deploymentResponse = await camunda.deployResourcesFromFile([
    "./process.bpmn",
  ]);
  const { processDefinitionKey } = deploymentResponse.processes[0]; // nominal type is ProcessDefinitionKey
  console.log(typeof processDefinitionKey); // structural type is 'string'

  const { processInstanceKey } = await camundaLegacy.createProcessInstance({
    processDefinitionKey,
  }); // works — structural type is string

  const runningProcessInstance = await camunda.searchProcessInstances(
    {
      filter: {
        processInstanceKey, // fails — legacy type is `string`, client requires `ProcessInstanceKey`
      },
    },
    { consistencyManagement: { waitUpToMs: 10_000 } }
  );
}

main();
```

## Integrate the strongly typed client

To handle this, you can either manage the type system boundary or erase nominal typing.

The new client provides lifters to deal with interoperability. For example:

```typescript

const factory = new Camunda8()
const camunda = new factory.getOrchestrationClusterApiClient()
const legacyCamunda = new factory.getCamundaRestClient()

async function main() {
    const deploymentResponse = await legacyCamunda.deployResourcesFromFile(['./process.bpmn'])
    const { processDefinitionKey } = deploymentResponse.processes[0]
    console.log(typeof processDefinitionKey) // structural type is 'string'

    const {processInstanceKey} = await legacyCamunda.createProcessInstance({ processDefinitionKey }) // works — structural type is string

    const
    const runningProcessInstance = await camunda.searchProcessInstances({
        filter: {
            processInstanceKey: processInstanceKey as OrchestrationLifters.ProcessInstanceKey // cast to `ProcessInstanceKey`
        }
    }, { consistencyManagement: { waitUpToMs: 10_000 } })
}

main()
```

Rather than casting in multiple places, you can do it once via assignment with the `assumeExists` lifter. The lifter will cast the type and also apply runtime constraint validation.

```typescript

const camunda = new Camunda8().getOrchestrationClusterApi();

async function cancelRunningProcessInstances(processDefinitionKey: string) {
  // lift to nominal type `ProcessInstanceKey`. Will throw if passed invalid format.
  const _processDefinitionKey =
    OrchestrationLifters.ProcessDefinitionKey.assumeExists(
      processDefinitionKey
    );

  const processes = await camunda.searchProcessInstances(
    {
      filter: {
        processDefinitionKey: _processDefinitionKey,
      },
    },
    { consistencyManagement: { waitUpToMs: 10_000 } }
  );
  for (const process in processes.items) {
    await camunda.cancelProcess(process.processInstanceKey);
  }
}
```

:::info
This approach is the preferred method. This allows you to move the type and constraint validation boundary from the server API to the boundaries of your application. See [the presentation on patterns](https://www.camundacon.com/event-session/camundacon-new-york-2025/patterns-to-use-today-to-make-camunda-8-apps-even-more-reliable?on_demand=true) for more information (refer to the third demo).
:::

## Integrate the loosely-typed client

The SDK provides a legacy-compatible loosely-typed client. This erases the domain typing (all fields remain type `string`). This enables you to use the new client without managing type interaction with your existing code.

```typescript

const factory = new Camunda8()
const camunda = new factory.getOrchestrationClusterApiClientLoose()
const legacyCamunda = new factory.getCamundaRestClient()

async function main() {
    const deploymentResponse = await legacyCamunda.deployResourcesFromFile(['./process.bpmn'])
    const { processDefinitionKey } = deploymentResponse.processes[0]

    const {processInstanceKey} = await legacyCamunda.createProcessInstance({ processDefinitionKey }) // string

    const
    const runningProcessInstance = await camunda.searchProcessInstances({
        filter: {
            processInstanceKey // accepts string type
        }
    }, { consistencyManagement: { waitUpToMs: 10_000 } })
}

main()
```

You can use loosely-typed in the first instance, then progressively migrate to the strongly typed variant.

## Configuration

The Orchestration Cluster API client uses the `ZEEBE_REST_ADDRESS` configuration value to connect to the server.

## Refactor API calls

The Orchestration Cluster API has command and query operations. All operations searching data using the v1 component APIs can be refactored to use the equivalent Orchestration Cluster API method.

Some method signatures have changed, mostly in the names of fields. Your IDE intellisense will guide you in refactoring to the new signatures.

## Data access and consistency

Search and get operations require a second parameter to manage eventual consistency.

:::info
See the examples in the [TypeScript SDK guide](./camunda8-sdk.md) and the [manage Orchestration Cluster API data consistency](./eventual-consistency.md) overview.
:::

## Manage backpressure

The new client has enhanced backpressure management.

:::info
See [manage backpressure using the TypeScript SDK](./backpressure.md).
:::

---

## Orchestration Cluster API TypeScript client

Use the Orchestration Cluster API TypeScript client to connect to Camunda 8, deploy process models, and interact with the Orchestration Cluster REST API.

## About this client

The `@camunda8/orchestration-cluster-api` package provides focused support for the Orchestration Cluster REST API.

### When to use this package

Use the [`@camunda8/orchestration-cluster-api`](https://www.npmjs.com/package/@camunda8/orchestration-cluster-api) package if:

- You are starting a new project.
- You do not need the gRPC API.
- You are using Camunda 8.9 or later.
- You are developing an application for the web browser.

### Differences between the package and the SDK

| Difference         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| :----------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Configuration keys | Environment variable configuration is different when using the package directly or using it via the SDK.The SDK wraps the Orchestration Cluster API client package and allows you to use the previous configuration keys.When using the package directly, you must use the environment variable configuration keys it requires. Keys that were prefixed with `ZEEBE_` in the SDK are now prefixed with `CAMUNDA_` in the Orchestration Cluster API client package configuration.See the [Configuration Reference](https://github.com/camunda/orchestration-cluster-api-js/blob/main/documentation/CONFIG_REFERENCE.md?plain=1) for a list of configuration parameters. |
| ESM                | The Orchestration Cluster API client is a dual ESM/CJS package, allowing you to use ESM and tree shake the package as a dependency.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |

## Use the Orchestration Cluster API package

The following example retrieves the cluster topology:

1. Install the package in your project:

   ```bash
   npm i @camunda8/orchestration-cluster-api
   ```

2. Import it into your application:

   ```typescript

   const camunda = createCamundaClient();

   async function main() {
     const response = await camunda.getTopology();
     console.log(JSON.stringify(response, null, 2));
   }

   main();
   ```

   The `createCamundaClient` function returns a strongly typed client.

## Example project

See a [complete example project](https://github.com/camunda-community-hub/c8-sdk-demo) that demonstrates how to use the package.

## API documentation

See the [package README](https://camunda.github.io/orchestration-cluster-api-js/) and the [full API documentation](https://camunda.github.io/orchestration-cluster-api-js/classes/index.CamundaClient.html) for more details.

---

## TypeScript SDK(Typescript)

<PageDescription />

## Get started

Choose how you want to get started with Camunda 8 TypeScript development:

<ApiGrid api={gsCards} columns={2}/>

## Features and concepts

Learn more about Camunda TypeScript SDK features and important concepts:

<ApiGrid api={frCards}/>

:::info
Learn more about the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md).
:::

---

## Authentication(Web-modeler-api)

All Web Modeler API requests require authentication. To authenticate, generate a [JSON Web Token (JWT)](https://jwt.io/introduction/) depending on your environment and include it in each request.

:::note
Clients using a valid generated token have access to all resources within an organization, similar to [super-user mode](/components/hub/workspace/modeler/collaboration/collaboration.md#super-user-mode).

While there's no project-level access control enforced in the API, access is still dependent on the [CRUD operations assigned](#generate-a-token).
:::

## Generate a token

<Tabs groupId="environment" defaultValue="saas" queryString values={
[
{label: 'SaaS', value: 'saas' },
{label: 'Self-Managed', value: 'self-managed' },
]}>

<TabItem value='saas'>

1. Create client credentials by clicking **Console > Organization > Administration API > Create new credentials**.
2. Add permissions to this client for **Web Modeler API** with the needed CRUD permissions.
3. Once you have created the client, capture the following values required to generate a token:
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   | Name                     | Environment variable name        | Default value                                |
   | ------------------------ | -------------------------------- | -------------------------------------------- |
   | Client ID                | `CAMUNDA_CONSOLE_CLIENT_ID`      | -                                            |
   | Client Secret            | `CAMUNDA_CONSOLE_CLIENT_SECRET`  | -                                            |
   | Authorization Server URL | `CAMUNDA_OAUTH_URL`              | `https://login.cloud.camunda.io/oauth/token` |
   | Audience                 | `CAMUNDA_CONSOLE_OAUTH_AUDIENCE` | `api.cloud.camunda.io`                       |
   <!-- this comment convinces the markdown processor to still treat the table as a table, but without adding surrounding paragraphs. 🤷 -->
   :::caution
   When client credentials are created, the `Client Secret` is only shown once. Save this `Client Secret` somewhere safe.
   :::
4. Execute an authentication request to the token issuer:
   ```bash
   curl --request POST ${CAMUNDA_OAUTH_URL} \
       --header 'Content-Type: application/x-www-form-urlencoded' \
       --data-urlencode 'grant_type=client_credentials' \
       --data-urlencode "audience=${CAMUNDA_CONSOLE_OAUTH_AUDIENCE}" \
       --data-urlencode "client_id=${CAMUNDA_CONSOLE_CLIENT_ID}" \
       --data-urlencode "client_secret=${CAMUNDA_CONSOLE_CLIENT_SECRET}"
   ```
   A successful authentication response looks like the following:
   ```json
   {
     "access_token": "<TOKEN>",
     "expires_in": 300,
     "refresh_expires_in": 0,
     "token_type": "Bearer",
     "not-before-policy": 0
   }
   ```
5. Capture the value of the `access_token` property and store it as your token.

</TabItem>

<TabItem value='self-managed'>

1. [Add an M2M application in Management Identity](/self-managed/components/management-identity/application-user-group-role-management/applications.md).
2. [Add permissions to this application](/self-managed/components/management-identity/application-user-group-role-management/applications.md) for **Web Modeler API** with the needed [CRUD permissions](/self-managed/components/management-identity/access-management/access-management-overview.md#preset-permissions).
3. Capture the `Client ID` and `Client Secret` from the application in Management Identity.
4. [Generate a token](/self-managed/components/management-identity/authentication.md) to access the Web Modeler REST API. Provide the `client_id` and `client_secret` from the values you previously captured in Management Identity.
   ```shell
   curl --location --request POST 'http://localhost:18080/auth/realms/camunda-platform/protocol/openid-connect/token' \
   --header 'Content-Type: application/x-www-form-urlencoded' \
   --data-urlencode "client_id=${CLIENT_ID}" \
   --data-urlencode "client_secret=${CLIENT_SECRET}" \
   --data-urlencode 'grant_type=client_credentials'
   ```
   A successful authentication response looks like the following:
   ```json
   {
     "access_token": "<TOKEN>",
     "expires_in": 300,
     "refresh_expires_in": 0,
     "token_type": "Bearer",
     "not-before-policy": 0
   }
   ```
5. Capture the value of the `access_token` property and store it as your token.

</TabItem>

</Tabs>

## Use a token

Include the previously captured token as an authorization header in each request: `Authorization: Bearer <TOKEN>`.

For example, to send a request to the Web Modeler API's `/info` endpoint:

<Tabs groupId="environment" defaultValue="saas" queryString values={
[
{label: 'SaaS', value: 'saas' },
{label: 'Self-Managed', value: 'self-managed' },
]}>

<TabItem value='saas'>

```shell
curl --header "Authorization: Bearer ${TOKEN}" \
     https://modeler.cloud.camunda.io/api/v1/info
```

</TabItem>

<TabItem value='self-managed'>

:::tip
The `${WEB_MODELER_REST_URL}` variable below represents the URL of the Web Modeler API. You can configure this value in your Self-Managed installation. The default value is `http://localhost:8070`.
:::

```shell
curl --header "Authorization: Bearer ${TOKEN}" \
     ${WEB_MODELER_REST_URL}/api/v1/info
```

</TabItem>
</Tabs>

A successful response includes [information about the environment](https://modeler.camunda.io/swagger-ui/index.html#/Info/getInfo). For example:

```json
{
  "version": "v1",
  "authorizedOrganization": "12345678-ABCD-DCBA-ABCD-123456789ABC",
  "createPermission": true,
  "readPermission": true,
  "updatePermission": true,
  "deletePermission": false
}
```

## Organization-level access

API tokens are granted to organization-level _applications_ (Self-Managed) or _clients_ (SaaS) rather than individual _users_. With an API token, you can read, edit, and delete all workspaces ([called "projects" before Camunda 8.10](../migration-manuals/migrate-from-web-modeler-to-hub-api.md#structure-and-terminology)) and workspace resources in the organization, as long as the application or client has the required Web Modeler API permissions. This is true even if you aren't a member of the workspace and you can't see it in the Camunda Hub user interface.

## Token expiration

Access tokens expire according to the `expires_in` property of a successful authentication response. After this duration, in seconds, you must request a new access token.

---

## Web Modeler API

:::note DEPRECATED
Web Modeler API v1 is deprecated in Camunda 8.10 and will be removed in 8.12. [Migrate to Camunda Hub REST API v2](../migration-manuals/migrate-from-web-modeler-to-hub-api.md).
:::

Use the Web Modeler API to access your Web Modeler data.

## About

You can use the Web Modeler REST API to programmatically access your Web Modeler data.

- Web Modeler provides a REST API at `/api/*`.
- Requests and responses are in JSON notation.

## Authentication

Clients can only access the Web Modeler REST API by passing a JWT access token in an authorization header `Authorization: Bearer <JWT>`. Details are covered in the [Authentication](authentication.md) section.

## API reference

A detailed API description is available as [OpenAPI](https://www.openapis.org/) specification at [https://modeler.camunda.io/swagger-ui/index.html](https://modeler.camunda.io/swagger-ui/index.html)
for SaaS and at [http://localhost:8070/swagger-ui.html](http://localhost:8070/swagger-ui.html) for Self-Managed
installations.

## API in Postman

Work with this API in our [Postman collection](https://www.postman.com/camundateam/workspace/camunda-8-postman/collection/26079299-0bb668f4-af6a-4ab0-88a3-c78b900125ed?action=share&creator=11465105).

## Usage notes

When using Web Modeler API:

- You will not receive a warning when deleting a file, a folder, or a project.
  This is important, because deletion cannot be undone.
- You will not receive a warning about breaking call activity links or business rule task links when moving files or folders to another project.
  Breaking these links is considered harmless. The broken links can be manually removed or restored in Web Modeler. This operation is also
  reversible - simply move the files or folders back to their original location.

## Rate limiting

In SaaS, the Web Modeler API uses rate limiting to control traffic.
The limit is 240 requests per minute.
Surpassing this limit will result into a `HTTP 429 Too Many Requests` response.

On Self-Managed instances no limits are enforced.

## FAQ

### What is the difference between _simplePath_ and _canonicalPath_?

In Web Modeler you can have multiple files with the same name, multiple folders with the same name, and even multiple projects with the same name. Internally, duplicate names are disambiguated by unique IDs.

The API gives you access to the names, as well as the IDs. For example, when requesting a file you will get the following information:

- **simplePath** contains the human-readable path. This path may be ambiguous or may have ambiguous elements (e.g. folders) in it.
- **canonicalPath** contains the unique path. It is a list of **PathElementDto** objects which contain the ID and the name of the element.

Internally, the IDs are what matters. You can rename files or move files between folders and projects and the ID will stay the same.

---

## Tutorial(Web-modeler-api)

In this tutorial, we'll step through examples to highlight the capabilities of the Web Modeler API, such as creating a new project, adding a collaborator to a project, viewing the details of a project, and deleting a project.
This tutorial focuses on using the Web Modeler API in a Camunda 8 SaaS environment, but the same principles apply to a Self-Managed environment.

## Prerequisites

- Create your first client by navigating to **Console > Organization > Administration API > Create new credentials**. Ensure you determine the scoped access for client credentials. For example, in this tutorial we will create a project, add a collaborator, and delete a project. Ensure you check the box for the Web Modeler scope.

:::note
Make sure you keep the generated client credentials in a safe place. The **Client secret** will not be shown again. For your convenience, you can also download the client information to your computer.
:::

- In this tutorial, we utilize a JavaScript-written [GitHub repository](https://github.com/camunda/camunda-api-tutorials) to write and run requests. Clone this repo before getting started.
- Ensure you have [Node.js](https://nodejs.org/en/download) installed as this will be used for methods that can be called by the CLI (outlined later in this guide). Run `npm install` to ensure you have updated dependencies.

## Getting started

- A detailed API description can be found [here](https://modeler.cloud.camunda.io/swagger-ui/index.html) via Swagger. With a valid access token, this offers an interactive API experience against your Camunda 8 cluster.
- You need authentication to access the API endpoints. Find more information [here](/apis-tools/web-modeler-api/authentication.md).

## Set up authentication

If you're interested in how we use a library to handle auth for our code, or to get started, examine the `auth.js` file in the GitHub repository. This file contains a function named `getAccessToken` which executes an OAuth 2.0 protocol to retrieve authentication credentials based on your client ID and client secret. Then, we return the actual token that can be passed as an authorization header in each request.

To set up your credentials, create an `.env` file which will be protected by the `.gitignore` file. You will need to add your `MODELER_CLIENT_ID`, `MODELER_CLIENT_SECRET`, `MODELER_AUDIENCE`, which is `modeler.cloud.camunda.io` in a Camunda 8 SaaS environment, and `MODELER_BASE_URL`, which is `https://modeler.camunda.io/api/v1`.

These keys will be consumed by the `auth.js` file to execute the OAuth protocol, and should be saved when you generate your client credentials in [prerequisites](#prerequisites).

:::tip Can't find your environment variables?
When you create new client credentials as a [prerequisite](#prerequisites), your environment variables appear in a pop-up window. Your environment variables may appear as `CAMUNDA_CONSOLE_CLIENT_ID`, `CAMUNDA_CONSOLE_CLIENT_SECRET`, and `CAMUNDA_CONSOLE_OAUTH_AUDIENCE`.
:::

Examine the existing `.env.example` file for an example of how your `.env` file should look upon completion. Do not place your credentials in the `.env.example` file, as this example file is not protected by the `.gitignore`.

:::note

In this tutorial, we will execute arguments to create a project, add a collaborator, and delete a project. You can examine the framework for processing these arguments in the `cli.js` file before getting started.

:::

## Create a new project (POST) and add a collaborator (PUT)

First, let's script an API call to create a new project.

To do this, take the following steps:

1. In the file named `modeler.js`, outline the authentication and authorization configuration in the first few lines. This will pull in your `.env` variables to obtain an access token before making any API calls:

```javascript
const authorizationConfiguration = {
  clientId: process.env.MODELER_CLIENT_ID,
  clientSecret: process.env.MODELER_CLIENT_SECRET,
  audience: process.env.MODELER_AUDIENCE,
};
```

2. Examine the function `async function createProject([projectName, adminEmail])` below this configuration. This is where you will script out your API call, defining a project name and the project administrator's email.
3. Within the function, you must first generate an access token for this request, so your function should now look like the following:

```javascript
async function createProject([projectName, adminEmail]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
}
```

4. Using your generated client credentials from [prerequisites](#prerequisites), capture your Web Modeler base URL beneath your call for an access token by defining `modelerApiUrl`:

```javascript
const modelerApiUrl = process.env.MODELER_BASE_URL;
```

5. On the next line, script the API endpoint to create your project:

```javascript
const projectUrl = `${modelerApiUrl}/projects`;
```

6. Configure your POST request to the appropriate endpoint, including an authorization header based on the previously acquired `accessToken`. You will also add a body to outline information about the new project:

```javascript
const projectOptions = {
  method: "POST",
  url: projectUrl,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
  data: {
    name: projectName,
  },
};
```

7. Call the add project endpoint and capture the data for the new project:

```javascript
  try {
    const response = await axios(projectOptions);

    const newProject = response.data;

    console.log(
      `Project added! Name: ${newProject.name}. ID: ${newProject.id}.`
    );
```

8. Next, we'll add a collaborator to the project you just created. After calling the add project endpoint, add an endpoint to add a collaborator to the project:

```javascript
const collaboratorUrl = `${modelerApiUrl}/collaborators`;
```

9. Configure the API call, including a body with information about the project and the new collaborator:

```javascript
    const collaboratorOptions = {
      method: "PUT",
      url: collaboratorUrl,
      headers: {
        Accept: "application/json",
        Authorization: `Bearer ${accessToken}`
      },
      data: {
        email: adminEmail,
        projectId: newProject.id,
        role: "project_admin"
      }
```

10. Call the add collaborator endpoint and process the results:

```javascript
 const collaboratorResponse = await axios(collaboratorOptions);

    if (collaboratorResponse.status === 204) {
      console.log(`Collaborator added! Email: ${adminEmail}.`);
    } else {
      console.error("Unable to add collaborator!");
    }
  } catch (error) {
    // Emit an error from the server.
    console.error(error.message);
  }
```

11. In your terminal, run `npm run cli modeler create` to create your project.

:::note
This `create` command is connected to the `createProject` function at the bottom of the `modeler.js` file, and executed by the `cli.js` file. While we create a project in this tutorial, you may add additional arguments depending on the API calls you would like to make.
:::

## View project details (GET)

To view project details, take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function viewProject([projectId]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const modelerApiUrl = process.env.MODELER_BASE_URL;
  const url = `${modelerApiUrl}/projects/${projectId}`;
}
```

2. Configure the API call using the GET method:

```javascript
const options = {
  method: "GET",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results from the API call. For example:

```javascript
try {
  const response = await axios(options);
  const project = response.data;

  console.log("Project:", project);
} catch (error) {
  console.error(error.message);
}
```

4. In your terminal, run `npm run cli modeler view <project ID>`, where `<project ID>` is the ID output by the command to create a project.

## Delete a project

To delete a project, take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function deleteProject([projectId]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
  const modelerApiUrl = process.env.MODELER_BASE_URL;
  const url = `${modelerApiUrl}/projects/${projectId}`;
```

2. Configure the API call using the DELETE method:

```javascript
const options = {
  method: "DELETE",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results from the API call. For example:

```javascript
try {
  const response = await axios(options);

  if (response.status === 204) {
    console.log(`Project ${projectId} was deleted!`);
  } else {
    console.error("Unable to delete project!");
  }
} catch (error) {
  console.error(error.message);
}
```

4. In your terminal, run `npm run cli modeler delete <project ID>`, where `<project ID>` is the ID output by the command to create a project.

## If you get stuck

Having trouble configuring your API calls or want to examine an example of the completed tutorial? Navigate to the `completed` folder in the [GitHub repository](https://github.com/camunda/camunda-api-tutorials/tree/main/completed), where you can view an example `modeler.js` file.

## Next steps

You can script several additional API calls as outlined in the [Web Modeler API reference material](/apis-tools/web-modeler-api/index.md).

---

## APIs & tools

Camunda 8 APIs and official clients and SDKs.

Use Camunda 8 APIs and clients to build, automate, and monitor your applications. Use the official Camunda clients and SDKs (Java, Spring, and Node.js) to simplify API usage and speed up development.

Get started with the Camunda Java Client

:::info Upgrade to Camunda 8.9

- Existing customer? Upgrade your APIs & tools to 8.9 using the [APIs & tools migration guide](/apis-tools/migration-manuals/migrate-to-89.md).
- See [what's new in Camunda 8.9](/reference/announcements-release-notes/890/whats-new-in-89.md), [release announcements](/reference/announcements-release-notes/890/890-announcements.md), and [release notes](/reference/announcements-release-notes/890/890-release-notes.md).

:::

## APIs

Use the following APIs for Camunda 8 integration and automation:

<ApiGrid api={apiCards} />

## API clients

Camunda provides the following official clients to simplify API usage and speed up development:

<ApiGrid api={clientCards} />

:::note community clients
In addition to the core Camunda-maintained clients, there are a number of [community-maintained component clients](/apis-tools/community-clients/index.md).
:::

## Client and API compatibility

Camunda clients and SDKs are **forward-compatible** with the Orchestration Cluster, meaning you can upgrade the cluster first and clients after. The Orchestration Cluster REST API is backward-compatible, ensuring no breaking changes to existing endpoints across versions.

[Client and API compatibility guarantees](/reference/public-api.md#client-and-api-compatibility)

## Testing

Use Camunda Process Test to test your process definitions and automations with a dedicated testing framework.

[Camunda Process Test](/apis-tools/testing/getting-started.md)

## Upgrade to Camunda 8.9

If you are migrating from Camunda 7 or from v1 component REST APIs, see the migration guide for guidance.

[Camunda 8.9 APIs & tools migration guide](/apis-tools/migration-manuals/migrate-to-89.md)

---

## Deprecated RPCs

The following RPCs are exposed by the gateway service, but have been deprecated.

## `DeployProcess` RPC

:::note
Deprecated since 8, replaced by [DeployResource RPC](#deployresource-rpc).
:::

:::note
When multi-tenancy is enabled, processes are always deployed to the `<default>` tenant.
:::

Deploys one or more processes to Zeebe. Note that this is an atomic call,
i.e. either all processes are deployed, or none of them are.

### Input: `DeployProcessRequest`

```protobuf
message DeployProcessRequest {
  // List of process resources to deploy
  repeated ProcessRequestObject processes = 1;
}

message ProcessRequestObject {
  enum ResourceType {
    // FILE type means the gateway will try to detect the resource type
    // using the file extension of the name field
    FILE = 0;
    BPMN = 1; // extension 'bpmn'
    YAML = 2 [deprecated = true]; // extension 'yaml'; removed as of release 1.0
  }

  // the resource basename, e.g. myProcess.bpmn
  string name = 1;
  // the resource type; if set to BPMN or YAML then the file extension
  // is ignored
  // As of release 1.0, YAML support was removed and BPMN is the only supported resource type.
  // The field was kept to not break clients.
  ResourceType type = 2 [deprecated = true];
  // the process definition as a UTF8-encoded string
  bytes definition = 3;
}
```

### Output: `DeployProcessResponse`

```protobuf
message DeployProcessResponse {
  // the unique key identifying the deployment
  int64 key = 1;
  // a list of deployed processes
  repeated ProcessMetadata processes = 2;
}

message ProcessMetadata {
  // the bpmn process ID, as parsed during deployment; together with the version forms a
  // unique identifier for a specific process definition
  string bpmnProcessId = 1;
  // the assigned process version
  int32 version = 2;
  // the assigned key, which acts as a unique identifier for this process
  int64 processKey = 3;
  // the resource name (see: ProcessRequestObject.name) from which this process was
  // parsed
  string resourceName = 4;
}
```

### Errors

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- No resources given.
- At least one resource is invalid. A resource is considered invalid if:
  - It is not a BPMN or YAML file (currently detected through the file extension).
  - The resource data is not deserializable (e.g. detected as BPMN, but it's broken XML).
  - The process is invalid (e.g. an event-based gateway has an outgoing sequence flow to a task.)

---

## Zeebe API RPCs

The Zeebe client gRPC API is exposed through a single gateway service. The current version of the protocol buffer file can be found in the [Zeebe repository](https://github.com/camunda/camunda/blob/main/zeebe/gateway-protocol/src/main/proto/gateway.proto).

## Default service config

Along with the gateway protocol definition, the gateway service also bundles a [default service configuration file](https://github.com/camunda/camunda/blob/main/zeebe/gateway-protocol-impl/src/main/resources/gateway-service-config.json).
This file can be used as is, or as a template to create your own, and defines default retry strategies on a per-RPC basis: when to retry (based on error code), how often, how soon, etc.
This file is also loaded by the [Camunda Java client](../java-client/getting-started.md) if `useDefaultRetryPolicy` is set to true.

:::note
Read more about [service configuration files](https://github.com/grpc/grpc/blob/master/doc/service_config.md). These files are especially useful
when using the Camunda protocol in languages without, or with less feature-rich clients and SDKs.
:::

Usage of this file largely depends on the gRPC bindings for your language of choice. For example, when using Java, you would programmatically configure your
client using:

```java
final ObjectMapper objectMapper = new ObjectMapper();
final File configFile = new File("gateway-service-config.json");
final Map<String, Object> serviceConfig = objectMapper.readValue(
      configFile, new TypeReference<Map<String, Object>>() {});
final ManagedChannelBuilder<?> channelBuilder = ManagedChannelBuilder.forAddress("localhost", 26500);

channelBuilder.defaultServiceConfig(serviceConfig);
channelBuilder.enableRetry();
```

## `ActivateJobs` RPC

Iterates through all known partitions round-robin, activates up to the requested
maximum, and streams them back to the client as they are activated.

### Input: `ActivateJobsRequest`

```protobuf
message ActivateJobsRequest {
  // the job type, as defined in the BPMN process (e.g. <zeebe:taskDefinition
  // type="payment-service" />)
  string type = 1;
  // the name of the worker activating the jobs, mostly used for logging purposes
  string worker = 2;
  // a job returned after this call will not be activated by another call until the
  // timeout (in ms) has been reached
  int64 timeout = 3;
  // the maximum jobs to activate by this request
  int32 maxJobsToActivate = 4;
  // a list of variables to fetch as the job variables; if empty, all visible variables at
  // the time of activation for the scope of the job will be returned
  repeated string fetchVariable = 5;
  // The request will be completed when at least one job is activated or after the requestTimeout (in ms).
  // if the requestTimeout = 0, a default timeout is used.
  // if the requestTimeout < 0, long polling is disabled and the request is completed immediately, even when no job is activated.
  int64 requestTimeout = 6;
  // a list of IDs of tenants for which to activate jobs
  repeated string tenantIds = 7;
}
```

If `requestTimeout` is set to `0`, the effective timeout depends on whether long polling is enabled:

- If long polling is enabled, the gateway uses its configured long-polling timeout (`camunda.api.long-polling.timeout` / `zeebe.gateway.longPolling.timeout`, default 10,000 ms).
- If long polling is disabled, the request falls back to a client-side timeout. For gRPC clients, this currently defaults to 10,000 ms.

If `requestTimeout` is set to a value less than `0`, long polling is disabled and the request completes immediately, even when no job is activated.

### Output: `ActivateJobsResponse`

```protobuf
message ActivateJobsResponse {
  // list of activated jobs
  repeated ActivatedJob jobs = 1;
}

message ActivatedJob {
  // Describes the kind of job.
  enum JobKind {
    BPMN_ELEMENT = 0;
    EXECUTION_LISTENER = 1;
    TASK_LISTENER = 2;
  }

  // Describes the listener event type of the job.
  enum ListenerEventType {
    ASSIGNING = 0;
    CANCELING = 1;
    COMPLETING = 2;
    CREATING = 3;
    END = 4;
    START = 5;
    UNSPECIFIED = 6;
    UPDATING = 7;
  }

  // the key, a unique identifier for the job
  int64 key = 1;
  // the type of the job (should match what was requested)
  string type = 2;
  // the job's process instance key
  int64 processInstanceKey = 3;
  // the bpmn process ID of the job process definition
  string bpmnProcessId = 4;
  // the version of the job process definition
  int32 processDefinitionVersion = 5;
  // the key of the job process definition
  int64 processDefinitionKey = 6;
  // the associated task element ID
  string elementId = 7;
  // the unique key identifying the associated task, unique within the scope of the
  // process instance
  int64 elementInstanceKey = 8;
  // a set of custom headers defined during modelling; returned as a serialized
  // JSON document
  string customHeaders = 9;
  // the name of the worker which activated this job
  string worker = 10;
  // the amount of retries left to this job (should always be positive)
  int32 retries = 11;
  // when the job can be activated again, sent as a UNIX epoch timestamp
  int64 deadline = 12;
  // JSON document, computed at activation time, consisting of all visible variables to
  // the task scope
  string variables = 13;
  // the ID of the tenant that owns the job
  string tenantId = 14;
  // the kind of the job.
  JobKind kind = 15;
  // the listener event type of the job.
  ListenerEventType listenerEventType = 16;
}
```

### Errors

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- Type is blank (empty string, null)
- Worker is blank (empty string, null)
- Timeout less than 1 (ms)
- maxJobsToActivate is less than 1
- If multi-tenancy is enabled, and `tenantIds` is empty (empty list)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantIds` is not empty (empty list), or has an ID other than `<default>`

#### GRPC_STATUS_PERMISSION_DENIED

- If multi-tenancy is enabled, and an unauthorized tenant ID is provided

## `BroadcastSignal` RPC

Broadcasts a [signal](/components/concepts/signals.md).

### Input: `BroadcastSignalRequest`

```protobuf
message BroadcastSignalRequest {
  // The name of the signal
  string signalName = 1;
  // the signal variables as a JSON document; to be valid, the root of the document must be an
  // object, e.g. { "a": "foo" }. [ "foo" ] would not be valid.
  string variables = 2;
  // the ID of the tenant that owns the signal.
  string tenantId = 3;
}
```

### Output: `BroadcastSignalResponse`

```protobuf
message BroadcastSignalResponse {
  // the unique ID of the signal that was broadcasted.
  int64 key = 1;
  // the tenant ID of the signal that was broadcasted.
  string tenantId = 2;
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

- If multi-tenancy is enabled, and `tenantId` is blank (empty string, null)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantId` is not blank (empty string, null), or has an ID other than `<default>`

#### GRPC_STATUS_PERMISSION_DENIED

- If multi-tenancy is enabled, and an unauthorized tenant ID is provided

## `CancelProcessInstance` RPC

Cancels a running process instance.

### Input: `CancelProcessInstanceRequest`

```protobuf
message CancelProcessInstanceRequest {
  // the process instance key (as, for example, obtained from
  // CreateProcessInstanceResponse)
  int64 processInstanceKey = 1;
}
```

### Output: `CancelProcessInstanceResponse`

```protobuf
message CancelProcessInstanceResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No process instance exists with the given key. Note that since process instances are removed once they are finished, it could mean the instance did exist at some point.
- No process instance exists with the given key for the tenants the user is authorized to work with.

## `CompleteJob` RPC

Completes a job with the given payload, which allows completing the associated service task.

### Input: `CompleteJobRequest`

```protobuf
message CompleteJobRequest {
  // the unique job identifier, as obtained from ActivateJobsResponse
  int64 jobKey = 1;
  // a JSON document representing the variables in the current task scope
  string variables = 2;
  // The result of the completed job as determined by the worker.
  // This functionality is currently supported only by user task listeners
  optional JobResult result = 3;
}

message JobResult{
  // Indicates whether the worker denies the work, or explicitly doesn't approve it.
  // For example, a user task listener can deny the completion of a user task by setting this flag to true.
  // In this example, the completion of a task is represented by a job that the worker can complete as denied.
  // As a result, the completion request is rejected and the task remains active.
  // Defaults to false.
  // Only applicable for user task listener jobs.
  optional bool denied = 1;
  // Attributes that were corrected by the worker.
  // The following attributes can be corrected, additional attributes will be ignored:
  //   * `assignee` - clear by providing an empty string
  //   * `dueDate` - clear by providing an empty string
  //   * `followUpDate` - clear by providing an empty string
  //   * `candidateGroups` - clear by providing an empty list
  //   * `candidateUsers` - clear by providing an empty list
  //   * `priority` - minimum 0, maximum 100, default 50
  // Omitting any of the attributes will preserve the persisted attribute's value.
  // Only applicable for user task listener jobs.
  optional JobResultCorrections corrections = 2;
  // The reason provided by the user task listener for denying the work.
  optional string deniedReason = 3;
  // Identifies the type of job result. Must be either "userTask" or "adHocSubprocess".
  // Defaults to "userTask" if not explicitly set.
  optional string type = 4;
  // The list of elements that should be activated after the job is completed.
  // Only applicable for ad-hoc subprocesses.
  repeated JobResultActivateElement activateElements = 5;
}

message JobResultCorrections {
  // The assignee of the task.
  optional string assignee = 1;
  // The due date of the task.
  optional string dueDate = 2;
  // The follow-up date of the task.
  optional string followUpDate = 3;
  // The list of candidate users of the task.
  optional StringList candidateUsers = 4;
  // The list of candidate groups of the task.
  optional StringList candidateGroups = 5;
  // The priority of the task.
  optional int32 priority = 6;
}

message JobResultActivateElement {
  // The id of the element to activate
  string elementId = 1;
  // JSON document of variables that will be created on the scope of the activated element.
  // It must be a JSON object, as variables will be mapped in a key-value fashion.
  // e.g. { "a": 1, "b": 2 } will create two variables, named "a" and
  // "b" respectively, with their associated values. [{ "a": 1, "b": 2 }] would not be a
  // valid argument, as the root of the JSON document is an array and not an object.
  string variables = 2;
}

message StringList {
  // Wrapper around a list of string values.
  repeated string values = 1;
}
```

### Output: `CompleteJobResponse`

```protobuf
message CompleteJobResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No job exists with the given job key. Note that since jobs are removed once completed, it could be that this job did exist at some point.
- No job exists with the given job key for the tenants the user is authorized to work with.

#### GRPC_STATUS_FAILED_PRECONDITION

Returned if:

- The job was marked as failed. In that case, the related [incident](/components/concepts/incidents.md) must be resolved before the job can be activated again and completed.

## `CreateProcessInstance` RPC

Creates and starts an instance of the specified process. The process definition to use
to create the instance can be specified either using its unique key (as returned by
DeployProcess), or using the BPMN process ID and a version. Pass -1 as the version to
use the latest deployed version.

:::note
Only processes with none start events can be started through this command.
:::

:::note
Start and runtime instructions have the
same [limitations as process instance modification](/components/concepts/process-instance-modification.md#limitations),
e.g., it is not possible to start at a sequence flow or terminate a process instance when a sequence
flow completes.
:::

### Input: `CreateProcessInstanceRequest`

```protobuf
message CreateProcessInstanceRequest {
  // the unique key identifying the process definition (e.g. returned from a process
  // in the DeployProcessResponse message)
  int64 processDefinitionKey = 1;
  // the BPMN process ID of the process definition
  string bpmnProcessId = 2;
  // the version of the process; set to -1 to use the latest version
  int32 version = 3;
  // JSON document that will instantiate the variables for the root variable scope of the
  // process instance; it must be a JSON object, as variables will be mapped in a
  // key-value fashion. e.g. { "a": 1, "b": 2 } will create two variables, named "a" and
  // "b" respectively, with their associated values. [{ "a": 1, "b": 2 }] would not be a
  // valid argument, as the root of the JSON document is an array and not an object.
  string variables = 4;
  // List of start instructions. If empty (default) the process instance
  // will start at the start event. If non-empty the process instance will apply start
  // instructions after it has been created
  repeated ProcessInstanceCreationStartInstruction startInstructions = 5;

  // the tenant id of the process definition
  string tenantId = 6;

  // a reference key chosen by the user and will be part of all records resulted from this operation
  optional uint64 operationReference = 7;

  // a list of runtime instruction that can modify the behavior of the process
  // instance during its execution
  // if empty (default), the process instance will be executed normally
  repeated ProcessInstanceCreationRuntimeInstruction runtimeInstructions = 8;
}

message ProcessInstanceCreationStartInstruction {

  // future extensions might include
  // - different types of start instructions
  // - ability to set local variables for different flow scopes

  // for now, however, the start instruction is implicitly a
  // "startBeforeElement" instruction

  // element ID
  string elementId = 1;
}

message ProcessInstanceCreationRuntimeInstruction {
  oneof instruction {
    TerminateProcessInstanceInstruction terminate = 1;
  }
}

message TerminateProcessInstanceInstruction {
  // the ID of the process element after which the process instance should be
  // terminated
  string afterElementId = 1;
}
```

### Output: `CreateProcessInstanceResponse`

```protobuf
message CreateProcessInstanceResponse {
  // the key of the process definition which was used to create the process instance
  int64 processDefinitionKey = 1;
  // the BPMN process ID of the process definition which was used to create the process
  // instance
  string bpmnProcessId = 2;
  // the version of the process definition which was used to create the process instance
  int32 version = 3;
  // the unique identifier of the created process instance; to be used wherever a request
  // needs a process instance key (e.g. CancelProcessInstanceRequest)
  int64 processInstanceKey = 4;
  // the tenant identifier of the created process instance
  string tenantId = 5;
}
```

## `CreateProcessInstanceWithResult` RPC

Similar to `CreateProcessInstance` RPC, creates and starts an instance of the specified process.
Unlike `CreateProcessInstance` RPC, the response is returned when the process is completed.

:::note
Only processes with none start events can be started through this command.
:::

:::note
Start instructions have the same [limitations as process instance modification](/components/concepts/process-instance-modification.md#limitations), e.g., it is not possible to start at a sequence flow.
:::

### Input: `CreateProcessInstanceWithResultRequest`

```protobuf
message CreateProcessInstanceWithResultRequest {
  CreateProcessInstanceRequest request = 1;
  // timeout (in ms). the request will be closed if the process is not completed
  // before the requestTimeout.
  // if requestTimeout = 0, uses the generic requestTimeout configured in the gateway.
  int64 requestTimeout = 2;
  // list of names of variables to be included in `CreateProcessInstanceWithResultResponse.variables`
  // if empty, all visible variables in the root scope will be returned.
  repeated string fetchVariables = 3;
}
```

### Output: `CreateProcessInstanceWithResultResponse`

```protobuf
message CreateProcessInstanceWithResultResponse {
  // the key of the process definition which was used to create the process instance
  int64 processDefinitionKey = 1;
  // the BPMN process ID of the process definition which was used to create the process
  // instance
  string bpmnProcessId = 2;
  // the version of the process definition which was used to create the process instance
  int32 version = 3;
  // the unique identifier of the created process instance; to be used wherever a request
  // needs a process instance key (e.g. CancelProcessInstanceRequest)
  int64 processInstanceKey = 4;
  // JSON document
  // consists of visible variables in the root scope
  string variables = 5;
  // the tenant identifier of the process definition
  string tenantId = 6;
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No process with the given key exists (if processKey was given).
- No process with the given process ID exists (if bpmnProcessId was given but version was -1).
- No process with the given process ID and version exists (if both bpmnProcessId and version were given).

#### GRPC_STATUS_FAILED_PRECONDITION

Returned if:

- The process definition does not contain a none start event; only processes with none
  start event can be started manually.

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- The given variables argument is not a valid JSON document; it is expected to be a valid
  JSON document where the root node is an object.
- The given `businessId` exceeds the maximum length of 256 characters.
- If multi-tenancy is enabled, and `tenantId` is blank (empty string, null)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantId` is not blank (empty string, null), or has an ID other than `<default>`

#### GRPC_STATUS_PERMISSION_DENIED

- If multi-tenancy is enabled, and an unauthorized tenant ID is provided

## `DeleteResource` RPC

### Input `DeleteResourceRequest`

```protobuf
message DeleteResourceRequest {
  // The key of the resource that should be deleted. This can either be the key
  // of a process definition, the key of a decision requirements definition or the key of a form.
  int64 resourceKey = 1;
}
```

### Output: `DeleteResourceResponse`

```protobuf
message DeleteResourceResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No resource exists with the given key.
- No resource was found with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_FAILED_PRECONDITION

Returned if:

- The deleted resource is a process definition, and there are running instances for this process definition.

## `DeployResource` RPC

Deploys one or more resources (e.g. processes, decision models or forms) to Zeebe.
Note that this is an atomic call, i.e. either all resources are deployed, or none of them are.

### Input: `DeployResourceRequest`

```protobuf
message DeployResourceRequest {
  // list of resources to deploy
  repeated Resource resources = 1;
  // the tenant id of the resources to deploy
  string tenantId = 2;
}

message Resource {
  // the resource name, e.g. myProcess.bpmn or myDecision.dmn
  string name = 1;
  // the file content as a UTF8-encoded string
  bytes content = 2;
}
```

### Output: `DeployResourceResponse`

```protobuf
message DeployResourceResponse {
  // the unique key identifying the deployment
  int64 key = 1;
  // a list of deployed resources, e.g. processes
  repeated Deployment deployments = 2;
  // the tenant id of the deployed resources
  string tenantId = 3;
}

message Deployment {
  // each deployment has only one metadata
  oneof Metadata {
    // metadata of a deployed process
    ProcessMetadata process = 1;
    // metadata of a deployed decision
    DecisionMetadata decision = 2;
    // metadata of a deployed decision requirements
    DecisionRequirementsMetadata decisionRequirements = 3;
    // metadata of a deployed form
    FormMetadata form = 4;
  }
}

message ProcessMetadata {
  // the bpmn process ID, as parsed during deployment; together with the version forms a
  // unique identifier for a specific process definition
  string bpmnProcessId = 1;
  // the assigned process version
  int32 version = 2;
  // the assigned key, which acts as a unique identifier for this process
  int64 processDefinitionKey = 3;
  // the resource name (see: ProcessRequestObject.name) from which this process was
  // parsed
  string resourceName = 4;
  // the tenant id of the deployed process
  string tenantId = 5;
}

message DecisionMetadata {
  // the dmn decision ID, as parsed during deployment; together with the
  // versions forms a unique identifier for a specific decision
  string dmnDecisionId = 1;
  // the dmn name of the decision, as parsed during deployment
  string dmnDecisionName = 2;
  // the assigned decision version
  int32 version = 3;
  // the assigned decision key, which acts as a unique identifier for this
  // decision
  int64 decisionKey = 4;
  // the dmn ID of the decision requirements graph that this decision is part
  // of, as parsed during deployment
  string dmnDecisionRequirementsId = 5;
  // the assigned key of the decision requirements graph that this decision is
  // part of
  int64 decisionRequirementsKey = 6;
  // the tenant id of the deployed decision
  string tenantId = 7;
}

message DecisionRequirementsMetadata {
  // the dmn decision requirements ID, as parsed during deployment; together
  // with the versions forms a unique identifier for a specific decision
  string dmnDecisionRequirementsId = 1;
  // the dmn name of the decision requirements, as parsed during deployment
  string dmnDecisionRequirementsName = 2;
  // the assigned decision requirements version
  int32 version = 3;
  // the assigned decision requirements key, which acts as a unique identifier
  // for this decision requirements
  int64 decisionRequirementsKey = 4;
  // the resource name (see: Resource.name) from which this decision
  // requirements was parsed
  string resourceName = 5;
  // the tenant id of the deployed decision requirements
  string tenantId = 6;
}

message FormMetadata {
  // the form ID, as parsed during deployment; together with the
  // versions forms a unique identifier for a specific form
  string formId = 1;
  // the assigned form version
  int32 version = 2;
  // the assigned key, which acts as a unique identifier for this form
  int64 formKey = 3;
  // the resource name
  string resourceName = 4;
  // the tenant id of the deployed form
  string tenantId = 5;
}
```

### Errors

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- No resources given.
- At least one resource is invalid. A resource is considered invalid if:
  - The resource type is not supported (e.g. supported resources include BPMN and DMN files)
  - The content is not deserializable (e.g. detected as BPMN, but it's broken XML)
  - The content is invalid (e.g. an event-based gateway has an outgoing sequence flow to a task)
- If multi-tenancy is enabled, and `tenantId` is blank (empty string, null)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantId` is not blank (empty string, null), or has an ID other than `<default>`

#### GRPC_STATUS_PERMISSION_DENIED

- If multi-tenancy is enabled, and an unauthorized tenant ID is provided

## `EvaluateConditional` RPC

Evaluates root-level conditional start events for process definitions.
If the evaluation is successful, it will return the keys of all created process instances, along with their associated process definition key.
Multiple root-level conditional start events of the same process definition can trigger if their conditions evaluate to true.

### Input: `EvaluateConditionalRequest`

```protobuf
message EvaluateConditionalRequest {
  // Used to evaluate root-level conditional start events for a tenant with the given ID.
  // This will only evaluate root-level conditional start events of process definitions which belong to the tenant.
  string tenantId = 1;
  // Used to evaluate root-level conditional start events of the process definition with the given key.
  optional int64 processDefinitionKey = 2;
  // Serialized JSON object representing the variables to use for evaluation of the conditions and to pass to the process instances that have been triggered.
  string variables = 3;
}
```

### Output: `EvaluateConditionalResponse`

```protobuf
message EvaluateConditionalResponse {
  // List of process instances created. If no root-level conditional start events evaluated to true, the list will be empty.
  repeated ProcessInstanceReference processInstances = 1;
  // The unique key of the conditional evaluation operation.
  int64 conditionalEvaluationKey = 2;
  // The tenant ID of the conditional evaluation operation.
  string tenantId = 3;
}

message ProcessInstanceReference {
  // The key of the process definition.
  int64 processDefinitionKey = 1;
  // The key of the created process instance.
  int64 processInstanceKey = 2;
}
```

### Errors

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- The provided data is not valid

#### GRPC_STATUS_NOT_FOUND

Returned if:

- The process definition was not found for the given processDefinitionKey

#### GRPC_STATUS_PERMISSION_DENIED

- The client is not authorized to start process instances for the specified process definition
- If a processDefinitionKey is not provided, this indicates that the client is not authorized
  to start process instances for at least one of the matched process definitions

## `EvaluateDecision` RPC

Evaluates a decision. You specify the decision to evaluate either by
using its unique KEY (as returned by DeployResource), or using the decision
ID. When using the decision ID, the latest deployed version of the decision
is used.

:::note
When you specify both the decision ID and KEY, the ID is used to find the decision to be evaluated.
:::

### Input: `EvaluateDecisionRequest`

```protobuf
message EvaluateDecisionRequest {
  // the unique key identifying the decision to be evaluated (e.g. returned
  // from a decision in the DeployResourceResponse message)
  int64 decisionKey = 1;
  // the ID of the decision to be evaluated
  string decisionId = 2;
  // JSON document that will instantiate the variables for the decision to be
  // evaluated; it must be a JSON object, as variables will be mapped in a
  // key-value fashion, e.g. { "a": 1, "b": 2 } will create two variables,
  // named "a" and "b" respectively, with their associated values.
  // [{ "a": 1, "b": 2 }] would not be a valid argument, as the root of the
  // JSON document is an array and not an object.
  string variables = 3;
  // the tenant identifier of the decision
  string tenantId = 4;
}
```

### Output: `EvaluateDecisionResponse`

```protobuf
message EvaluateDecisionResponse {
  // the unique key identifying the decision which was evaluated (e.g. returned
  // from a decision in the DeployResourceResponse message)
  int64 decisionKey = 1;
  // the ID of the decision which was evaluated
  string decisionId = 2;
  // the name of the decision which was evaluated
  string decisionName = 3;
  // the version of the decision which was evaluated
  int32 decisionVersion = 4;
  // the ID of the decision requirements graph that the decision which was
  // evaluated is part of.
  string decisionRequirementsId = 5;
  // the unique key identifying the decision requirements graph that the
  // decision which was evaluated is part of.
  int64 decisionRequirementsKey = 6;
  // JSON document that will instantiate the result of the decision which was
  // evaluated; it will be a JSON object, as the result output will be mapped
  // in a key-value fashion, e.g. { "a": 1 }.
  string decisionOutput = 7;
  // a list of decisions that were evaluated within the requested decision evaluation
  repeated EvaluatedDecision evaluatedDecisions = 8;
  // an optional string indicating the ID of the decision which
  // failed during evaluation
  string failedDecisionId = 9;
  // an optional message describing why the decision which was evaluated failed
  string failureMessage = 10;
  // the tenant identifier of the evaluated decision
  string tenantId = 11;
  // the unique key identifying this decision evaluation
  int64 decisionInstanceKey = 12;
}

message EvaluatedDecision {
  // the unique key identifying the decision which was evaluated (e.g. returned
  // from a decision in the DeployResourceResponse message)
  int64 decisionKey = 1;
  // the ID of the decision which was evaluated
  string decisionId = 2;
  // the name of the decision which was evaluated
  string decisionName = 3;
  // the version of the decision which was evaluated
  int32 decisionVersion = 4;
  // the type of the decision which was evaluated
  string decisionType = 5;
  // JSON document that will instantiate the result of the decision which was
  // evaluated; it will be a JSON object, as the result output will be mapped
  // in a key-value fashion, e.g. { "a": 1 }.
  string decisionOutput = 6;
  // the decision rules that matched within this decision evaluation
  repeated MatchedDecisionRule matchedRules = 7;
  // the decision inputs that were evaluated within this decision evaluation
  repeated EvaluatedDecisionInput evaluatedInputs = 8;
  // the tenant identifier of the evaluated decision
  string tenantId = 9;
}

message EvaluatedDecisionInput {
  // the id of the evaluated decision input
  string inputId = 1;
  // the name of the evaluated decision input
  string inputName = 2;
  // the value of the evaluated decision input
  string inputValue = 3;
}

message EvaluatedDecisionOutput {
  // the ID of the evaluated decision output
  string outputId = 1;
  // the name of the evaluated decision output
  string outputName = 2;
  // the value of the evaluated decision output
  string outputValue = 3;
}

message MatchedDecisionRule {
  // the ID of the matched rule
  string ruleId = 1;
  // the index of the matched rule
  int32 ruleIndex = 2;
  // the evaluated decision outputs
  repeated EvaluatedDecisionOutput evaluatedOutputs = 3;
}
```

### Errors

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- No decision with the given key exists (if decisionKey was given).
- No decision with the given decision ID exists (if decisionId was given).
- Both decision ID and decision KEY were provided, or are missing.
- If multi-tenancy is enabled, and `tenantId` is blank (empty string, null)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantId` is not blank (empty string, null), or has an ID other than `<default>`

#### GRPC_STATUS_PERMISSION_DENIED

- If multi-tenancy is enabled, and an unauthorized tenant ID is provided

## `FailJob` RPC

Marks the job as failed. If the retries argument is positive and no retry back off is set, the job is immediately
activatable again. If the retry back off is positive the job becomes activatable once the back off timeout has passed.
If the retries argument is zero or negative, an incident is raised, tagged with the given errorMessage, and the job is
not activatable until the incident is resolved. If the variables argument is set, the variables are merged into the process at the local scope of the job's associated task.

### Input: `FailJobRequest`

```protobuf
message FailJobRequest {
  // the unique job identifier, as obtained when activating the job
  int64 jobKey = 1;
  // the amount of retries the job should have left
  int32 retries = 2;
  // an optional message describing why the job failed
  // this is particularly useful if a job runs out of retries and an incident is raised,
  // as it this message can help explain why an incident was raised
  string errorMessage = 3;
  // the backoff timeout (in ms) for the next retry
  int64 retryBackOff = 4;
  // JSON document that will instantiate the variables at the local scope of the
  // job's associated task; it must be a JSON object, as variables will be mapped in a
  // key-value fashion. e.g. { "a": 1, "b": 2 } will create two variables, named "a" and
  // "b" respectively, with their associated values. [{ "a": 1, "b": 2 }] would not be a
  // valid argument, as the root of the JSON document is an array and not an object.
  string variables = 5;
}
```

### Output: `FailJobResponse`

```protobuf
message FailJobResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No job was found with the given key.
- No job was found with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_FAILED_PRECONDITION

Returned if:

- The job was not activated.
- The job is already in a failed state, i.e. ran out of retries.

## `MigrateProcessInstance` RPC

Migrates a process instance to a new process definition. The command can contain multiple mapping instructions
to define mapping between the active process instance's elements and target process definition elements.

Use the command to upgrade a process instance to a new version of a process or to a different process definition.
E.g. keep your running instances up-to-date with the latest process improvements.

### Input: `MigrateProcessInstanceRequest`

```protobuf
message MigrateProcessInstanceRequest {
  // key of the process instance to migrate
  int64 processInstanceKey = 1;
  // the migration plan that defines target process and element mappings
  MigrationPlan migrationPlan = 2;

  message MigrationPlan {
    // the key of process definition to migrate the process instance to
    int64 targetProcessDefinitionKey = 1;
    // the mapping instructions describe how to map elements from the source process definition to the target process definition
    repeated MappingInstruction mappingInstructions = 2;
  }

  message MappingInstruction {
    // the element ID to migrate from
    string sourceElementId = 1;
    // the element ID to migrate into
    string targetElementId = 2;
  }
}
```

### Output: `MigrateProcessInstanceResponse`

```protobuf
message MigrateProcessInstanceResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No process instance exists with the given key, or it is not active
- No process definition exists with the given target definition key
- No process instance exists with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- A `sourceElementId` does not refer to an element in the process instance's process definition
- A `targetElementId` does not refer to an element in the target process definition
- A `sourceElementId` is mapped by multiple mapping instructions.
  For example, the engine cannot determine how to migrate a process instance when the instructions are: [A->B, A->C].

#### GRPC_STATUS_FAILED_PRECONDITION

Returned if:

- Not all active elements in the given process instance are mapped to the elements in the target process definition
- A mapping instruction changes the type of an element or event
- A mapping instruction changes the implementation of a task
- A mapping instruction refers to an unsupported element (i.e. some elements will be supported later on)
- A mapping instruction refers to element in unsupported scenarios.
  (i.e. migrating active elements with event subscriptions will be supported later on)
- A mapping instruction detaches a boundary event from an active element
- Multiple mapping instructions refer to the same catch event
- A mapping instruction changes a parallel multi-instance body to a sequential multi-instance body or vice versa

## `ModifyProcessInstance` RPC

Modifies a running process instance. The command can contain multiple instructions to activate an element of the
process, or to terminate an active instance of an element.

Use the command to repair a process instance that is stuck on an element or took an unintended path. For example,
because an external system is not available or doesn't respond as expected.

### Input: `ModifyProcessInstanceRequest`

```protobuf
message ModifyProcessInstanceRequest {
  // the key of the process instance that should be modified
  int64 processInstanceKey = 1;
  // instructions describing which elements should be activated in which scopes,
  // and which variables should be created
  repeated ActivateInstruction activateInstructions = 2;
  // instructions describing which elements should be terminated
  repeated TerminateInstruction terminateInstructions = 3;

  message ActivateInstruction {
    // the ID of the element that should be activated
    string elementId = 1;
    // the key of the ancestor scope the element instance should be created in;
    // set to -1 to create the new element instance within an existing element
    // instance of the flow scope
    int64 ancestorElementInstanceKey = 2;
    // instructions describing which variables should be created
    repeated VariableInstruction variableInstructions = 3;
  }

  message VariableInstruction {
    // JSON document that will instantiate the variables for the root variable scope of the
    // process instance; it must be a JSON object, as variables will be mapped in a
    // key-value fashion. e.g. { "a": 1, "b": 2 } will create two variables, named "a" and
    // "b" respectively, with their associated values. [{ "a": 1, "b": 2 }] would not be a
    // valid argument, as the root of the JSON document is an array and not an object.
    string variables = 1;
    // the ID of the element in which scope the variables should be created;
    // leave empty to create the variables in the global scope of the process instance
    string scopeId = 2;
  }

  message TerminateInstruction {
    // the ID of the element that should be terminated
    int64 elementInstanceKey = 1;
  }
}
```

### Output: `ModifyProcessInstanceResponse`

```protobuf
message ModifyProcessInstanceResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No process instance exists with the given key, or it is not active.
- No process instance was found with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- At least one activate instruction is invalid. An activate instruction is considered invalid if:
  - The process doesn't contain an element with the given ID.
  - A flow scope of the given element can't be created.
  - The given element has more than one active instance of its flow scope.
- At least one variable instruction is invalid. A variable instruction is considered invalid if:
  - The process doesn't contain an element with the given scope ID.
  - The given element doesn't belong to the activating element's flow scope.
  - The given variables are not a valid JSON document.
- At least one terminate instruction is invalid. A terminate instruction is considered invalid if:
  - No element instance exists with the given key, or it is not active.
- The instructions would terminate all element instances of a process instance that was created by a call activity in
  the parent process.

## `PublishMessage` RPC

Publishes a single message. Messages are published to specific partitions computed from their
correlation keys.

### Input: `PublishMessageRequest`

```protobuf
message PublishMessageRequest {
  // the name of the message
  string name = 1;
  // the correlation key of the message
  string correlationKey = 2;
  // how long the message should be buffered on the broker, in milliseconds
  int64 timeToLive = 3;
  // the unique ID of the message; can be omitted. only useful to ensure only one message
  // with the given ID will ever be published (during its lifetime)
  string messageId = 4;
  // the message variables as a JSON document; to be valid, the root of the document must be an
  // object, e.g. { "a": "foo" }. [ "foo" ] would not be valid.
  string variables = 5;
  // the tenant id of the message
  string tenantId = 6;
}
```

### Output: `PublishMessageResponse`

```protobuf
message PublishMessageResponse {
  // the unique ID of the message that was published
  int64 key = 1;
  // the tenant id of the message
  string tenantId = 2;
}
```

### Errors

#### GRPC_STATUS_ALREADY_EXISTS

Returned if:

- A message with the same ID was previously published (and is still alive).

#### GRPC_STATUS_NOT_FOUND

- If multi-tenancy is enabled, and `tenantId` is blank (empty string, null)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantId` is not blank (empty string, null), or has an ID other than `<default>`

#### GRPC_STATUS_PERMISSION_DENIED

- If multi-tenancy is enabled, and an unauthorized tenant ID is provided

## `ResolveIncident` RPC

Resolves a given incident. This simply marks the incident as resolved; most likely a call to
UpdateJobRetries or SetVariables will be necessary to actually resolve the
problem, followed by this call.

### Input: `ResolveIncidentRequest`

```protobuf
message ResolveIncidentRequest {
  // the unique ID of the incident to resolve
  int64 incidentKey = 1;
}
```

### Output: `ResolveIncidentResponse`

```protobuf
message ResolveIncidentResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No incident with the given key exists.
- No incident with the given key was found for the tenants the user is authorized to work with.

## `SetVariables` RPC

Updates all the variables of a particular scope (e.g. process instance, flow element instance) from the given JSON document.

### Input: `SetVariablesRequest`

```protobuf
message SetVariablesRequest {
  // the unique identifier of a particular element; can be the process instance key (as
  // obtained during instance creation), or a given element, such as a service task (see
  // elementInstanceKey on the job message)
  int64 elementInstanceKey = 1;
  // a JSON serialized document describing variables as key value pairs; the root of the document
  // must be an object
  string variables = 2;
  // if true, the variables will be merged strictly into the local scope (as indicated by
  // elementInstanceKey); this means the variables is not propagated to upper scopes.
  // for example, let's say we have two scopes, '1' and '2', with each having effective variables as:
  // 1 => `{ "foo" : 2 }`, and 2 => `{ "bar" : 1 }`. if we send an update request with
  // elementInstanceKey = 2, variables `{ "foo" : 5 }`, and local is true, then scope 1 will
  // be unchanged, and scope 2 will now be `{ "bar" : 1, "foo" 5 }`. if local was false, however,
  // then scope 1 would be `{ "foo": 5 }`, and scope 2 would be `{ "bar" : 1 }`.
  bool local = 3;
}
```

### Output: `SetVariablesResponse`

```protobuf
message SetVariablesResponse {
  // the unique key of the set variables command
  int64 key = 1;
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No element with the given `elementInstanceKey` exists.
- No element with the given `elementInstanceKey` was found for the tenants the user is authorized to work with.

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- The given payload is not a valid JSON document; all payloads are expected to be
  valid JSON documents where the root node is an object.

## `StreamActivatedJobs` RPC

Opens a long living stream for the given job type, worker name, job timeout, and fetch variables. This will cause available
jobs in the engine to be activated and pushed down this stream.

See the [job worker's technical reference](/components/concepts/job-workers.md) for more on this.

### Input `StreamActivatedJobsRequest`

```protobuf
message StreamActivatedJobsRequest {
  // the job type, as defined in the BPMN process (e.g. <zeebe:taskDefinition
  // type="payment-service" />)
  string type = 1;
  // the name of the worker activating the jobs, mostly used for logging purposes
  string worker = 2;
  // a job returned after this call will not be activated by another call until the
  // timeout (in ms) has been reached
  int64 timeout = 3;
  // a list of variables to fetch as the job variables; if empty, all visible variables at
  // the time of activation for the scope of the job will be returned
  repeated string fetchVariable = 5;
  // a list of identifiers of tenants for which to stream jobs
  repeated string tenantIds = 6;
}
```

### Output: a stream of `ActivatedJob`

```protobuf
message ActivatedJob {
  // Describes the kind of job.
  enum JobKind {
    BPMN_ELEMENT = 0;
    EXECUTION_LISTENER = 1;
    TASK_LISTENER = 2;
  }

  // Describes the listener event type of the job.
  enum ListenerEventType {
    ASSIGNING = 0;
    CANCELING = 1;
    COMPLETING = 2;
    CREATING = 3;
    END = 4;
    START = 5;
    UNSPECIFIED = 6;
    UPDATING = 7;
  }

  // the key, a unique identifier for the job
  int64 key = 1;
  // the type of the job (should match what was requested)
  string type = 2;
  // the job's process instance key
  int64 processInstanceKey = 3;
  // the bpmn process ID of the job process definition
  string bpmnProcessId = 4;
  // the version of the job process definition
  int32 processDefinitionVersion = 5;
  // the key of the job process definition
  int64 processDefinitionKey = 6;
  // the associated task element ID
  string elementId = 7;
  // the unique key identifying the associated task, unique within the scope of the
  // process instance
  int64 elementInstanceKey = 8;
  // a set of custom headers defined during modelling; returned as a serialized
  // JSON document
  string customHeaders = 9;
  // the name of the worker which activated this job
  string worker = 10;
  // the amount of retries left to this job (should always be positive)
  int32 retries = 11;
  // when the job can be activated again, sent as a UNIX epoch timestamp
  int64 deadline = 12;
  // JSON document, computed at activation time, consisting of all visible variables to
  // the task scope
  string variables = 13;
  // the ID of the tenant that owns the job
  string tenantId = 14;
  // the kind of the job.
  JobKind kind = 15;
  // the listener event type of the job.
  ListenerEventType listenerEventType = 16;
}
```

### Errors

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- Type is blank (empty string, null)
- Timeout less than 1 (ms)
- If multi-tenancy is enabled, and `tenantIds` is empty (empty list)
- If multi-tenancy is enabled, and an invalid tenant ID is provided. A tenant ID is considered invalid if:
  - The tenant ID is blank (empty string, null)
  - The tenant ID is longer than 31 characters
  - The tenant ID contains anything other than alphanumeric characters, dot (.), dash (-), or underscore (\_)
- If multi-tenancy is disabled, and `tenantIds` is not empty (empty list), or has an ID other than `<default>`

## `ThrowError` RPC

`ThrowError` reports a business error (i.e. non-technical) that occurs while processing a job.

The error is handled in the process by an error catch event. If there is no error catch event with the specified `errorCode`, an incident is raised instead.

Variables can be passed along with the thrown error to provide additional details that can be used in the process.

### Input: `ThrowErrorRequest`

```protobuf
message ThrowErrorRequest {
  // the unique job identifier, as obtained when activating the job
  int64 jobKey = 1;
  // the error code that will be matched with an error catch event
  string errorCode = 2;
  // an optional error message that provides additional context
  string errorMessage = 3;
  // JSON document that will instantiate the variables at the local scope of the
  // error catch event that catches the thrown error; it must be a JSON object, as variables will be mapped in a
  // key-value fashion. e.g. { "a": 1, "b": 2 } will create two variables, named "a" and
  // "b" respectively, with their associated values. [{ "a": 1, "b": 2 }] would not be a
  // valid argument, as the root of the JSON document is an array and not an object.
  string variables = 4;
}
```

### Output: `ThrowErrorResponse`

```protobuf
message ThrowErrorResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No job was found with the given key.
- No job was found with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_FAILED_PRECONDITION

Returned if:

- The job is already in a failed state, i.e. ran out of retries.

## `Topology` RPC

Obtains the current topology of the cluster the gateway is part of.

:::note
The partition role can be one of `LEADER`, `FOLLOWER`, or `INACTIVE`, which [is defined here](../../components/zeebe/technical-concepts/partitions.md#roles).
:::

:::note
The partition health can be one of `HEALTHY`, `UNHEALTHY`, or `DEAD`, which [is defined here](../../components/zeebe/technical-concepts/health.md).
:::

### Input: `TopologyRequest`

```protobuf
message TopologyRequest {
}
```

### Output: `TopologyResponse`

```protobuf
message TopologyResponse {
  // list of brokers part of this cluster
  repeated BrokerInfo brokers = 1;
  // how many nodes are in the cluster
  int32 clusterSize = 2;
  // how many partitions are spread across the cluster
  int32 partitionsCount = 3;
  // configured replication factor for this cluster
  int32 replicationFactor = 4;
  // gateway version
  string gatewayVersion = 5;
  // the cluster's unique ID
  string clusterId = 6;
}

message BrokerInfo {
  // unique (within a cluster) node ID for the broker
  int32 nodeId = 1;
  // hostname of the broker
  string host = 2;
  // port for the broker
  int32 port = 3;
  // list of partitions managed or replicated on this broker
  repeated Partition partitions = 4;
  // broker version
  string version = 5;
}

message Partition {
  // Describes the Raft role of the broker for a given partition
  enum PartitionBrokerRole {
    LEADER = 0;
    FOLLOWER = 1;
    INACTIVE = 2;
  }

  // Describes the current health of the partition
  enum PartitionBrokerHealth {
    HEALTHY = 0;
    UNHEALTHY = 1;
    DEAD = 2;
  }

  // the unique ID of this partition
  int32 partitionId = 1;
  // the role of the broker for this partition
  PartitionBrokerRole role = 2;
  // the health of this partition
  PartitionBrokerHealth health = 3;
}
```

### Errors

No specific errors.

## `UpdateJobRetries` RPC

Updates the number of retries a job has left. This is mostly useful for jobs that have run out of
retries, should the underlying problem be solved.

### Input: `UpdateJobRetriesRequest`

```protobuf
message UpdateJobRetriesRequest {
  // the unique job identifier, as obtained through ActivateJobs
  int64 jobKey = 1;
  // the new amount of retries for the job; must be positive
  int32 retries = 2;
}
```

### Output: `UpdateJobRetriesResponse`

```protobuf
message UpdateJobRetriesResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No job exists with the given key.
- No job was found with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_INVALID_ARGUMENT

Returned if:

- Retries is not greater than 0.

## `UpdateJobTimeout` RPC

Updates the deadline of a job using the timeout (in milliseconds) provided. This can be used for extending or shortening
the job deadline. The new deadline will be calculated from the current time, adding the timeout provided.

### Input: `UpdateJobTimeoutRequest`

```protobuf
message UpdateJobTimeoutRequest {
  // the unique job identifier, as obtained from ActivateJobsResponse
  int64 jobKey = 1;
  // the duration of the new timeout in ms, starting from the current moment
  int64 timeout = 2;
}
```

### Output: `UpdateJobTimeoutResponse`

```protobuf
message UpdateJobTimeoutResponse {
}
```

### Errors

#### GRPC_STATUS_NOT_FOUND

Returned if:

- No job exists with the given key.
- No job was found with the given key for the tenants the user is authorized to work with.

#### GRPC_STATUS_INVALID_STATE

Returned if:

- The job is not active.

---

## Zeebe API (gRPC)

<PageDescription />

## About

You can use the [gRPC](https://grpc.io/) high-performance, cross-platform remote procedure call (RPC) framework to communicate with the Orchestration Cluster.

Zeebe clients use gRPC to communicate with the cluster. For example, you can use this API to activate jobs, cancel and create process instances, and more.

## Why use gRPC?

Using this API may be beneficial if your use-case requires low-latency or high-throughput communication.

Benefits of gRPC include:

- Low-latency, high-throughput communication
- Bidirectional streaming for efficient microservices integration
- Ideal for scalable, event-driven process automation

## Key capabilities

- Activate jobs
- Create and cancel process instances
- Manage workflows and more

See [Zeebe API RPCs](gateway-service.md) for all available operations. Additionally, review [technical error handling](/apis-tools/zeebe-api/technical-error-handling.md) for a closer look at business logic errors, or [Postman](https://www.postman.com/camundateam/camunda-8-postman/collection/jzgs776/zeebe-api-grpc?action=share&creator=11465105) to experiment with the API.

## Authentication

Authentication for the Zeebe API (gRPC) depends on your environment and how you deploy Camunda 8. You can find more details in the [Authentication guide](./zeebe-api-authentication.md).

---

## Technical error handling

In the documentation above, the documented errors are business logic errors.
These errors are a result of request processing logic, and not serialization, network, or
other more general errors. These errors are described in this section.

The gRPC API for Zeebe is exposed through an API gateway, which acts as a proxy
for the cluster. Generally, this means the clients execute a remote call on the gateway,
which is then translated to special binary protocol the gateway uses to
communicate with nodes in the cluster. The nodes in the cluster are called brokers.

Technical errors which occur between gateway and brokers (e.g. the gateway cannot deserialize the broker response,
the broker is unavailable, etc.) are reported to the client using the following error codes:

- `GRPC_STATUS_RESOURCE_EXHAUSTED`: When a broker receives more requests than it can handle, it signals backpressure and rejects requests with this error code.
  - In this case, it is possible to retry the requests with an appropriate retry strategy.
  - If you receive many such errors within a short time period, it indicates the broker is constantly under high load.
- `GRPC_STATUS_UNAVAILABLE`: If the gateway itself is in an invalid state (e.g. out of memory).
- `GRPC_STATUS_INTERNAL`: For any other internal errors that occurred between the gateway and the broker.

<BackpressureWarning/>

This behavior applies to every request. In these cases, the client should retry
with an appropriate retry policy (e.g. a combination of exponential backoff or jitter wrapped
in a circuit breaker).

As the gRPC server/client is based on generated code, keep in mind that
any call made to the server can also return errors as described by the spec
[here](https://grpc.io/docs/guides/error.html#error-status-codes).

---

## Authentication(Zeebe-api)

This page describes the available authentication methods for accessing the Zeebe API (gRPC) in the Orchestration Cluster. Similar to the Orchestration Cluster REST API, the Zeebe API supports three authentication methods:

- **No Authentication**
- **Basic Authentication**
- **OIDC-based Authentication**

Please refer to the [Orchestration Cluster API authentication guide](./../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md) for more details on each method and general guidance on usage.

---

## Tutorial(Zeebe-api-rest)

In this tutorial, we'll step through examples to highlight the capabilities of the Zeebe API, such as assigning and unassigning a user to and from a Zeebe user task.

## Prerequisites

- If you haven't done so already, [create a cluster](/components/hub/organization/manage-clusters/create-cluster.md).
- Upon cluster creation, [create your first client](/components/hub/organization/manage-clusters/manage-api-clients.md#create-a-client). Ensure you check the `Zeebe` client scope box.

:::note
Make sure you keep the generated client credentials in a safe place. The **Client secret** will not be shown again. For your convenience, you can also download the client information to your computer.
:::

- In this tutorial, we utilize a JavaScript-written [GitHub repository](https://github.com/camunda/camunda-api-tutorials) to write and run requests. Clone this repo before getting started.
- Ensure you have [Node.js](https://nodejs.org/en/download) installed as this will be used for methods that can be called by the CLI (outlined later in this guide). Run `npm install` to ensure you have updated dependencies.

## Getting started

- You need authentication to access the API endpoints. See [Zeebe REST API authentication](./zeebe-api-rest-authentication.md).

## Set up authentication

If you're interested in how we use a library to handle auth for our code, or to get started, examine the `auth.js` file in the GitHub repository. This file contains a function named `getAccessToken` which executes an OAuth 2.0 protocol to retrieve authentication credentials based on your client id and client secret. Then, we return the actual token that can be passed as an authorization header in each request.

To set up your credentials, create an `.env` file which will be protected by the `.gitignore` file. You will need to add your `ZEEBE_CLIENT_ID`, `ZEEBE_CLIENT_SECRET`, `ZEEBE_BASE_URL`, and `ZEEBE_AUDIENCE`, which is `zeebe.camunda.io` in a Camunda 8 SaaS environment. For example, your audience may be defined as `ZEEBE_AUDIENCE=zeebe.camunda.io`.

These keys will be consumed by the `auth.js` file to execute the OAuth protocol, and should be saved when you generate your client credentials in [prerequisites](#prerequisites).

Examine the existing `.env.example` file for an example of how your `.env` file should look upon completion. Do not place your credentials in the `.env.example` file, as this example file is not protected by the `.gitignore`.

:::note

In this tutorial, we will execute arguments to assign and unassign a user to and from a Zeebe user task. You can examine the framework for processing these arguments in the `cli.js` file before getting started.

:::

## Assign a Zeebe user task (POST)

:::note
In this tutorial, you will capture a **Zeebe user task** ID to assign and unassign users in this API. Camunda 8.5 introduced this new [user task](/components/modeler/bpmn/user-tasks/user-tasks.md) implementation type, and these Zeebe user tasks are different from job worker-based user tasks (which while still supported, are now deprecated with 8.6). See more details on task type differences in the [migrating to Zeebe user tasks documentation](/apis-tools/migration-manuals/migrate-to-camunda-user-tasks.md#task-type-differences).
:::

First, let's script an API call to assign a Zeebe user task.

To do this, take the following steps:

1. In the file named `zeebe.js`, outline the authentication and authorization configuration in the first few lines. This will pull in your `.env` variables to obtain an access token before making any API calls:

```javascript
const authorizationConfiguration = {
  clientId: process.env.ZEEBE_CLIENT_ID,
  clientSecret: process.env.ZEEBE_CLIENT_SECRET,
  audience: process.env.ZEEBE_AUDIENCE,
};
```

2. Examine the function `async function assignUser([userTaskKey, assignee])` below this configuration. This is where you will script out your API call.
3. Within the function, you must first generate an access token for this request, so your function should now look like the following:

```javascript
async function assignUser([userTaskKey, assignee]) {
  const accessToken = await getAccessToken(authorizationConfiguration);
}
```

4. Using your generated client credentials from [prerequisites](#prerequisites), capture your Zeebe API URL beneath your call for an access token by defining `zeebeApiUrl`:

`const zeebeApiUrl = process.env.ZEEBE_BASE_URL`

5. On the next line, script the API endpoint to assign a Zeebe user task.:

```javascript
const url = `${ZeebeApiUrl}/user-tasks/${userTaskKey}/assignment`;
```

6. Configure your POST request to the appropriate endpoint, including an authorization header based on the previously acquired `accessToken`:

```javascript
const options = {
  method: "POST",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
  data: {
    // The body contains information about the new assignment.
    assignee: assignee,
  },
};
```

7. Call the assign endpoint, process the results from the API call, and emit an error message from the server if necessary:

```javascript
try {
  // Call the assign endpoint.
  const response = await axios(options);

  // Process the results from the API call.
  if (response.status === 204) {
    console.log(`User task assigned to ${assignee}.`);
  } else {
    // Emit an unexpected error message.
    console.error("Unable to assign this user!");
  }
} catch (error) {
  // Emit an error from the server.
  console.error(error.message);
}
```

8. In your terminal, run `node cli.js zeebe assign <task id> <assignee@assignee.com>`, where `<task id>` is the Zeebe user task ID you've captured from Tasklist, and `<assignee@assignee.com>` is the assignee's email address. Include your own email address if you would like to see these results in your user interface.

:::note
This `assign` command is connected to the `assignUser` function at the bottom of the `zeebe.js` file, and executed by the `cli.js` file. While we will assign and unassign users in this tutorial, you may add additional arguments depending on the API calls you would like to make.
:::

If you have a valid user and task ID, the assignment will now output. If you have an invalid API name or action name, or no arguments provided, or improper/insufficient credentials configured, an error message will output as outlined in the `cli.js` file. If no action is provided, it will default to "assign" everywhere, except when unassigning a user.

## Unassign a Zeebe user task (DELETE)

To unassign a user from a Zeebe user task, you can use the same Zeebe user task ID from the previous exercise and take the following steps:

1. Outline your function, similar to the steps above:

```javascript
async function unassignUser([userTaskKey]) {
  const accessToken = await getAccessToken(authorizationConfiguration);

  const ZeebeApiUrl = process.env.ZEEBE_BASE_URL;

  const url = `${ZeebeApiUrl}/user-tasks/${userTaskKey}/assignee`;
}
```

2. Configure the API call using the DELETE method:

```javascript
const options = {
  method: "DELETE",
  url,
  headers: {
    Accept: "application/json",
    Authorization: `Bearer ${accessToken}`,
  },
};
```

3. Process the results from the API call. For example:

```javascript
try {
  // Call the delete endpoint.
  const response = await axios(options);

  // Process the results from the API call.
  if (response.status === 204) {
    console.log("User task has been unassigned!");
  } else {
    // Emit an unexpected error message.
    console.error("Unable to unassign this user task!");
  }
} catch (error) {
  // Emit an error from the server.
  console.error(error.message);
}
```

4. In your terminal, run `node cli.js zeebe unassign <task id>`, where `<task id>` is the Zeebe user task ID.

## If you get stuck

Having trouble configuring your API calls or want to examine an example of the completed tutorial? Navigate to the `completed` folder in the [GitHub repository](https://github.com/camunda/camunda-api-tutorials/tree/main/completed), where you can view an example `zeebe.js` file.

## Next steps

You can script several additional API calls as outlined in the [Zeebe API reference material](./zeebe-api-rest-overview.md).

---

## Authentication(Zeebe-api-rest)

:::warning
The Zeebe REST API is **deprecated**. While it continues to function, new development should use the Orchestration Cluster REST API by referencing the [Orchestration Cluster REST API migration documentation](/apis-tools/migration-manuals/migrate-to-camunda-api.md).
:::

The Zeebe REST API uses the same authentication mechanism as the [Orchestration Cluster REST API](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md).

If your environment uses **OIDC-based authentication**, obtain an access token following [Using a token (OIDC/JWT)](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md#using-a-token-oidcjwt).

If **no authentication is configured** (for example, for local development), see [No authentication (local development)](../orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md#no-authentication-local-development).

When making requests to Zeebe, replace the base URL used in examples with your Zeebe API URL.

Example:

```bash
curl "$ZEEBE_BASE_URL/v2/topology" \
  -H "Authorization: Bearer $ACCESS_TOKEN"
```

#### Token expiration

Access tokens expire according to the `expires_in` property of a successful authentication response. After this duration, in seconds, you must request a new access token.

---

## Overview

:::warning
The Zeebe REST API is **deprecated**. While it continues to function, new development should use the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md). See the [migration guide](/apis-tools/migration-manuals/migrate-to-camunda-api.md) for details.
:::

## Introduction

The Zeebe REST API is a REST API designed to interact with the Zeebe workflow engine.

:::note
Ensure you [authenticate](./zeebe-api-rest-authentication.md) before accessing the Zeebe REST API.
:::

## Context paths

### SaaS

Find your **region Id** and **cluster Id** under **Connection information** in your client credentials (revealed when you click on your client under the **API** tab within your cluster).

Example path: `https://${REGION}.api.camunda.io:443/${CLUSTER_ID}/v1/`

### Self-Managed

Use the host and path defined for your [Zeebe Gateway](/reference/glossary.md#zeebe-gateway). For Ingress and routing details, see the [configuration guide](/self-managed/deployment/helm/configure/ingress/ingress-setup.md). The path used here is the default.

Example path: `http://localhost:8080/v1/`

## API Explorer

See [the interactive Zeebe REST API Explorer][zeebe-api-explorer] for specifications, example requests and responses, and code samples of interacting with the Tasklist REST API.

[zeebe-api-explorer]: ./specifications/zeebe-rest-api.info.mdx

---

## Access control

If authorization control is enabled for your Orchestration Cluster, users require the following authorizations to work with Admin.

:::note
If you already have another administration user, they can assign these [in the Admin UI](components/admin/authorization.md#create-an-authorization). See [the introduction to authorizations](components/concepts/access-control/authorizations.md#available-resources) for a list of all available authorizations.
:::

## Mandatory authorizations

The following mandatory authorizations are required to work with Admin:

| Authorization type     | Resource type | Resource ID                                                                  | Permission |
| :--------------------- | :------------ | :--------------------------------------------------------------------------- | :--------- |
| Admin component access | `Component`   | `admin` or `identity` (deprecated) or `*` (for access to all web components) | `ACCESS`   |

## Authorizations per resource

The following authorizations are required to manage each User, Group, Role, Authorization, Mapping Rule, and Tenant resource:

| Authorization type                 | Resource type                                                     | Resource ID                                                                     | Permission                                  |
| :--------------------------------- | :---------------------------------------------------------------- | :------------------------------------------------------------------------------ | :------------------------------------------ |
| Create/Read/Update/Delete resource | One of `User`, `Group`, `Authorization`, `Mapping Rule`, `Tenant` | ID of the resource or `*` (for access to all resources and to create resources) | Any of `CREATE`, `READ`, `UPDATE`, `DELETE` |

## Optional authorizations

The following optional authorizations can also be defined:

| Authorization type                 | Resource type     | Resource ID                        | Permission                                                                                   |
| :--------------------------------- | :---------------- | :--------------------------------- | :------------------------------------------------------------------------------------------- |
| View audit log entries.            | `AUDIT_LOG`       | `ADMIN` or `*` for all categories. | `READ`                                                                                       |
| Manage global user task listeners. | `GLOBAL_LISTENER` | `*`                                | `CREATE_TASK_LISTENER`, `READ_TASK_LISTENER`, `UPDATE_TASK_LISTENER`, `DELETE_TASK_LISTENER` |

---

## Introduction to Admin

Use the integrated [Orchestration Cluster](../orchestration-cluster.md) Admin (formerly Orchestration Cluster Identity) to manage Camunda 8 authentication, authorization, and cluster administration.

:::note
This was renamed in 8.9 to reflect its expanded scope and to avoid confusion with [Management Identity](/self-managed/components/management-identity/overview.md).
:::

## About Admin

The Orchestration Cluster Admin interface centralizes all key administrative jobs for a single cluster. This interface manages identity and access control for cluster components, including Zeebe, Operate, Tasklist, and Orchestration Cluster APIs, while also handling other core features such as cluster variables and the global user task listener, giving administrators one clear place to configure and operate their clusters end to end.

Admin includes the following features:

| Feature                                                     | Description                                                                                                                                                   |
| :---------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Unified access management                                   | Authentication and authorization are handled consistently across all Orchestration Cluster components and APIs.                                               |
| Flexible authentication                                     | Admin supports multiple authentication modes, including no authentication, Basic authentication, and OpenID Connect (OIDC), depending on the deployment type. |
| Tenant management                                           | Multi-tenancy is managed directly within the Orchestration Cluster, allowing for clear separation of resources.                                               |
| [Cluster variables](cluster-variables.md)                   | Manage configuration values centrally across your cluster, making them available in FEEL expressions.                                                         |
| [Global user task listeners](global-user-task-listeners.md) | Configure cluster-wide listeners that react to user task lifecycle events across all processes.                                                               |

For details about authorization concepts, resources, and configuration, see
[Orchestration Cluster authorizations](../concepts/access-control/authorizations.md).

## Manage access

Depending on your setup, Admin allows you to manage Orchestration Cluster access as follows:

| Entity                             | Description                                                                                                                         | Availability    |
| :--------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------- | :-------------- |
| [Users](user.md)                   | Individuals who can access applications and perform actions based on their permissions.                                             | All deployments |
| [Groups](group.md)                 | Simplify access management by granting permissions collectively to groups of users.                                                 | All deployments |
| [Roles](role.md)                   | Sets of permissions to define what actions can be performed on specific resources. Roles can be assigned to users and groups.       | All deployments |
| [Authorizations](authorization.md) | The specific permissions that connect users, groups, or roles with resources and actions (for example, `READ`, `UPDATE`, `DELETE`). | All deployments |
| [Tenants](tenant.md)               | Logically isolate data within a single cluster. This is useful for multi-tenancy applications.                                      | All deployments |

:::info Admin in Self-Managed
For documentation on deploying Admin as part of Camunda 8 Self-Managed, see [Admin in Self-Managed](/self-managed/components/orchestration-cluster/admin/overview.md).
:::

---

## Audit operations

Audit [operations](../audit-log/overview.md) in Camunda 8 Admin.

## Prerequisites

To follow the steps in this guide, you must be [authorized to view operations in the audit log](../audit-log/overview/access-control.md).

## Audit operations

In Admin, you can audit all [`ADMIN` operations](../audit-log/overview/recorded-operations.md#admin-operations):

1. In the top navigation, click **Operations log**.
2. To sort the log, click a column header.

## Next steps

- [Learn about the operation data structure in the operations log.](../audit-log/overview/operation-structure.md)
- [Use the Audit Log REST API to programmatically access the audit log](../../apis-tools/orchestration-cluster-api-rest/specifications/search-audit-logs.api.mdx).

---

## Authorizations

Use authorizations to control access to resources in your Orchestration Cluster.

## About authorizations

An authorization grants an owner access to a resource and defines the specific permissions they have.

- Owner: The entity that receives permissions, such as a [user](user.md), [group](group.md), [role](role.md), [client](client.md), or [mapping rule](mapping-rules.md).
  - In SaaS deployments, the username is the user's email address.
  - In Self-Managed deployments, the username must match [the value of the claim configured as `username-claim`](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md#step-4-configure-the-oidc-connection-details).
- Resource: The object that the permissions apply to, such as a process definition, decision definition, or system. See the full list of [available resources](/components/concepts/access-control/authorizations.md#available-resources).

Each authorization specifies which permissions the owner has for the resource (for example, `READ`, `UPDATE`, `DELETE`).

For an authorization to apply, [enable it in your cluster configuration](/components/concepts/access-control/authorizations.md#configuration).

To learn more, see [Orchestration Cluster authorizations](/components/concepts/access-control/authorizations.md).

## Create an authorization in Admin

To create a new authorization:

1. Log in to Admin, and select the **Authorizations** tab.
2. Select a resource type from the list on the left, and select **Create authorization**.
3. Enter the following information:
   - **Owner type**: The entity to which you want to assign permissions, such as a user, group, role, client, or mapping rule.
   - **Owner ID**: The ID of the owner.
   - **Resource type**: The selected resource type.
   - **Resource scope**: Choose how this authorization is scoped:
     - By **Resource ID**, or
     - For `USER_TASK`, by **Resource property name** with the `PROPERTY` matcher.
   - **Resource ID**: The ID of the resource within the selected resource type. Use `*` to grant permissions for all resources of that type.
   - **Resource property name** _(USER_TASK only)_: The task property used when scoping access with the `PROPERTY` matcher. Supported values are:
     - `assignee`
     - `candidateUsers`
     - `candidateGroups`

   Only one of **Resource ID** or **Resource property name** can be specified.
   If you use a resource property, set the matcher to `PROPERTY`.

4. Select the permissions you want to grant.
5. Click **Create authorization**.

The authorization is created, and the owner is granted the specified permissions.

## User task authorizations

To support fine-grained access to user tasks in Tasklist and the Orchestration Cluster REST API, Admin provides a **USER_TASK** resource type with the following permissions:

- `READ`: View the task and its properties.
- `UPDATE`: Perform updates on the task (for example, change assignment, due dates, or candidate users or groups).
- `CLAIM`: Claim a task from a pool of candidate users or groups.
- `COMPLETE`: Complete the task, with or without variables.

### Configure property-based user task authorizations

With property-based user task authorizations, you can grant permissions based on task assignment rather than a specific task ID. A user is authorized when their username or group membership matches a corresponding task property.

To create a property-based user task authorization:

1. Log in to Admin, and select the **Authorizations** tab.
2. Create a new authorization for the `USER_TASK` resource type.
3. Specify the **Owner type** and **Owner ID** (for example, a role that represents task workers).
4. Set the matcher to `PROPERTY`.
5. Select the task property used to scope access:
   - `assignee`
   - `candidateUsers`
   - `candidateGroups`
6. Select the permissions to grant (for example `READ`, `CLAIM`, and `COMPLETE`).
7. Create the authorization.

You can't combine multiple task properties in a single authorization. To cover all three properties (`assignee`, `candidateUsers`, `candidateGroups`), create one authorization per property.

### Authorization for user tasks

You can control access to user tasks using a combination of process-level and task-level permissions:

- Process-level permissions on the `Process Definition` resource, such as `READ_USER_TASK`, `CLAIM_USER_TASK`, `COMPLETE_USER_TASK`, and `UPDATE_USER_TASK`.
- Task-level permissions on the `USER_TASK` resource, such as `READ`, `UPDATE`, `CLAIM`, and `COMPLETE`, which are typically scoped using property-based access control on task properties such as `assignee`, `candidateUsers`, and `candidateGroups`.

When both process-level and task-level permissions exist, process-level permissions take precedence.
If a user already has the required `Process Definition` permission for an operation (for example, `READ_USER_TASK`, `CLAIM_USER_TASK`, `COMPLETE_USER_TASK`, or `UPDATE_USER_TASK`), the system does not evaluate `USER_TASK` permissions for that operation.
Task-level `USER_TASK` permissions are evaluated only when no effective process‑level permission exists for that user and process definition.

For Tasklist-specific behavior and practical authorization patterns, see [User task authorization in Tasklist](../tasklist/user-task-authorization.md).

### Authorization examples

#### Supervisor: broad process-level access

To allow a supervisor to see and manage all user tasks for one or more processes:

- Resource type: `PROCESS_DEFINITION`
- Resource scope: by **Resource ID**
- Resource ID: `*` (or a specific BPMN process ID)
- Permissions: `READ_USER_TASK`, `UPDATE_USER_TASK`, `CLAIM_USER_TASK`, `COMPLETE_USER_TASK`

This grants broad visibility and control over all user tasks for the selected processes, without needing task-level authorizations.

#### Task worker: property-based access

The default task worker role is created with property-based user task authorizations:

- Role ID: `task-worker`
- Resource type: `USER_TASK`
- Resource scope: by **Resource property name** (`PROPERTY` matcher)
- Property name: `assignee`, `candidateUsers`, or `candidateGroups`
- Permissions: `READ`, `CLAIM`, `COMPLETE`

This ensures that task workers can only see, claim, and complete tasks where they are the assignee, a candidate user, or in a candidate group.

:::note
Default roles, including task worker, are recreated each time the cluster starts and are not customizable.
To adjust permissions, create and manage custom roles instead.
:::

## Change an existing authorization

:::tip
Partial wildcard matching, for example `my-resource*`, is not supported.
:::

## Update an authorization

Authorizations cannot be updated after they are created.

To edit an authorization, [delete](#delete-an-authorization) the existing one, and create a new authorization with the updated permissions.

## Delete an authorization

Delete an authorization by completing the following steps:

1. Log in to Admin, and select the **Authorizations** tab.
2. Select the resource type of the authorization you want to delete.
3. In the list, find the authorization you want to remove and click **Delete**.
4. Confirm the deletion by clicking **Delete** in the confirmation dialog.

The authorization is deleted, and the owner no longer has the permissions granted by it.

:::caution
Deleting an authorization is permanent and can't be undone.
:::

---

## Clients

Configure and manage client access to a cluster so the client application has the permissions it requires.

## About client application access

A client is an application that interacts with an Orchestration Cluster via its APIs.

This guide describes how to manage client access in SaaS and in Self-Managed environments that use an [external OpenID Connect (OIDC) identity provider](../concepts/access-control/connect-to-identity-provider.md) for authentication.

If you are using the Orchestration Cluster with [Basic authentication](/self-managed/concepts/authentication/authentication-to-orchestration-cluster.md#basic-authentication), both end users and machine-to-machine (m2m) applications are treated as users and must be [managed accordingly](user.md). The Admin UI does not display dedicated client options in Basic authentication setups for this reason.

## Manage clients in SaaS

In Camunda 8 SaaS, client credentials are created and managed in [Camunda Hub](../hub/index.md).

### Step 1: Create client credentials in Camunda Hub

Follow the [guide for creating client credentials in Camunda Hub](../hub/organization/manage-clusters/manage-api-clients.md#create-a-client).

Copy the **client id** shown in the variables after you have created your client as this is required in the next step.

### Step 2: Configure authorizations in Admin

If you have enabled [authorizations](/components/concepts/access-control/authorizations.md) on your cluster, the new client has no permissions by default, even after assigning scopes in Camunda Hub. You must grant fine-grained permissions in Admin:

1.  Open the **Admin** application for your cluster.
2.  Open the **Authorizations** tab.
3.  Click **Create authorization**.
4.  Set the **Owner type** to `Client`.
5.  In the **Owner ID** field, enter the **Client ID** of the client you just created and copied.
6.  Select the **Resource type**, **Resource ID**, and permissions the client needs.
7.  Click **Create authorization**.

If authorizations are disabled, your client will have full access based on the scopes you selected during creation.

## Manage clients in Self-Managed with OIDC authentication

To configure a client application in a [Self-Managed environment with OIDC](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md), complete the following two steps:

1. Register your client application with your identity provider to obtain client credentials.
2. Configure authorizations for the client in the Orchestration Cluster Admin to grant the necessary permissions.

After completing these steps, your client application can then authenticate with your IdP, obtain an access token, and use that token to make authorized API calls to the Camunda 8 orchestration cluster.

### Prerequisites

Your Orchestration Cluster must be [configured to use a token claim as the client id](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md#step-1-configure-the-oidc-client-id-claim).

### Step 1: Create client credentials in your IdP

Before configuring access in the Orchestration Cluster, you must register your client application in your OIDC-compatible identity provider (for example, EntraID, Keycloak, Okta).

During the registration process, your identity provider will provide you with a **Client ID** and a **Client Secret**. Your application will use these credentials to authenticate and obtain an access token.

### Step 2: Configure authorizations in Admin

Once you have your client credentials, you can configure the required permissions in the Admin component of your cluster. Log in to Admin and choose one of the following methods to grant authorizations.

#### Authorization based on client ID

This method is suitable when your client application requires a fixed set of permissions. Follow [the steps on how to create authorizations](/components/admin/authorization.md#create-an-authorization) with the following specifics:

- As the **Owner type**, select `Client`.
- In the **Owner ID** field, enter the **Client ID** that matches your client's value for the configured client id claim.

You can also assign the client to existing [groups](./group.md) or [roles](./role.md) to inherit their permissions.

#### Flexible authorization based on JWT claims with mapping rules

This method is ideal when you need to dynamically assign permissions based on claims in the OIDC access token, such as scopes or custom claims.

1. [Create a mapping rule](/components/admin/mapping-rules.md#add-a-mapping-rule) that matches a claim from your client's access token.
2. [Create authorizations](/components/admin/authorization.md#create-an-authorization) for the mapping rule with the following specifics:
   - As the **Owner type**, select `Mapping Rule`.
   - In the **Owner ID** field, enter the **Mapping Rule ID** that you chose in the previous step.

Alternatively, you can assign the mapping rule to [groups](./group.md) or [roles](./role.md) to inherit their permissions.

Any client that authenticates with a token matching the criteria of the mapping rule will be granted the associated permissions.

---

## Cluster variables

Use Admin to manage cluster variables, which store configuration values centrally across your cluster and make them available in [FEEL expressions](/components/modeler/feel/cluster-variable/overview.md).

## About cluster variables

Cluster variables allow you to maintain environment-specific configurations, API endpoints, feature flags, and other shared values without hardcoding them into individual process definitions. Variables can be defined at the global (cluster-wide) or tenant level.

:::tip
To learn more about cluster variables, including scope resolution, data types, and FEEL expression usage, see the [cluster variables overview](/components/modeler/feel/cluster-variable/overview.md).
:::

You can manage cluster variables through the Admin UI or the [Orchestration Cluster API](/apis-tools/orchestration-cluster-api-rest/specifications/create-global-cluster-variable.api.mdx).

## Manage global cluster variables

Global cluster variables are available to all processes across the entire cluster.

### Create a global cluster variable

1. Log in to Admin in your cluster, and select the **Cluster Variables** tab.
2. Click **Create variable**.
3. Provide the following details:
   - **Name**: A unique identifier for the variable.
   - **Value**: The value of the variable, which can be a string, number, boolean, or JSON object.
4. Click **Create variable**.

The variable is created and immediately available for use in FEEL expressions across all processes in the cluster using `camunda.vars.cluster.<name>` or `camunda.vars.env.<name>`.

### Update a global cluster variable

1. Log in to Admin in your cluster, and select the **Cluster Variables** tab.
2. Click the **pencil icon** next to the variable you want to update.
3. Update the variable value.
4. Click **Save**.

The updated value takes effect for new evaluations of FEEL expressions that reference this variable.

### Delete a global cluster variable

1. Log in to Admin in your cluster, and select the **Cluster Variables** tab.
2. Click **Delete** next to the variable you want to delete.
3. Confirm the deletion by clicking **Delete** in the confirmation dialog.

The variable is deleted and is no longer available in FEEL expressions.

:::note
Deleting a cluster variable does not affect process instances that have already resolved the variable value.
:::

## Manage tenant cluster variables

When [multi-tenancy](/components/concepts/multi-tenancy.md) is enabled, you can define tenant-specific cluster variables that override global variables with the same name for processes running in that tenant.

### Create a tenant cluster variable

1. Log in to Admin in your cluster, and select the **Cluster Variables** tab.
2. Select the tenant for which you want to create a variable.
3. Click **Create variable**.
4. Provide the following details:
   - **Name**: A unique identifier for the variable.
   - **Value**: The value of the variable.
5. Click **Create variable**.

The variable is created and available in FEEL expressions for processes running in the selected tenant using `camunda.vars.tenant.<name>` or `camunda.vars.env.<name>`.

:::note
If a global variable with the same name exists, the tenant-level variable takes precedence for processes running in this tenant. See [scope resolution](/components/modeler/feel/cluster-variable/scope-and-priority.md) for details.
:::

### Update a tenant cluster variable

1. Log in to Admin in your cluster, and select the **Cluster Variables** tab.
2. Select the tenant for which you want to update the variable.
3. Click the **pencil icon** next to the variable you want to update.
4. Update the variable value.
5. Click **Save**.

### Delete a tenant cluster variable

1. Log in to Admin in your cluster, and select the **Cluster Variables** tab.
2. Select the tenant for which you want to delete the variable.
3. Click **Delete** next to the variable you want to delete.
4. Confirm the deletion by clicking **Delete** in the confirmation dialog.

## See also

- [Cluster variables overview](/components/modeler/feel/cluster-variable/overview.md) — learn about scopes, data types, and FEEL expression usage.
- [Get started with cluster variables](/components/modeler/feel/cluster-variable/get-started.md) — tutorial for creating and using your first cluster variable.
- [Orchestration Cluster API: Create global cluster variable](/apis-tools/orchestration-cluster-api-rest/specifications/create-global-cluster-variable.api.mdx) — manage cluster variables via API.

---

## Global user task listeners

Use Admin to manage [global user task listeners](/components/concepts/global-user-task-listeners.md), which are cluster-wide listeners that react to user task lifecycle events across all processes.

## About global user task listeners

Global user task listeners allow you to define listeners once for all processes in a cluster, instead of individually per user task. They are useful for centralizing audit logging, notifications, governance rules, and other cross-cutting concerns.

:::tip
To learn more about global user task listeners, including execution order, supported features, and configuration options, see the [global user task listeners concept page](/components/concepts/global-user-task-listeners.md).
:::

You can manage global user task listeners through the Admin UI, [Unified Configuration](/components/concepts/global-user-task-listeners/configuration.md#configure-through-unified-configuration), or the [Orchestration Cluster API](/apis-tools/orchestration-cluster-api-rest/specifications/create-global-task-listener.api.mdx).

## Manage global user task listeners in Admin

The Admin UI provides a user-friendly interface to manage global user task listeners in the **Global User Task Listeners** tab. Changes made through the Admin UI take effect immediately, without requiring a cluster restart.

:::note
The Admin UI uses the Orchestration Cluster API to manage listeners. Listeners created through the Admin UI have their `source` property set to `API`.
:::

### Create a global user task listener

1. Log in to Admin in your cluster, and select the **Global User Task Listeners** tab.
2. Click **Create listener**.
3. Provide the following details:
   - **Listener ID**: A unique identifier for the listener.
   - **Listener type**: The name of the listener type. Job workers use this to identify and process listener jobs.
   - **Event type**: The user task lifecycle events that trigger the listener, selected from the dropdown menu with the following supported values: "All events", "Assigning", "Canceling", "Completing", "Creating", and "Updating".
   - **Retries** (optional): Number of retries for the listener job. Defaults to `3`.
     - **Execution order**: When the global listener should be executed with respect to model-level ones. Supported values: "Before model-level listeners" or "After model-level listeners".
   - **Priority** (optional): The priority of the listener. Higher priority listeners are executed first. Defaults to `50`.
4. Click **Create**.

The listener is created and immediately applies to new lifecycle events for both running and new process instances.

### Update a global user task listener

1. Log in to Admin in your cluster, and select the **Global User Task Listeners** tab.
2. Click the **pencil icon** next to the listener you want to update.
3. Update the listener details.
4. Click **Update**.

The updated listener configuration applies immediately to new lifecycle events.

### Delete a global user task listener

1. Log in to Admin in your cluster, and select the **Global User Task Listeners** tab.
2. Click **Delete** next to the listener you want to delete.
3. Confirm the deletion by clicking **Delete** in the confirmation dialog.

The listener is deleted and no longer triggers for new lifecycle events. In-progress listener jobs are not affected.

### Known limitations

The Admin UI retrieves the listener list from secondary storage. Because secondary storage is eventually consistent, changes might not appear immediately.

## See also

- [Global user task listeners](/components/concepts/global-user-task-listeners.md) — learn about execution order, supported features, and configuration options.
- [User task listeners](/components/concepts/user-task-listeners.md) — learn about model-level user task listeners.
- [Orchestration Cluster API: Create global task listener](/apis-tools/orchestration-cluster-api-rest/specifications/create-global-task-listener.api.mdx) — manage listeners via API.

---

## Groups

A user group is a way to organize multiple [users](user.md) in one unit. Groups simplify access management by allowing you to assign permissions to a collection of users at once, rather than individually. You can grant permissions to a group by assigning [roles](role.md) to it or creating direct [authorizations](authorization.md).

## Create a group

To create a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the **Create group** button, and provide the following group details:
   - **Group ID**: The unique identifier for the group.
   - **Name**: The name of the group.
   - **Description**: A description of the group.
3. Click on the **Create group** button.

The group is created and can now be assigned to roles or users.

![identity-create-group-tab](./img/create-group-tab.png)

## Update a group

To update a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the **pencil icon** next to the group you want to update.
3. Update the group details:
   - **Name**: The name of the group.
   - **Description**: A description of the group.
4. Click on the **Save** button.

The group details are updated.

## Delete a group

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the **Delete** button next to the group you want to delete.
3. Confirm the deletion by clicking on the **Delete** button in the confirmation dialog.

The group is deleted. Users and roles that were assigned to the group will not be affected, but they will no longer be part of the group. The authorizations that were granted to the group will also be removed.

## Assign authorizations to a group

See the [authorization](./authorization.md) section to learn how to create authorizations for groups.

## Manage users

### Assign users to a group

To assign users to a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to assign users to.
3. Click on the **Users** tab.
4. Click on the **Assign user** button.
5. Type the username of the user you want to assign to the group, and click on the **Assign user** button. For SaaS deployments, the username field refers to the email address of the user. For Self-Managed deployments, the username field has to match [the value of the claim configured as `username-claim`](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md#step-4-configure-the-oidc-connection-details).

:::note
For Self-Managed deployments with Basic authentication, you must search for existing users.
:::

The user is assigned to the group and inherits its permissions.

### Remove users from a group

To remove users from a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to remove users from.
3. Click on the **Users** tab.
4. Click on the **Remove** button next to the user you want to remove from the group.
5. Confirm the removal by clicking on the **Remove** button in the confirmation dialog.

The user is removed from the group and loses any permissions that were granted through the group.

## Manage roles

### Assign roles to a group

To assign roles to a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to assign roles to.
3. Click on the **Roles** tab.
4. Click on the **Assign role** button.
5. Search for the ID of the role you want to assign to the group, and click on the **Assign role** button.

The role is assigned to the group. Users in the group now have the permissions granted by that role.

### Remove roles from a group

To remove roles from a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to remove roles from.
3. Click on the **Roles** tab.
4. Click on the **Remove** button next to the role you want to remove from the group.
5. Confirm the removal by clicking on the **Remove** button in the confirmation dialog.

The role is removed from the group. Users in the group will lose the permissions that were granted through that role.

## Manage clients

:::note
In Self-Managed deployment, [client management](client.md) is only available for OIDC authentication.
:::

### Assign client to a group

To assign a client to a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to assign a client to.
3. Click on the **Clients** tab.
4. Click on the **Assign client** button.
5. Type the ID of the client you want to assign to the group, and click on the **Assign client** button.

The client is assigned to the group.

### Remove client from a group

To remove a client from a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to remove a client from.
3. Click on the **Clients** tab.
4. Click on the **Remove** button next to the client you want to remove from the group.
5. Confirm the removal by clicking on the **Remove** button in the confirmation dialog.

The client is removed from the group.

## Manage mapping rules

Self-Managed only

:::note
[Mapping rules](../concepts/access-control/mapping-rules.md) are only available for OIDC authentication.
:::

### Assign mapping rules to a group

To assign a mapping rule to a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to assign mapping rules to.
3. Click on the **Mapping rules** tab.
4. Click on the **Assign mapping rule** button.
5. Search for the ID of the mapping rule you want to assign to the group, and click on the **Assign mapping rule** button.

The mapping rule is assigned to the group.

### Remove mapping rules from a group

To remove a mapping rule from a group:

1. Log in to Admin in your cluster, and click on the **Groups** tab.
2. Click on the group you want to remove mapping rules from.
3. Click on the **Mapping rules** tab.
4. Click on the **Remove** button next to the mapping rule you want to remove from the group.
5. Confirm the removal by clicking on the **Remove** button in the confirmation dialog.

The mapping rule is removed from the group.

---

## Mapping rules

Self-Managed only

Mapping rules provide flexible access to Orchestration Cluster resources based on claims in a user's or client's OIDC access token.

:::info
To learn more, see [mapping rules](../concepts/access-control/mapping-rules.md).
:::

## Create a mapping rule

To create a mapping rule:

1. Log in to Admin in your cluster, and select the **Mapping Rules** tab.
2. Click **Create a mapping rule**, and enter the following details:
   - **Mapping Rule ID**: A unique identifier for the mapping rule.
   - **Mapping Rule name**: A user-friendly name.
   - **Claim name**: The name of a claim in the OIDC access token or a [JSONPath expression](https://www.rfc-editor.org/rfc/rfc9535) that points to a claim in the access token.
   - **Claim value**: The expected value of the claim so that the mapping rule matches an access token.
3. Click **Create mapping rule** to create the role.

You can now assign the role to groups, roles, or tenants, or create and apply authorizations for it.

## Update a mapping rule

To update a mapping rule:

1. Log in to Admin in your cluster, and select the **Mapping rules** tab.
2. Click the **pencil icon** next to the mapping rule you want to update.
3. Update the mapping rule details as required.
4. Click **Save** to update the mapping rule.

## Delete a mapping rule

To delete a mapping rule:

1. Log in to Admin in your cluster, and select the **Mapping Rules** tab.
2. Click **Delete** next to the mapping rule you want to delete.
3. Confirm the deletion by clicking on the **Delete** button in the confirmation dialog. The mapping rule is deleted.

## Assign authorizations to a role

See [authorizations](./authorization.md) to learn how to create authorizations for mapping rules.

---

## Roles

A role is a collection of [authorizations](authorization.md) that defines a set of permissions.

## About roles

Roles are used to grant users the system and data access required to fulfill a certain responsibility. A role can be assigned to [users](user.md) directly or as part of a [group](group.md) they belong to.

:::info
The Orchestration Cluster creates [a set of default roles](../concepts/access-control/authorizations.md#default-roles) on startup. If deleted, they're automatically recreated on cluster startup.
:::

## Create a role

To create a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click **Create role**, and enter the following role details:
   - **Role ID**: The unique identifier for the role.
   - **Role name**: The name of the role.
   - **Description**: An optional description of the role.
3. Click **Create role**.

The role is created and can now be assigned to users or groups.

## Update a role

To update a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click the **pencil icon** next to the role you want to update.
3. Update the role details:
   - **Name**: The name of the role.
   - **Description**: An optional description of the role.
4. Click the **Save** button.

The role details are updated.

:::note
Default roles that are automatically created are system entities and cannot be updated.
:::

## Delete a role

To delete a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click **Delete** next to the role you want to delete.
3. Confirm the deletion by clicking **Delete** in the confirmation dialog.

The role is deleted. The authorizations that were granted to the role are also removed.

:::note
Default roles that are automatically created are system entities and cannot be deleted.
:::

## Assign authorizations to a role

See [authorizations](./authorization.md) to learn how to create authorizations for roles.

## Manage users

### Assign users to a role

To assign users to a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to assign users to.
3. Select the **Users** tab.
4. Click **Assign user**.
5. Type the username of the user you want to assign to the role, and click **Assign user**. For SaaS deployments, the username field refers to the email address of the user. For Self-Managed deployments, the username field has to match [the value of the claim configured as `username-claim`](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md#step-4-configure-the-oidc-connection-details).

:::note
For Self-Managed deployments with Basic authentication, you must search for existing users.
:::

The user is assigned to the role and inherits its permissions.

### Remove users from a role

To remove users from a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to remove users from.
3. Select the **Users** tab.
4. Click **Remove** next to the user you want to remove from the role.
5. Confirm the removal by clicking **Remove** in the confirmation dialog.

The user is removed from the role and loses any permissions that were granted through it.

## Manage groups

### Assign groups to a role

To assign groups to a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to assign users to.
3. Select the **Groups** tab.
4. Click **Assign group**.
5. Type the ID of the group you want to assign to the role, and click **Assign group**.

The group is assigned to the role and inherits its permissions.

### Remove groups from a role

To remove groups from a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to remove groups from.
3. Select the **Groups** tab.
4. Click **Remove** next to the group you want to remove from the role.
5. Confirm the removal by clicking **Remove** in the confirmation dialog.

The group is removed from the role and loses any permissions that were granted through it.

## Manage clients

:::note
In a Self-Managed deployment, [client management](client.md) is only available for OIDC authentication.
:::

### Assign client to a role

To assign a client to a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to assign a client to.
3. Select the **Clients** tab.
4. Click **Assign client**.
5. Type the ID of the client you want to assign to the role, and click **Assign client**.

The client is assigned to the role.

### Remove client from a role

To remove a client from a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to remove a client from.
3. Select the **Clients** tab.
4. Click **Remove** next to the client you want to remove from the role.
5. Confirm the removal by clicking **Remove** in the confirmation dialog.

The client is removed from the role.

## Manage mapping rules

Self-Managed only

:::note
[Mapping rules](../concepts/access-control/mapping-rules.md) are only available for OIDC authentication.
:::

### Assign mapping rules to a role

To assign mapping rules to a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to assign mapping rules to.
3. Select the **Mapping rules** tab.
4. Click **Assign mapping rule**.
5. Search for the ID of the mapping rule you want to assign to the role, and click **Assign mapping rule**.

The mapping rule is assigned to the role.

### Remove mapping rules from a role

To remove a mapping rule from a role:

1. Log in to Admin in your cluster, and select the **Roles** tab.
2. Click on the role you want to remove mapping rules from.
3. Select the **Mapping rules** tab.
4. Click **Remove** next to the mapping rule you want to remove from the role.
5. Confirm the removal by clicking **Remove** in the confirmation dialog.

The mapping rule is removed from the role.

---

## Tenants

Use Admin to manage Orchestration Cluster tenants and isolate data within a single cluster. Tenant management is available on both Camunda 8 SaaS and Self-Managed.

:::note
On SaaS, the **Tenants** tab is visible to organization admins on clusters running generation 8.8 and later, even before multi-tenancy checks are enabled. This allows admins to set up tenants and assignments before enforcing checks. Before enabling checks, confirm your tenant assignments so users retain the access they need.
:::

## About tenants

A tenant is a logical boundary for data within a Camunda 8 installation.

This enables multiple teams, departments, or clients to share a single environment while keeping data isolated.

:::tip
To learn more about tenants, see [multi-tenancy](../concepts/multi-tenancy.md).
:::

You can manage your Orchestration Cluster tenants directly in [Admin](admin-introduction.md).

- **Multi-tenancy** is enabled by default.
- **Multi-tenancy checks** are disabled by default. All data maps to the `<default>` tenant.

This allows administrators to set up tenants and assignments before enforcing multi-tenancy checks.

How you enable multi-tenancy checks depends on your deployment model:

- **SaaS**: Enable the **Multi-tenancy** toggle per cluster in [Camunda Hub cluster settings](/components/hub/organization/manage-clusters/settings.md#multi-tenancy).
- **Self-Managed**: Configure multi-tenancy through [Orchestration Cluster configuration properties](/self-managed/components/orchestration-cluster/core-settings/configuration/properties.md#multi-tenancy).

:::warning
Before you enable multi-tenancy checks, assign all users, groups, and roles that need access to their tenants and to the `<default>` tenant. Once checks are enforced, any principal not assigned to a tenant loses access to the resources scoped to that tenant.
:::

## Create a tenant

:::note
The `<default>` tenant is automatically created when Admin starts.
:::

1. Log in to Admin and open the **Tenants** tab.

   ![tenant-management-tab](./img/tenant-management-tab.png)

2. Click **Create tenant**. In the modal, provide the tenant **ID**, **name**, and optional **description**. Then click **Create tenant**.

   ![tenant-management-create-tenant-modal](./img/tenant-management-create-tenant-modal.png)

3. The tenant appears in the list. If not, refresh the page.

   ![tenant-management-new-tenant-in-table](./img/tenant-management-new-tenant-in-table.png)

4. Click the tenant to open details and manage assignments.

   ![tenant-management-tenant-details-users-tab](./img/tenant-management-tenant-details-users-tab.png)

## Update a tenant

You can update the name and description of a tenant, but cannot change its ID after creation. To change a tenant's ID, you must delete the tenant and create a new one.

To update a tenant:

1. Log in to Admin in your cluster, and select the **Tenants** tab.
2. Click the **pencil icon** next to the tenant you want to update.
3. Update the tenant details:
   - **Name**: The name of the tenant.
   - **Description**: An optional description of the tenant.
4. Click the **Save** button.

The tenant details are updated.

:::note
The `<default>` tenant is a system entity and cannot be updated.
:::

## Delete a tenant

To delete a tenant, click on the **Delete** option in the list of tenants, and confirm the deletion.

:::note
The `<default>` tenant is a system entity and cannot be deleted.
:::

## Tenant assignments

You can assign the following entities to a tenant:

- [Users](user.md)
- [Groups](group.md)
- [Roles](role.md)
- [Mapping rules](mapping-rules.md)
- [Clients](client.md)

You can manage these assignments by selecting the relevant tab on the tenant details page.

### Assign users to a tenant

1. Select the **Users** tab.
2. Click **Assign user**. In the modal, enter the username and confirm. The username field has to match [the value of the claim configured as `username-claim`](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md#step-4-configure-the-oidc-connection-details).

   ![tenant-management-assign-users-modal](./img/tenant-management-assign-users-modal.png)

3. The user appears in the list after assignment. Refresh the page if needed.

   ![tenant-management-assigned-users](./img/tenant-management-assigned-users.png)

### Assign groups to a tenant

1. Select the **Groups** tab.
2. Click **Assign group**. Search for a group ID and confirm.

   ![tenant-management-assign-groups-modal](./img/tenant-management-assign-groups-modal.png)

3. The group appears in the list after assignment. Refresh the page if needed.

   ![tenant-management-assigned-groups](./img/tenant-management-assigned-groups.png)

### Assign roles to a tenant

1. Select the **Roles** tab.
2. Click **Assign role**. Search for a role ID and confirm.

   ![tenant-management-assign-roles-modal](./img/tenant-management-assign-roles-modal.png)

3. The role appears in the list after assignment. Refresh the page if needed.

   ![tenant-management-assigned-roles](./img/tenant-management-assigned-roles.png)

### Assign mapping rules to a tenant

:::note
Assignment of [mapping rules](../concepts/access-control/mapping-rules.md) is only available for [OIDC authentication in Self-Managed](../concepts/access-control/connect-to-identity-provider.md#self-managed). On SaaS, identity is managed by Camunda, so mapping rules cannot map claims from a customer identity provider.
:::

1. Select the **Mapping rules** tab.
2. Click **Assign mapping rule**. Search for a mapping rule ID and confirm.

   ![tenant-management-assign-mapping-rules-modal](./img/tenant-management-assign-mapping-rules-modal.png)

3. The mapping rule appears in the list after assignment. Refresh the page if needed.

   ![tenant-management-assigned-mapping-rules](./img/tenant-management-assigned-mapping-rules.png)

### Assign clients to a tenant

1. Select the **Clients** tab.
2. Click **Assign client**. Enter the client ID and confirm.

   ![tenant-management-assign-client-modal](./img/tenant-management-assign-client-modal.png)

3. The client appears in the list after assignment. Refresh the page if needed.

   ![tenant-management-assigned-clients](./img/tenant-management-assigned-clients.png)

---

## Users

Users are individuals who are granted with access to an orchestration cluster and it's components like Operate, Tasklist and REST API. User management differs depending on whether you are using Camunda 8 SaaS or a Self-Managed installation.

## SaaS

In a SaaS environment, user management is handled through [Camunda Hub](/components/hub/organization/manage-members/manage-users.md). From Camunda Hub, you can invite new users to your organization and manage their roles. For more advanced user management, you can configure [single sign-on (SSO)](/components/hub/organization/manage-organization-settings/external-sso.md) to integrate with your own identity provider.

## Self-Managed

For Self-Managed deployments, user management depends on your authentication setup:

- When using **Basic authentication**, users are managed through Admin. This involves creating, updating, and deleting them directly in your cluster.
- If you have configured an external [OpenID Connect (OIDC) provider](/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider.md), user management is handled by that provider.

The following sections describe how to manage users in a Self-Managed environment with **Basic authentication** enabled.

### Create a user

To create a user:

1. Log in to Admin in your cluster, and click on the **Users** tab.
2. Click on the **Create user** button, and provide the following user details:
   - **Username**: The username for the user.
   - **Name**: The name of the user.
   - **Email**: The email address of the user.
   - **Password**: The password for the user.
3. Click on the **Create user** button.

The user is created, and can now log in to the Camunda 8 web applications.

![identity-create-user-tab](./img/create-user-tab.png)

### Update a user

1. Log in to Admin in your cluster, and click on the **Users** tab.
2. Click on the **pencil icon** next to the user you want to update.
   :::note
   You can also select the user, and click the three vertical dots > **Update**.
   :::
3. Update the user details:
   - **Name**: The name of the user.
   - **Email**: The email address of the user.
   - **Password**: The password for the user.
4. Click on the **Save** button.

The user details are updated, and the user can now use these credentials to log in.

![identity-update-user-tab](./img/update-user-tab.png)

### Delete a user

1. Log in to Admin in your cluster, and click on the **Users** tab.
2. Click on the **Delete** button next to the user you want to delete.
   :::note
   You can also select the user, and click the three vertical dots > **Delete**.
   :::
3. Confirm the deletion by clicking on the **Delete** button in the confirmation dialog.

The user is deleted, and can no longer log in to the Camunda 8 web applications.

### Assign authorizations to a user

See the [authorization](./authorization.md) section to learn how to create authorizations for users.

---

## Benchmark Data

Regarding maintenance of the by_models.csv file (in static\data\by_models.csv) that feeds into the component from the LiveBenchModelFilter file (in components\react-components\livebench-model-filter.js).

# Benchmark Data

This repo contains benchmark CSVs for LLMs.  
They are exported manually (copy-pasted) from:

- [LiveBench](https://livebench.ai/#/)

You can use the script file (in static\data\script\Clean_and_Extend_getlivebench_data.ipynb) to fetch the artificial analysis data faster.

## How to update

1. Open livebench site.
2. Copy-paste or download the CSV as provided.
3. fetch the input and output prices from the official source.
4. compute the 3 to 1 blended, 1 being input price and 3 the output.
5. fetch speed numbers from official website or open source and compare it with the number in the csv to place it next to a comparable 0 to 10 (integer)
6. Replace the old file in this repo.
7. Commit the change.

## Format

- Keep exactly the same schema as exported.
- Do not rename, reorder, or edit columns.
- Leave missing values blank.
- Commit the **raw CSV only** (no edits, no formatting).

---

## Agentic orchestration

Orchestrate and integrate artificial intelligence (AI) agents into your end-to-end processes.

Camunda agentic orchestration allows you to orchestrate AI agents within your BPMN-based workflows, enabling human tasks, deterministic rule sets, and AI-driven decisions to collaborate in a robust, end-to-end process.

Agentic orchestration ensures your AI-driven processes are efficient, compliant, and aligned with business goals.

Build and use AI agents to execute the non-deterministic parts of a process, integrated with the proven foundation of BPMN.

## Get started

Get started with Camunda agentic orchestration by building and running your first AI agent.

Build your first AI agent

## Learn the fundamentals

Understand the fundamental concepts of Camunda agentic orchestration.

<AoGrid ao={fundamentalCards} columns={2}/>

## Explore further resources

Read about key capabilities and recommendations for using Camunda AI agents.

<AoGrid ao={recommendationCards} columns={2} />

---

## AI agents

Build and integrate AI agents into your end-to-end processes.

## About AI agents

An AI agent is an addressable execution of an LLM-driven loop with shared memory context across iterations. An agent runs a loop where the model decides what to do next, which tools to invoke, and when to stop. The loop is what makes it an agent. A standalone LLM call with no loop and no autonomous tool selection, such as a single connector call that returns output along a fixed execution path, is not an agent.

AI agents can perform a variety of functions, including making decisions, solving problems, interacting with external environments, and taking actions.

Camunda supports two types of agents:

- **[Camunda AI agents](/reference/glossary.md#camunda-ai-agent)** are native. Tool orchestration is executed by Camunda's engine, which activates each tool call as a governed BPMN activity, maintains memory across iterations, and emits lifecycle events.
- **[External agents](/reference/glossary.md#external-agent)** run their loop in an external runtime, such as, LangGraph, Amazon Bedrock, or custom code, instead of Camunda's engine.

The rest of this page describes how to build a Camunda AI agent using the AI Agent connector.

## The AI Agent connector

The AI Agent connector is the primary Camunda connector for building Camunda AI agents. It integrates an LLM with your BPMN process, enabling the agent to reason over context, select tools, and respond to users or process events.

Key capabilities include:

- **LLM provider support**: Connects to a range of providers, such as Anthropic, Amazon Bedrock, Google Gemini, and OpenAI.
- **Tool calling**: Exposes BPMN activities inside an [ad-hoc sub-process](/reference/glossary.md#ad-hoc-sub-process) as tools the LLM can select.
- **Memory**: Short-term conversational memory enables multi-turn interactions and follow-up questions within a process instance.

See the [AI Agent connector](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md) documentation for full configuration details, implementation examples, and reference.

### Integrate an AI agent into your process

The recommended approach for most use cases is to use the [AI Agent Sub-process](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-subprocess.md) implementation due to its simplified configuration and support for event sub-processes.

In this approach, you integrate the agent using an [ad-hoc sub-process](/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses.md) and the AI Agent connector in a tool feedback loop, where the agent understands the process goal and uses the available tools to complete it.

#### How the feedback loop works

The AI Agent connector operates in a feedback loop between the LLM and Camunda:

1. A user prompt is sent to the connector. The LLM evaluates the prompt, the system prompt, and the available tool definitions.
1. If the LLM determines that a tool call is needed, Camunda activates the corresponding BPMN activity in the ad-hoc sub-process.
1. The tool result is passed back to the LLM, which decides whether more tool calls are needed.
1. The loop continues until the LLM returns a final response, which can then be routed to the next step in the process.

Decision-making and execution are intentionally split:

- **LLM decides**: Which tool to call next, in what order, and with which parameters.
- **Camunda orchestrates**: Executes the selected BPMN activity, stores variables, applies retries and incident handling, and routes human tasks and events.

:::tip
Learn more in the [example AI Agent Sub-process connector integration](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-subprocess-example.md) and [guide to adding a tool for an AI agent](https://camunda.com/blog/2025/05/guide-to-adding-tool-ai-agent/).
:::

## AI agent integration features

Use the following Camunda 8 features to integrate AI agents into your processes:

    **Feature**
    **Description**

    [Ad-hoc sub-process](/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses.md)
    A special kind of embedded BPMN subprocess with an ad-hoc marker that allows a small part of your process decision-making to be handed over to a human or agent.

    [AI Agent connector](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md)
    Enables AI agents to integrate with an LLM to provide interaction/reasoning capabilities. This connector is designed for use with an ad-hoc sub-process in a feedback loop, providing automated user interaction and tool selection.

    [MCP Client connector](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-client.md)
    Connect an AI agent connector to tools exposed by [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) servers.

    [Ad-hoc tools schema resolver connector](/components/connectors/out-of-the-box-connectors/agentic-ai-ahsp-tools-schema-resolver.md)
    Can be used independently with other AI connectors for direct LLM interaction. Use this connector if you don't want to use the AI agent connector but still want to resolve tools for an ad-hoc sub-process or debug tool definitions.

    [Vector database connector](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md)
    Allows embedding, storing, and retrieving LLM embeddings. Use this connector to build AI-based solutions such as context document search, long-term memory for LLMs, and agentic AI interaction.

---

## Camunda-provided LLM

Run AI agents quickly in Camunda SaaS with Camunda-provided LLM.

## About

Camunda-provided LLM is a Camunda-managed LLM provider option that comes with automatically configured credentials. With it, you can run AI agents in your processes right away without additional setup.

Camunda-provided LLM is only available in Camunda 8 SaaS. It is not available in Camunda 8 Self-Managed.

:::info
Camunda-provided LLM is free to use within the provided budget, and is intended for testing and experimentation. When you're ready for production or need more control, switch to a customer-managed provider.
:::

Key benefits:

- **No LLM account setup required.** You don't need to sign up with a model provider or configure credentials to start exploring AI agents.
- **Compare different LLM providers.** Run your agent with different models and easily switch between them to find the best fit for your use case.
- **No surprise bills.** Your organization gets a free, preconfigured budget for testing and experimentation.
- **Instant blueprints.** AI agent blueprints that use Camunda-provided LLM work out of the box with no configuration needed.
- **Seamless transition.** When you're ready for production, switch to a customer-managed provider like AWS Bedrock without changing your process architecture.

Camunda-provided LLM is available in Camunda SaaS for:

- **SaaS trial organizations**: Includes Camunda-managed credentials and a free budget. AI features are enabled by default.
- **SaaS enterprise organizations**: Includes a larger budget to support multiple proofs of concept. You must explicitly enable AI features in Camunda Console. When you enable them, Camunda-provided LLM is enabled automatically. If Camunda-provided LLM is unavailable, disable AI features and then re-enable them.

:::note
Availability, budgets, and UI may vary by environment and rollout stage.
:::

See [Trial vs. enterprise budgets](#trial-vs-enterprise-budgets) for more details.

## Set up Camunda-provided LLM

Once Camunda-provided LLM is available in your organization, its credentials are populated automatically as cluster secrets.

- If you are using an AI agent blueprint, no additional configuration is needed in most cases. Explore selected AI agent blueprints in the [Camunda Marketplace](https://marketplace.camunda.com/en-US/home).
- If you are building your own agent from scratch, enable Camunda-provided LLM by configuring your [AI Agent connector](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md) with the following parameters:
  - **Provider**: `OpenAI Compatible`.
  - **API endpoint**: `{{secrets.CAMUNDA_PROVIDED_LLM_API_ENDPOINT}}`.
  - **API key**: `{{secrets.CAMUNDA_PROVIDED_LLM_API_KEY}}`.
  - **Model**: Select a model from the [list of supported models](#supported-models). For example `amazon.nova-pro-v1`.

## Supported models

Camunda-provided LLM uses a managed LLM gateway that supports multiple models from different providers. You can switch between models to compare how your agent performs with each one. When using the AI Agent connector, set the **Model** field to one of the following values:

| Model                       | Value to set in **Model**     | What it's good for                                                                                                                |
| :-------------------------- | :---------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
| Amazon Nova Pro v1          | `amazon.nova-pro-v1`          | Best for balanced quality and cost across general-purpose AI agent scenarios.                                                     |
| Anthropic Claude Haiku 4.5  | `anthropic.claude-haiku-4-5`  | Best for lightweight assistants, short interactions, and lower-cost tasks that still need good instruction following.             |
| Anthropic Claude Opus 4.5   | `anthropic.claude-opus-4-5`   | Best for advanced analysis and challenging multi-step tasks where maximum quality is the priority.                                |
| Anthropic Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` | Best as the default for complex agent tasks, balancing strong reasoning, reliable tool use, speed, and budget consumption.        |
| Anthropic Claude Sonnet 5   | `anthropic.claude-sonnet-5`   | Best for demanding agent tasks when you want stronger reasoning and tool use than the default and can trade off speed and budget. |
| DeepSeek v3.2               | `deepseek.v3.2`               | Best for technical and coding-heavy workflows that need strong reasoning at moderate cost.                                        |
| OpenAI GPT-OSS 120B         | `openai.gpt-oss-120b`         | Best for higher-quality results than small open models while still controlling cost.                                              |
| OpenAI GPT-OSS 20B          | `openai.gpt-oss-20b`          | Best for budget-conscious experimentation and simpler automations with lower complexity.                                          |
| Qwen Qwen3 235B             | `qwen.qwen3-235b`             | Best for advanced reasoning and coding use cases where you want strong performance with good cost efficiency.                     |

:::note
When selecting a model, consider your process requirements, expected usage volume, and token budget. For model selection guidelines, see how to [choose the right LLM](./choose-right-model-agentic.md).
:::

## Trial vs. enterprise budgets

The budgets, measured in **dollars (USD) spent**, differ depending on your SaaS plan:

- **Trial**: A smaller budget intended for quick evaluation and early experiments by individuals and small teams.
- **Enterprise**: A larger budget intended for broader team experimentation and proofs of concept.

:::important
Budgets are topped up automatically and enforced at the organization level (not per user). This means multiple users in the same organization draw from the same budget.
:::

### What the budget cover

The Camunda-provided LLM budget covers LLM provider calls during AI agent execution:

- **Trial budget**: Allows for a hundred to a few thousand agent runs, depending on the model used and the agent complexity.
- **Enterprise budget**: Is significantly larger to support more extensive experimentation.

Other Camunda AI features, such as Camunda Copilot, do not consume your Camunda-provided LLM budget and can be used independently.

:::note
The total cost of an agent run depends on how many LLM calls it makes, which can vary based on the agent’s design and task complexity. Cost also depends on the model used, since different models have different per-token pricing.
:::

### When budget is exhausted

When your organization reaches its Camunda-provided LLM budget cap:

- Additional LLM calls are **blocked**.
- Your process execution may fail with an “out of budget” error, such as `COST_LIMIT_EXCEEDED`, depending on how your process handles errors.

:::tip
If your process model doesn’t handle LLM failures, an exhausted budget may result in incidents or failed instances. Consider adding BPMN error handling to provide a user-friendly fallback path.
:::

## Monitor usage

The Camunda-provided LLM budget is shared across your organization, so you should monitor consumption. Camunda Console shows usage statistics for Camunda-provided LLM, including:

- How much of your budget has been used.
- How much budget remains.

Use this data to plan your transition to a customer-managed provider when you're ready for production.

## Switch away from Camunda-provided LLM

As you move from evaluation to production, you may want to switch to your own LLM provider. This gives you:

- Direct control over provider choice.
- Your own billing and quota management.
- The ability to scale beyond the Camunda-provided LLM budget caps.

:::important Before you begin

- Ensure your organization has access to the LLM provider you plan to use.
- Gather credentials and any required configuration.
- Identify where your current AI agent models rely on Camunda-provided LLM defaults.
  :::

To switch away, follow these steps:

1. Add your LLM provider credentials in the appropriate Camunda location for managing secrets and credentials.
2. Update your AI Agent connector configuration to use the new LLM provider.
3. Re-deploy your process.
4. Test a process instance end-to-end and verify results.

Your orchestration model doesn’t change during this transition. The BPMN process, event choreography, and human touchpoints you designed with Camunda-provided LLM carry forward unchanged, while only the LLM backend configuration shifts.

---

## Choose the right LLM

Choose the right Large Language Model (LLM) to ensure your AI agent reliably executes tasks in a Camunda process.

This guide helps you evaluate and select the best LLMs based on your deployment requirements and business needs. It explains how to measure agent performance and shows how to leverage LiveBench’s standardized benchmarks to compare models effectively.

## Define your LLM needs

Consider the following aspects regarding your model requirements and setup constraints:

| Consideration             | Description                                                                                                                                                          |
| :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Hosting**               | Cloud-only vs. on-premises deployment. For compliance-heavy or air-gapped environments, self-hostable open-source models are preferred.                              |
| **Data sensitivity**      | Workflows handling Personally Identifiable Information (PII) or confidential data may require private deployments or self-hosting to meet data control requirements. |
| **Cost vs. speed**        | Larger models offer higher accuracy but often with higher latency and cost. Balance performance against Service Level Agreements (SLAs) and budgets.                 |
| **Accuracy vs. openness** | Proprietary models often lead in benchmark accuracy. Open-source models provide flexibility, fine-tuning, and offline use cases.                                     |

## Measure agent performance

The ideal model should handle tools effectively, follow instructions consistently, and complete actions successfully.

When evaluating models for your agentic process, focus on these three core capabilities:

- **Tool usage:** How accurately does the model choose and use the right tools? Poor tool usage leads to failed tasks or wasted steps.
- **Action completion:** Does the agent fully achieve the goals of each task without manual intervention?
- **Instruction adherence:** Does the model follow your prompts, policies, and constraints as expected?

:::tip
To validate these capabilities against your own agent process, [test your AI agents with Camunda Process Test (CPT)](./evaluate-agents/test-ai-agents.md).
:::

## Benchmark your candidate models

Once you have defined your model needs, setup requirements, and peformance metrics, standardized benchmarks help you measure these aspects objectively.
They use the same tasks and conditions for every model, enabling fair comparisons.

### Learn about LiveBench metrics

One such benchmark is ​​[LiveBench](https://arxiv.org/abs/2406.19314), that evaluates LLMs across multiple skill areas.
It avoids common pitfalls such as test data contamination or subjective scoring by using fresh tasks and objective ground-truth answers.

Each LiveBench metric represents a core capability:

| Metric                             | What it measures                                         | When it matters                                   |
| :--------------------------------- | :------------------------------------------------------- | :------------------------------------------------ |
| **Reasoning**                      | Logical thinking and stepwise problem-solving.           | Strategic planning, multi-step workflows.         |
| **Math**                           | Numerical accuracy and quantitative reasoning.           | Finance, analytics, reporting.                    |
| **Coding**                         | Code generation and debugging.                           | Dev tools, automation scripts.                    |
| **Data analysis**                  | Extracting insights from datasets, tables, or documents. | Research, reporting, content analysis.            |
| **Instruction following**          | Compliance with formats, rules, and prompts.             | Policy-driven workflows, SOP tasks.               |
| **Software engineering (agentic)** | Tool-assisted coding and autonomous dev work.            | CI/CD, issue triage, automated PRs.               |
| **Language**                       | Context understanding, fluency, general knowledge.       | Chatbots, documentation, natural language output. |

Different models excel in different areas.
For instance, a model might rank highly in reasoning but score average on coding tasks.
Matching model strengths to your workflow requirements ensures better outcomes.

### Compare models with LiveBench

Use the interactive tool below to generate a LiveBench benchmark comparison.
It outputs a pre-filtered table based on your selected criteria.

<LiveBenchModelFilter/>

:::note

- LiveBench benchmarks are used under a Creative Commons license.
- [LiveBench rankings](https://livebench.ai/#/) update continuously. The table above shows the most recent evaluation results.
- This tool is provided for illustration purposes only to help you choose the right LLM for your agentic processes.
  :::

## Key takeaways

Your model choice should align with:

1. **Practical constraints** like hosting, privacy, cost, and accuracy needs.
1. **Performance metrics** such as tool usage, action completion, and instruction adherence.
1. **LiveBench scores** for skills relevant to your workflow.

:::important  
Model selection should always reflect your **use case**. For example, a math-heavy workflow may weight numerical accuracy higher, while a customer support bot might prioritize language skills and instruction-following.  
:::

A clear framework and benchmarked data helps you choose an LLM or foundation model to power your Camunda agent.

### Explore models with Camunda-provided LLM

Camunda-provided LLM gives you access to [multiple models](./camunda-provided-llm.md#supported-models) for experimentation and evaluation, so you can test different options without setting up your own provider.

:::important
Camunda-provided LLM is only available in Camunda 8 SaaS. It is not available in Camunda 8 Self-Managed.
:::

See [Camunda-provided LLM](./camunda-provided-llm.md) for more details.

## Next steps

Selecting and benchmarking a model is only the first step. Once your agent is running, validate and continuously evaluate its behavior in practice:

- [Evaluate your AI agents](./evaluate-agents/evaluate-agents-overview.md): Monitor agents in real time with Operate and improve their performance over time with Optimize.
- [Test with CPT](./evaluate-agents/test-ai-agents.md): Write integration tests that assert on tool usage, action completion, and agent output.

---

## Design and architecture

Plan and design your agentic orchestration solutions, and understand recommended architecture guidelines.

## Plan agentic orchestration solutions

Follow these principles when planning your agentic orchestration solution:

- **Problem first**: First, identify any problem you might have in a process, and only then determine whether an AI agent could help solve the problem. Do not use an AI agent where it is not really necessary, or just for the sake of it.
- **Architect for composability**. Avoid becoming too dependant on a specific LLM model, for example by doing too much fine tuning. This allows you to more easily integrate newer LLM providers and models in the future that better suit your needs.
- **Observability and governance**: Use [Operate](/components/operate/operate-introduction.md) and [Optimize](/components/optimize/what-is-optimize.md) for visibility into your agentic orchestration processes.

### Blend deterministic and dynamic orchestration

Blending both deterministic and dynamic (AI-driven) process orchestration into your end-to-end processes allows you to take advantage of non-deterministic process orchestration without sacrificing predictability, customer experience, and compliance.

For example, you could use an AI agent to enhance a Know Your Customer (KYC) process, where the AI agent:

- Provides dynamic guidance and problem-solving to the person throughout the process.
- Monitors for policy changes and dynamically changes the process execution in response.
- Automatically adjusts risk level and takes action such as restricting account activity or dynamically adjusting spend limits.

### When to use deterministic or non-deterministic orchestration

Agentic orchestration involves blending both deterministic and dynamic (AI-driven) process orchestration into your end-to-end processes. It is important to understand when to use each approach:

| &nbsp;           | Deterministic                                                                                                                                                                                                | Dynamic                                                                                                                                                                                                                                |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Suitable for** | Clear, predictable paths.Repeatable, rules-based decisions.Fast, efficient execution.Regulation dictates execution sequence. | Flexible, context-aware choices.AI-driven task planning.Unstructured cases: classification, triage, or investigation.Adaptable to data and conditions. |
| **Enabled by**   | Advanced workflow patterns.Business/IT alignment on process and decision logic.                                                                              | Dynamic task scheduling and tracking.Collaboration between AI and Human.                                                                                                               |

:::info
To learn more about determining when and where to use AI agents within your automation strategy, download the [why agentic process orchestration belongs in your automation](https://page.camunda.com/wp-why-agentic-process-orchestration-belongs-in-your-automation-strategy) strategy guide.
:::

## Design agent orchestration workflows

Follow these principles when designing your agentic orchestration solution:

- **Guardrail sandwich**: Apply guardrails in your process when using agents. For example, you could have one agent performing the task execution, with another agent following up to check the chain of thought and make sure every execution is compliant. If the execution is not compliant, route to a human for additional validation.
- **Human-in-the-Loop escalation**: Provide an agent with an escalation path to a human - confidence levels are useful, but it is good to always provide deterministic outbreaks for agents.
- **Prompt versioning**: Version every prompt, so you can revert to using a previous prompt when required.

### How execution works in an AI agent

In Camunda agentic orchestration, decision-making and orchestration are intentionally split:

- **LLM responsibility**: Interprets the system prompt, current user prompt, and available tool descriptions. It decides which tool to call, in what order, and with which parameters.
- **Camunda responsibility**: Executes the selected BPMN activities, stores process state, applies retries and incident handling, and coordinates user tasks and other deterministic workflow logic.

Think of the ad-hoc sub-process as a governed toolbox:

- Each activity can be selected by the LLM as a tool.
- Activities can be executed multiple times, in different orders, in parallel, or skipped.
- The LLM chooses a path from the allowed options, while Camunda enforces process boundaries and execution reliability.

This is a typical execution timeline:

1. A user submits a prompt.
1. The LLM evaluates the prompt together with the configured system prompt and available tool definitions.
1. The LLM chooses one or more tool calls.
1. Camunda activates and executes the corresponding BPMN activities.
1. Results are written to process variables and returned to the LLM context.
1. The loop repeats until the LLM returns a final response or the process routes to deterministic follow-up steps.

### Define your agent tools

In the AI agent model, each BPMN activity inside an ad-hoc sub-process is a tool exposed to the LLM. The activity name and its documentation are used by the LLM to decide what to do next.

Clear, behavior-oriented descriptions help the LLM:

- Select the right tool for the current goal.
- Pass the right parameters in the expected format.
- Avoid unsafe, redundant, or nonsensical actions.

Poor or missing documentation increases the risk of:

- Incorrect or ambiguous tool selection.
- Repeated tool calls or skipped required steps.
- Hallucinated behavior and responses that do not match process intent.

#### Example: weak vs strong tool definition

| Tool definition | Example                                                                                                                                                                                                                                           |
| :-------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Weak            | **Name**: `Lookup`**Documentation**: `Find customer data`                                                                                                                                                                                    |
| Strong          | **Name**: `Resolve customer by legal company name`**Documentation**: `Use this tool when a document mentions a company and you need its internal customer ID. If multiple matches are returned, request human validation before continuing.` |

A clear tool name and precise documentation make the expected behavior explicit, improving reliability during tool selection and execution.

#### Tool parameters

Each tool can also declare input parameters the LLM must supply at runtime. Use the [`fromAi()`](../modeler/feel/builtin-functions/feel-built-in-functions-ai-agent.md#fromaivalue) [AI agent function](/reference/glossary.md#ai-agent-function) in input mappings to mark a value as LLM-provided, with an optional description and type to guide the model.

See [tool definitions](../connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions.md) for more details.

### Mix agents with workflow patterns

    1
    **Process flow within tools**: Full BPMN control inside ad-hoc sub-processes for ultimate flexibility.

    2
    **Agents pivot instantly with external messages and timers**: During execution, agents can be influenced by events like external messages or timers, enabling on-the-fly adjustments.

    3
    **Event-driven agent reconfiguration**: Sub-workflows handle new data, guiding the next AI steps.

    4
    **Agents orchestrate sub-workflow**: A tool doesn't need to be a single tool - it can be a whole subprocess.

    5
    **Multi-agent orchestration**: Agents orchestrate other agents for streamlined, scalable solutions. This agent-to-agent pattern runs inside Camunda's [agentic orchestration](/components/agentic-orchestration/agentic-orchestration-overview.md), as one of the tools available to an agent. It is not the same as agentic orchestration itself, which is Camunda's overall model for orchestrating agents, people, and systems.

### Call processes as agent tools

When an AI agent needs to invoke another BPMN process as a tool, you have two options:

- Use a call activity inside the ad-hoc sub-process.
- Add an MCP client gateway tool connected to the [Processes MCP Server](/apis-tools/processes-mcp/processes-mcp-overview.md).

The right choice depends on whether your target process runs on the same or a different Orchestration Cluster:

| Scenario                                                   | Recommended approach                                                                                                                                                            |
| :--------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Target process is on the **same** Orchestration Cluster    | Use a [call activity](/components/modeler/bpmn/call-activities/call-activities.md) inside the ad-hoc sub-process.                                                               |
| Target process is on a **different** Orchestration Cluster | Use the [MCP Remote Client connector](../connectors/out-of-the-box-connectors/agentic-ai-mcp-remote-client-connector.md) connected to the other cluster's Processes MCP Server. |

These two approaches differ in runtime behavior, the result the agent receives, instance visibility, and the audit trail:

| &nbsp;                 | Call activity                                                                                                      | MCP client                                                                                                                          |
| :--------------------- | :----------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------- |
| **Execution**          | The tool call waits for the called process to complete and returns its output to the agent.                        | The called process starts immediately and the tool returns the process instance key. The agent does not receive the process output. |
| **Instance hierarchy** | The called process instance is a child of the ad-hoc sub-process element, visible in the instance tree in Operate. | The called process runs independently with no structural link to the calling agent process.                                         |
| **Audit logs**         | The audit trail reflects the full call hierarchy.                                                                  | The audit trail shows a process triggered by an external message, with no structural link to the calling agent.                     |

:::note
Although it is technically possible to use an MCP client to connect to the Processes MCP Server on the same cluster as the calling agent, this produces a detached hierarchy and a less coherent audit trail. Use call activities for same-cluster process invocations.
:::

---

## Analyze your AI agents with Optimize

Analyze and improve the performance of your AI agent executions using Optimize.

## About

In this guide, you will:

- Understand what data Optimize can analyze for AI agents.
- Create reports and heatmaps, including token and tool usage.
- Build a dashboard to track AI agent behavior over time.

After completing this guide, you will be able to analyze AI agent executions in Optimize and build dashboards that track usage and performance trends.

:::important Agentic control plane in Optimize
The [agentic control plane](/components/optimize/userguide/agentic-control-plane.md) already provides standard metrics for AI-agent-powered processes without additional setup. Use this guide to learn how to create custom metrics, thresholds, breakdowns, or reports grouped by process variables.
:::

## Prerequisites

- You have access to [Optimize](/components/optimize/what-is-optimize.md).
- You have deployed and run the [AI Agent Chat Quick Start](https://marketplace.camunda.com/en-US/apps/587865) model blueprint. This is needed for Optimize to fetch execution data to analyze. Consider running it using different prompts to trigger various AI agent tools.

:::important
This guide is a follow-up to [build your first AI agent](/guides/getting-started-agentic-orchestration.md), in which you use the same example AI agent process. We recommend completing that guide first. However, you can also apply this guide to other AI agent process implementations.
:::

## Step 1: Make your data available

Optimize's report builder can only aggregate over process variables, so any custom report you build yourself needs its data available as one. To make data available to Optimize, make sure it's scoped at the process level. If it's scoped to a lower level, for example, within a connector or tool-execution scope, extract it into process variables.

:::important
Optimize can only use variable data at the **process level**.
:::

### Example: Collect token usage

In the AI Agent Chat Quick Start example, token usage data is not available at the process level, but in a nested scope.
How you extract it depends on your AI agent implementation. The important aspect is that the target variables exist at the **process level** when the instance finishes.

:::note
Getting the token usage from the agent context only works with the AI Agent Sub-process when the **Include agent context** option in the **Response** section is enabled.
:::

To surface this data, you can add a script task after the AI agent execution that copies the values into process variables as follows:

1. Add a [script task](/components/modeler/bpmn/script-tasks/script-tasks.md).
1. Configure its **Properties**:
   - Set **Name** to `Gather metrics` under the **General** section.
   - Select **FEEL expression** as **Implementation**.
   - Under **Script**:
     - Set **Result variable** to `tokenUsage`.
     - Set **FEEL expression** to `agent.context.metrics.tokenUsage`.
   - Under **Output mapping**, add two process variables:
     - `inputTokenUsage` with **Variable assignment value**: `agent.context.metrics.tokenUsage.inputTokenCount`.
     - `outputTokenUsage` with **Variable assignment value**: `agent.context.metrics.tokenUsage.outputTokenCount`.

You should see something similar to the following:

## Step 2: Examine data in Optimize

You can use Optimize reports and dashboards to examine data collected during process execution and identify areas for improvement in your AI agent processes.

1. Open Optimize.
1. Go to the **Dashboards** tab.
1. Select your AI agent process, **AI Agent Chat With Tools**, in the **Process dashboards and KPIs** section.
1. Verify that Optimize shows data for your executed process instances in the **Business Operations** section, including your AI agent process model diagram and other statistics below.
1. Explore the other metrics shown below in the **Business Reporting** and **Process Improvement** sections.

See [getting started](/components/optimize/improve-processes-with-optimize.md) with Optimize for more details on using Optimize for business intelligence.

## Step 3: Create reports for token usage

You can create reports for token usage across process instances and over time.

1. Go to the **Collections** tab.
1. Select **Report** from the **Create new** dropdown.
1. Select **AI Agent Chat With Tools** from the **Select one or more processes** dropdown. You can fetch data for all process model versions or customize it.
1. Choose a blank template.
1. Enable **Update preview automatically** to make it easier to see the report results as you configure it.
1. In the **Report setup** section, select **Variable** in the **View** option, and then select **tokenUsage**.
1. Click the pencil icon and select an aggregation that matches your goal. For example:
   - **Sum** to track total tokens across instances.
   - **Average** to track typical usage per process instance.
1. Save the report with a descriptive name. For example, **Token usage**.

:::note
You can create similar reports, targeting other goals and process variables, such as `inputTokenUsage` or `outputTokenUsage`.
:::

### Example: Set a target threshold

If you have a token budget, you can set a target in the report.

1. Complete steps 1–6 in [Step 3: Create reports for token usage](#step-3-create-reports-for-token-usage).
1. In the **Visualization** settings, click the gear icon and enable **Set target** to configure a target value. For example, a maximum token usage threshold.
1. Set the target threshold to match your budget. For example, select the **below** option and set it to 10,000 tokens.
1. Save the report with a descriptive name. For example, **Token usage with threshold**.

## Step 4: Create reports for tool usage

You can create reports for tool usage across process instances and over time.

### Example: Create a heatmap

Use a heatmap to understand how long your AI agent spends in each task.

1. Go to the **Collections** tab.
1. Select **Report** from the **Create new** dropdown.
1. Select **Flow node** as the **View**.
1. Select **Duration** as the **Measure**.
1. (Optional) Filter the report by selecting **Flow node selection** in the **Filter flow nodes** dropdown. For example, select only tool tasks within the AI Agent connector.
1. In the **Visualization** settings, select **Heatmap**. Click the gear icon and enable the tooltip to show absolute values.
1. Save the report with a descriptive name. For example, **Tool usage heatmap**.

You can see from the heatmap that the **Search recipe**, **Jokes API**, and **Get list of Tech Stuff** tools are the only ones that were called across all process executions, and that your AI agent spent the most time in **Get list of Tech Stuff**.

### Example: Create a report for tool call counts

Create a bar chart to see how many times each tool is called.

1. Go to the **Collections** tab.
1. Select **Report** from the **Create new** dropdown.
1. Select **Flow node** as **View**.
1. Select **Count** as the **Measure**.
1. (Optional) Filter the report by selecting **Flow node selection** in the **Filter flow nodes** dropdown. For example, select only tool tasks within the AI Agent connector.
1. In the **Visualization** settings, select **Bar chart** or **Pie chart**. Then click the gear icon and enable both tooltips to show absolute and relative values.
1. Save the report with a descriptive name. For example, **Tool usage**.

You can see from the pie chart that the AI agent called the Jokes API tool most often across all process executions.

### Example: Track trends over time

Use a timeline report to analyze trends over time. For example, you can see how many times a tool is called per day over a one-week period.

1. Go to the **Collections** tab.
1. Select **Report** from the **Create new** dropdown.
1. Select **Flow node** as **View**.
1. Select **Count** as the **Measure**.
1. In **Group by**, select **Start date**. Then choose your preferred interval, for example, **Week**.
1. (Optional) Filter the report by selecting **Flow node selection** in the **Filter flow nodes** dropdown. For example, select only tool tasks within the AI Agent connector.
1. In the **Visualization** settings, select **Bar chart** or **Line chart**. Then click the gear icon and enable both tooltips to show absolute and relative values.
1. Save the report with a descriptive name. For example, **Tool usage over time**.

## Step 5: Build a dashboard

You can create a dashboard, which is a collection of reports that you can view together, for your AI agent process.

1. Go to the **Collections** tab.
1. Select **Dashboard** from the **Create new** dropdown.
1. Click the plus icon to add tiles for the reports you created.
1. In the **Optimize report** section, add reports as needed.
1. Arrange the tiles to customize your dashboard layout.
1. Save the dashboard with a descriptive name. For example, **AI Agent Chat Quick Start dashboard**.

## Next steps

Now that you know how to analyze your AI agents, you can:

- [Monitor your AI agents](./monitor-ai-agents.md) with Operate.
- Learn more about [Camunda agentic orchestration](/components/agentic-orchestration/agentic-orchestration-overview.md) and the [AI Agent connector](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md).

---

## Evaluate AI agents

Evaluate your AI agents by monitoring them in real time with Operate, improving performance over time with Optimize, and testing them with Camunda Process Test.

<AoGrid ao={fundamentalCards_monitoring} columns={3}/>

---

## Monitor your AI agents with Operate

Monitor and troubleshoot your AI agent process instances in real time using Operate.

## About

In this guide, you will:

- Inspect an AI agent process instance in Operate.
- Understand the agent's tool usage and metadata, such as tool call inputs and results.
- Analyze the agent context and how it is stored.

:::note
Operate enables inspection of execution paths, tool usage, and agent metadata. However, certain runtime artifacts, such as document storage contents, may require additional configuration.
:::

After completing this guide, you will be able to inspect, debug, and monitor AI agent executions in Camunda 8.

## Prerequisites

- You have access to [Operate](/components/operate/operate-introduction.md).
- You have the [AI Agent Chat Quick Start](https://marketplace.camunda.com/en-US/apps/587865) model blueprint deployed in [Modeler](/components/modeler/about-modeler.md).

:::important
This guide is a follow-up to [build your first AI agent](/guides/getting-started-agentic-orchestration.md), where you use the same example AI agent process. We recommend completing that guide first. However, you can also apply this guide to other AI agent process implementations.
:::

## Step 1: Run your AI agent process

Run your process instance using a prompt to trigger the AI Agent connector.
For example:

1. Enter "Tell me a joke" in the **How can I help you today?** field.
1. Click **Start instance**.

## Step 2: Open the process instance in Operate

1. Open [Operate](/components/operate/operate-introduction.md).
2. Locate the process instance created by your prompt. See [view a deployed process](/components/operate/userguide/basic-operate-navigation.md#view-a-deployed-process) for more details.
3. Open your process instance view by clicking on its process instance key.

At this point, you should see the process progressing through your model:

## Step 3: Understand what Operate shows

With Operate, you can track the agent activity and see which tool tasks are called.

1. To show how many times each BPMN element is triggered, select **Execution count** in the **Instance History** section. For this particular prompt example, you can see:
   - The AI Agent connector was triggered once.
   - Within it, the agent executed the **Jokes API** tool.

2. Select the **Jokes API** tool element:
   - In the bottom-left pane, you can see where the element belongs in the execution tree:
     

- In the bottom-right pane, the element details are displayed, including the [**Variables**](/components/concepts/variables.md) and [**Input/Output Mappings**](/components/concepts/variables.md#inputoutput-variable-mappings) columns, among others.
  However, the actual tool inputs and results are stored in a **parent scope** and are accessible via the element's inner instance in the execution tree. See [Step 4: Inspect tool calls](#step-4-inspect-tool-calls) for more details.

## Step 4: Inspect tool calls

Each tool execution produces an inner instance where you can find:

- The inputs passed into the tool.
- The results.

To see the **Jokes API** tool input and results:

1. In the execution tree, select the **AI_Agent#innerInstance** parent element of the **Jokes API** tool. You will see:
   - The `toolCall` variable (the _input_).
   - The `toolCallResult` variable (the _results_). See [Tool call responses](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions.md#tool-call-responses) for more details.

  

2. To better inspect the results, click the pencil icon to enter edit mode for `toolCallResult`.
3. Click the two-arrow icon to open the JSON editor modal. With this, you can inspect the full payload of the variable value:

```json
{
  "Java and C were telling jokes. It was C's turn, so he writes something on the wall, points to it and says \"Do you get the reference?\" But Java didn't."
}
```

:::note
If a tool is executed more than once, select the desired tool invocation in **Instance History**, then open the corresponding inner instance to view the actual inputs and results.
:::

## Step 5: Analyze the agent context

Within the AI Agent connector, you can examine the agent context.
To view it:

1. Select the **AI Agent** element in the execution tree.
2. To better inspect the value, click the pencil icon to enter edit mode for the `agentContext` variable.
3. Click the two-arrow icon to open the JSON editor modal. With this, you can inspect the full payload of the variable value.

In the JSON payload, you can find information about:

- Defined tools.
- The conversation, including your prompts and agent's replies.
- Tool calls invoked by the agent.
- Tool call inputs and results.
- Additional metadata, such as reasoning traces and token usage.

Here’s a snippet of the example conversation stored in the agent’s context:

```json
"type": "in-process",
"conversationId": "3889288d-5904-485f-bdca-48ad1f1ef679",
"messages": [
  {
    "role": "system",
    "content": [
      {
        "type": "text",
        "text": "You are a helpful, generic chat agent which can answer a wide amount of questions based on your knowledge and an optional set of available tools.\n\nIf tools are provided, you should prefer them instead of guessing an answer. You can call the same tool multiple times by providing different input values. Don't guess any tools which were not explicitely configured. If no tool matches the request, try to generate an answer. If you're not able to find a good answer, return with a message stating why you're not able to.\n\nIf you are prompted to interact with a person, never guess contact details, but use available user/person lookup tools instead and return with an error if you're not able to look up appropriate data.\n\nThinking, step by step, before you execute your tools, you think using the template `<thinking><context></context><reflection></reflection></thinking>`"
      }
    ]
  },
  {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "Tell me a joke"
      }
    ],
    "metadata": {
      "timestamp": "2026-04-06T09:53:19.224987296Z"
    }
  },
  {
    "role": "assistant",
    "content": [
      {
        "type": "text",
        "text": "<thinking>\n<context>\nThe user is asking for a joke. I have access to a Jokes_API function that can fetch a random joke from a REST API. This seems like the perfect tool to use for this request. The function doesn't require any parameters, so I can call it directly.\n</context>\n<reflection>\nThis is a straightforward request that matches exactly with one of my available tools. I should use the Jokes_API function to get a random joke for the user.\n</reflection>\n</thinking>"
      }
    ],
    "toolCalls": [
      {
        "id": "tooluse_x83f1Vaj62lgkT9PMo6oqB",
        "name": "Jokes_API",
        "arguments": {}
      }
    ],
```

## Step 6: Understand how agent memory is stored

In Modeler, within the AI Agent sub-process, you can define how the conversation memory is stored using the **Memory storage type** field.

By default, agent memory uses the **In Process** type, which stores it as part of the agent context.
With this option, you can view it in Operate within the agent context, as you did in the previous step, [Analyze the agent context](#step-5-analyze-the-agent-context).

With the **Camunda Document Storage** option instead:

- You can't view the full conversation and chain-of-thought traces in Operate. Operate only shows a **document reference** and metadata.
- Use this option for long conversations, where Operate variable limits might be exceeded.

See [memory](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-subprocess.md#memory) for more details.

:::note Agent memory storage

- Use **In Process** for testing and debugging scenarios: Better visibility in Operate.
- Use **Camunda Document Storage** for production scenarios: Better scalability and runtime behavior for long contexts.

:::

## Step 7: Review the results

Go back to Operate. In the **User Feedback** element, you will see the execution count in green. This means the process instance execution is stopped there and waiting for action.

In this case, the required action is to provide feedback on the agent results. To do so:

1. Select the **User Feedback** element.
2. Open [Tasklist](/components/tasklist/introduction-to-tasklist.md).
3. Select the user feedback task and assign to yourself by clicking **Assign to me**.
4. Analyze the result. You will see a joke, as requested in the prompt.
5. You can follow up with more prompts to continue testing your AI agent.
6. Select the **Are you satisfied with the result?** checkbox when you want to finish the process, then click **Complete task**.
7. Go back to Operate. You will see the process instance is now completed, and the end event has been triggered.

## Next steps

Now that you know how to monitor your AI agents, you can:

- [Analyze your AI agents](./analyze-ai-agents.md) with Optimize.
- [Test your AI agents](./test-ai-agents.md) with Camunda Process Test, including handling non-deterministic flows and verifying AI-generated output.
- Learn more about [Camunda agentic orchestration](/components/agentic-orchestration/agentic-orchestration-overview.md) and the [AI Agent connector](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md).

---

## Test your AI agents with CPT

Test your AI agent processes in Camunda 8 with [Camunda Process Test (CPT)](/apis-tools/testing/getting-started.md).

## About

AI agent processes are non-deterministic: the [AI Agent connector](/components/connectors/out-of-the-box-connectors/available-connectors-overview.md) inside an [ad-hoc sub-process](/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses.md) decides at runtime which tools to invoke and in what order, and its free-text output varies across runs.

In this guide, you will build integration tests that keep the AI agent and LLM interaction real while mocking external tool executions, using the following CPT features:

- [Conditional behavior](/apis-tools/testing/utilities.md#conditional-behavior): Reacts to whichever tasks the agent activates, instead of blocking on a single hard-coded execution order. This addresses non-deterministic control flow.
- [Judge](/apis-tools/testing/assertions.md#hasvariablesatisfiesjudge) and [semantic similarity assertions](/apis-tools/testing/assertions.md#hasvariablesimilarto): Verify AI-generated output.

After completing this guide, you will be able to test your AI agents using CPT.

## Prerequisites

- You use Camunda 8.9+.
- You use the Camunda Process Test Spring Boot Starter.
- You have [Camunda Process Test set up](/apis-tools/testing/getting-started.md).
- You have downloaded the [AI Agent Chat With Tools](https://marketplace.camunda.com/en-US/apps/587865) process to your local machine.

:::important
This guide is a follow-up to [build your first AI agent](/guides/getting-started-agentic-orchestration.md), in which you use the same example AI agent process. We recommend completing that guide first. However, you can also apply this guide to other AI agent process implementations.
:::

## Step 1: Prepare the example AI agent blueprint

Place the BPMN file and any associated forms for your AI agent process in the `src/main/resources` directory of your Spring Boot project. Create it if it does not already exist.

You can organize files into subdirectories such as `bpmn/` and `forms/`.

## Step 2: Configure the LLM provider and connectors

Judge assertions send a process variable and a natural language expectation to a configured LLM, which scores how well they match. The assertion passes if the score meets a configurable threshold. This avoids brittle string-matching on free-text AI output.

For this testing style, first configure both the connector runtime and the judge LLM. The goal is to keep the AI agent and LLM interaction real while disabling outbound connector execution for the tool calls you want to control in the test.

### Configure the connector runtime

Add the following connector runtime configuration to your test configuration, for example in `src/test/resources/application.yaml` or as inline properties on `@SpringBootTest`. For the full property reference, see the [CPT configuration docs](/apis-tools/testing/configuration.md).

```yaml
camunda:
  process-test:
    assertion:
      timeout: PT1M
    connectors-enabled: true
    connectors-env-vars:
      CAMUNDA_CONNECTOR_POLLING_ENABLED: "false"
      CONNECTOR_OUTBOUND_DISCOVERY_DISABLED: "true"
      CONNECTOR_OUTBOUND_DISABLED: "io.camunda:http-json:1"
```

With this setup:

- The assertion timeout is increased to one minute. AI agent processes involve LLM interactions and typically take longer than standard BPMN processes.
- CPT starts the connector runtime needed by the AI agent process.
- Outbound connector executions, such as the HTTP JSON connector, are disabled so tool behavior can be controlled by the test with conditional behavior.

If your AI agent tools use different outbound connectors, adjust `CONNECTOR_OUTBOUND_DISABLED` accordingly.

### Configure the LLM provider

Configure the LLM provider for the judge. The judge does not need the same provider or model as your AI agent. A lighter model often works well since the judge context is much smaller.

<Tabs groupId="judge-provider" defaultValue="amazon-bedrock" queryString values={[
{label: 'Amazon Bedrock', value: 'amazon-bedrock' },
{label: 'Ollama', value: 'openai-compatible' }
]}>

<TabItem value='amazon-bedrock'>

```yaml
camunda:
  process-test:
    connectors-secrets:
      AWS_BEDROCK_ACCESS_KEY: ${AWS_LLM_BEDROCK_ACCESS_KEY}
      AWS_BEDROCK_SECRET_KEY: ${AWS_LLM_BEDROCK_SECRET_KEY}
    judge:
      chat-model:
        provider: "amazon-bedrock"
        model: "eu.anthropic.claude-haiku-4-5-20251001-v1:0"
        region: "eu-central-1"
        credentials:
          access-key: ${AWS_LLM_BEDROCK_ACCESS_KEY}
          secret-key: ${AWS_LLM_BEDROCK_SECRET_KEY}
```

</TabItem>

<TabItem value='openai-compatible'>

Use this provider for [Ollama](https://ollama.com/).

```yaml
camunda:
  process-test:
    judge:
      chat-model:
        provider: "openai-compatible"
        model: "gpt-oss:20b"
        base-url: "http://localhost:11434/v1"
```

</TabItem>

</Tabs>

:::tip Manage secrets safely
Avoid committing credentials to your test configuration files. CPT properties support [Spring's external configuration](https://docs.spring.io/spring-boot/reference/features/external-config.html), so you can inject secrets through environment variables, CI/CD secret stores, or other techniques. See the [CPT configuration reference](/apis-tools/testing/configuration.md) for details.
:::

The AI agent can still interact with the configured LLM provider, while the test controls the tool executions.

For the full property reference, see [judge configuration](/apis-tools/testing/configuration.md#judge-configuration).

## Step 3: Set up the test class

Add the `@Deployment` annotation to your Spring Boot application class to declare which resources CPT should deploy:

```java
@SpringBootApplication
@Deployment(resources = {"classpath*:/bpmn/**/*.bpmn", "classpath*:/forms/**/*.form"})
public class MyApplication {}
```

Then create a test class annotated with `@SpringBootTest` and `@CamundaSpringProcessTest`, and inject the `CamundaClient` and `CamundaProcessTestContext`:

```java
@SpringBootTest(classes = MyApplication.class)
@CamundaSpringProcessTest
class AiAgentProcessTest {

    @Autowired
    private CamundaClient client;

    @Autowired
    private CamundaProcessTestContext processTestContext;
}
```

For the full setup including dependencies and project structure, see [Getting started with Camunda Process Test](/apis-tools/testing/getting-started.md).

## Step 4: Handle non-deterministic flow paths

In this guide, the test uses the prompt `"Give me a joke! Greet Ervin as an introduction"`. In response, the agent:

- Calls `List Users` and `Jokes API` in any order.
- Collects feedback through the `User Feedback` user task.

With [conditional behavior](/apis-tools/testing/utilities.md#conditional-behavior), you can register background reactions that monitor the process state and execute actions as conditions are met, without blocking the test thread. Register behaviors before starting the process; they then react independently as the process progresses.

Each behavior watches for a specific element to become active and then completes it with test data. If the agent never activates that element, the behavior simply never triggers and the test does not stall.

### Complete tool tasks

Register a behavior for each tool task the agent might invoke. In this integration test, these behaviors stand in for external tool executions such as REST connector calls.

First, define records for the tool call results:

```java
record User(int id, String name, String username) {}
```

Register a behavior that completes the `List Users` tool with a mock user list when the agent invokes it:

```java
processTestContext
    .when(
        () -> assertThatProcessInstance(ProcessInstanceSelectors.byProcessId("ai-agent-chat-with-tools"))
            .hasActiveElements("ListUsers"))
    .as("complete ListUsers")
    .then(
        () -> processTestContext.completeJob(
            JobSelectors.byElementId("ListUsers"),
            Map.of("toolCallResult",
                List.of(
                    new User(1, "Leanne Graham", "Bret"),
                    new User(2, "Ervin Howell", "Antonette")))));
```

Register a behavior that completes the `Jokes API` tool. This behavior uses chained `.then()` calls to return different jokes on repeated invocations:

```java
String firstJoke = "Why did the workflow cross the road? To get to the happy path.";
String secondJoke = "Why did the BPMN diagram apply for a job? It had excellent flow experience.";

processTestContext
    .when(
        () -> assertThatProcessInstance(ProcessInstanceSelectors.byProcessId("ai-agent-chat-with-tools"))
            .hasActiveElements("Jokes_API"))
    .as("complete jokes tool")
    .then(
        () -> processTestContext.completeJob(
            byElementId("Jokes_API"), Map.of("toolCallResult", firstJoke)))
    .then(
        () -> processTestContext.completeJob(
            byElementId("Jokes_API"), Map.of("toolCallResult", secondJoke)));
```

### Complete user tasks

The `User Feedback` user task is outside the agent and prompts the user to approve the agent output or request a different one.

Use chained `.then()` calls when a behavior should produce different results on repeated invocations: the first action is consumed on the first invocation, and the last action repeats for all subsequent invocations.

For example, register a behavior that first rejects the joke with a follow-up request, then approves the result on the next invocation:

```java
processTestContext
    .when(
        () -> assertThatProcessInstance(ProcessInstanceSelectors.byProcessId("ai-agent-chat-with-tools"))
            .hasActiveElements("User_Feedback"))
    .as("feedback loop")
    .then(
        () -> processTestContext.completeUserTask(
            "User_Feedback",
            Map.of(
                "userSatisfied", false,
                "followUpInput", "This joke is bad, send Ervin a better joke")))
    .then(
        () -> processTestContext.completeUserTask(
            "User_Feedback", Map.of("userSatisfied", true)));
```

:::important
Each behavior's action should resolve the process state that the condition checks for. For example, if the condition checks for an active user task, the action should complete that task. Otherwise the behavior may execute repeatedly.
:::

For the full conditional behavior API, see [Utilities](/apis-tools/testing/utilities.md#conditional-behavior).

## Step 5: Verify the agent output

You can use two types of assertions to verify the agent output:

- **[Judge assertions](/apis-tools/testing/assertions.md#hasvariablesatisfiesjudge)** verify AI-generated output or tool execution results with a judge LLM that scores whether a value satisfies a natural-language expectation.
- **[Semantic similarity assertions](/apis-tools/testing/assertions.md#hasvariablesimilarto)** verify AI-generated output against a reference text using embeddings and cosine similarity. They are a deterministic, lower-cost alternative to judge assertions.

### When to use judge vs. similarity

| Assertion                                               | Best for                                                                                                                                                                                                                                | Cost                                                                                                                  |
| ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| [Judge](#verify-with-judge-assertions)                  | Open-ended natural-language criteria, multi-part expectations, structured data, Camunda document content (with [document attachment](/apis-tools/testing/configuration.md#document-attachment) enabled), anything that needs reasoning. | One extra LLM call per assertion. Score and explanation depend on the configured judge model.                         |
| [Semantic similarity](#verify-with-semantic-similarity) | Checks where a concrete reference text is close to a variable's actual content. Deterministic and fast.                                                                                                                                 | One embedding call per value. No reasoning step, so it cannot evaluate criteria that aren't expressed in the wording. |

:::tip

- Use judge assertions when it feels natural to express the expectation in natural language.
- Use similarity assertions when the expected answer is itself a sample string.
  :::

#### Limitations

- Judge assertions support Camunda document evaluation when [document attachment](/apis-tools/testing/configuration.md#document-attachment) is enabled. When enabled, document references in the variable are resolved, and their content is passed to the judge as structured content blocks.

- Semantic similarity assertions operate on the **serialized JSON string** of a process variable and cannot evaluate non-text content, such as [Camunda documents](/components/document-handling/getting-started.md) or other embedded binaries. In those cases, only metadata or encoded strings reach the assertion.

- Semantic similarity assertions compare the serialized variable against the expected string using a vector space. Highly structured variables, such as JSON objects with many fields, may score lower than expected even when the semantic meaning matches.

### Verify with judge assertions

Use a judge assertion to verify the agent output satisfies a natural language expectation.

The following example registers the conditional behaviors from [Step 4](#step-4-handle-non-deterministic-flow-paths), starts the process with the prompt `"Give me a joke! Greet Ervin as an introduction"`, and then asserts that the agent completed the scenario correctly:

```java
@Test
void shouldSendErvinAJoke() {
    ProcessInstanceEvent processInstance = client.newCreateInstanceCommand()
        .bpmnProcessId("ai-agent-chat-with-tools")
        .latestVersion()
        .variables(Map.of("inputText", "Give me a joke! Greet Ervin as an introduction"))
        .send()
        .join();

    assertThat(processInstance).isCompleted();
    assertThat(processInstance)
        .hasVariableSatisfiesJudge(
            "agent",
            """
            The agent correctly identified Ervin by calling ListUsers.
            The agent fetched a joke using Jokes_API.
            After the user rejected the first joke and asked for another one, the
            agent offered a second, different joke.
            """);
}
```

The expectation is a plain-text description of what the agent should have done. The judge does not compare strings literally. It evaluates whether the actual variable content satisfies the expectation semantically, so different phrasing or formatting in the agent's output does not cause false failures.

The judge evaluates matches using the following scoring scale:

| Score | Meaning                                                                                                                |
| ----- | ---------------------------------------------------------------------------------------------------------------------- |
| 1.0   | Fully satisfied semantically. Different wording or formatting that conveys the same meaning counts as fully satisfied. |
| 0.75  | Satisfied in substance with only minor differences that do not affect correctness.                                     |
| 0.5   | Partially satisfied. Some required elements are present but others are missing or incorrect.                           |
| 0.25  | Mostly not satisfied. Only marginal relevance.                                                                         |
| 0.0   | Not satisfied at all, or the actual value is empty.                                                                    |

The LLM may return any value between these anchor points (for example, 0.6 or 0.85). The default threshold is 0.5. This means the assertion passes when the response is at least partially satisfied according to the rubric, which is a practical default for AI-generated output that may vary in wording or completeness across runs. Use a higher threshold when the response must satisfy stricter semantic requirements. You can change the threshold globally in the [judge configuration](/apis-tools/testing/configuration.md#judge-configuration) or per assertion using `withJudgeConfig`.

If the assertion fails, for example, because the agent made up its own joke instead of calling the `Jokes API` tool, or the feedback was not handled correctly, the judge returns a low score with an explanation of which parts of the expectation were not met. This gives you a clear, human-readable failure message instead of a generic assertion error.

#### Tune the judge evaluation

Use `withJudgeConfig` to set a stricter threshold for individual assertions:

```java
assertThat(processInstance)
    .withJudgeConfig(config -> config.withThreshold(0.8))
    .hasVariableSatisfiesJudge(
        "agent",
        "The email body contains a joke addressed to Ervin.");
```

You can also replace the default evaluation criteria with a custom prompt. The custom prompt replaces only the evaluation criteria. The system still controls the expectation and value injection, the scoring rubric, and the JSON output format.

Set a custom prompt globally in configuration:

```yaml
camunda:
  process-test:
    judge:
      custom-prompt: "You are evaluating whether an AI agent correctly identified the intended recipient, used the right tools, and produced an appropriate email response."
```

Or override the prompt for a single assertion:

```java
assertThat(processInstance)
    .withJudgeConfig(config -> config
        .withCustomPrompt("You are evaluating whether an AI agent correctly identified the intended recipient, used the right tools, and produced an appropriate email response."))
    .hasVariableSatisfiesJudge("agent", "The email body contains a joke addressed to Ervin.");
```

For the full assertion API, see [Assertions](/apis-tools/testing/assertions.md#hasvariablesatisfiesjudge).

### Verify with semantic similarity assertions

Use a semantic similarity assertion to verify the agent output.
Semantic similarity assertions are a deterministic, lower-cost alternative to [judge assertions](#step-5-verify-with-judge-assertions).

Instead of calling a judge LLM at assertion time, they convert both the actual variable value and the expected text to vector embeddings and compare them using cosine similarity.
They work best when you can express the expected result as a concrete sample string.

### Configure the embedding model

The embedding model does not need to match the AI agent's LLM or the judge model. Depending on your requirements, a lightweight model is often good enough for a good test result.

Add the embedding model configuration to your test configuration alongside the CPT settings from [Step 2](#step-2-configure-the-llm-provider-and-connectors):

<Tabs groupId="similarity-provider" defaultValue="amazon-bedrock-similarity" queryString values={[
{label: 'Amazon Bedrock', value: 'amazon-bedrock-similarity' },
{label: 'Ollama', value: 'openai-compatible-similarity' }
]}>

<TabItem value='amazon-bedrock-similarity'>

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "amazon-bedrock"
        model: "amazon.titan-embed-text-v2:0"
        region: "eu-central-1"
        dimensions: 256
        credentials:
          access-key: ${AWS_LLM_BEDROCK_ACCESS_KEY}
          secret-key: ${AWS_LLM_BEDROCK_SECRET_KEY}
```

</TabItem>

<TabItem value='openai-compatible-similarity'>

Use this provider for [Ollama](https://ollama.com/).

```yaml
camunda:
  process-test:
    similarity:
      embedding-model:
        provider: "openai-compatible"
        model: "<your-model-id>"
        base-url: "http://localhost:11434/v1"
```

</TabItem>

</Tabs>

For the full property reference, see [semantic similarity configuration](/apis-tools/testing/configuration.md#semantic-similarity-configuration).

### Add a similarity assertion

With the embedding model configured, use `hasVariableSimilarTo` as a complementary check on the `responseText` variable of the `User_Feedback` task instance:

```java
assertThat(processInstance)
    .hasVariableSimilarTo(
        "User_Feedback",
        "responseText",
        """
          Hey Ervin! Here is a joke for you:
          Why did the workflow cross the road? To get to the happy path.
        """);
```

The assertion converts both strings to embeddings, applies the default text preprocessors (lowercase, Unicode NFC, and whitespace normalization), and compares cosine similarity against the default threshold of 0.5.

Override the minimal success threshold for a single assertion if you require a higher precision for some assertions:

```java
assertThat(processInstance)
    .withSemanticSimilarityConfig(config -> config.withThreshold(0.8))
    .hasVariableSimilarTo(
        "User_Feedback",
        "responseText",
        """
          Hey Ervin! Here is a joke for you:
          Why did the workflow cross the road? To get to the happy path.
        """);
```

## Next steps

Now that you know how to test your AI agents, you can:

- Learn more about [Camunda agentic orchestration](/components/agentic-orchestration/agentic-orchestration-overview.md) and the [AI Agent connector](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md).
- Dive into [Camunda Process Test assertions](/apis-tools/testing/assertions.md).
- Review [judge](/apis-tools/testing/configuration.md#judge-configuration) and [semantic similarity](/apis-tools/testing/configuration.md#semantic-similarity-configuration) configurations for the full property references.
- Explore [conditional behavior](/apis-tools/testing/utilities.md#conditional-behavior), including chained actions and lifecycle details.

---

## Expose a process as an MCP tool

Expose a BPMN process as a callable [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) tool so that AI agents and LLM-powered applications can discover and invoke it.

## About

You can configure a BPMN process as a callable MCP tool through the [Processes MCP Server](/apis-tools/processes-mcp/processes-mcp-overview.md).

It is built into the Orchestration Cluster and automatically registers processes as MCP tools when they are deployed with the [MCP start event element template](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-start-event.md).

:::tip
If your AI agent and the target process run on the **same** Orchestration Cluster, consider using a [call activity](/components/modeler/bpmn/call-activities/call-activities.md) inside the ad-hoc sub-process instead. Call activities are synchronous and maintain a connected instance hierarchy with a consistent audit trail. See [call processes as agent tools](/components/agentic-orchestration/design-architecture.md#call-processes-as-agent-tools) for a full comparison.
:::

## Prerequisites

- A [Camunda Hub project](/components/hub/workspace/manage-projects/create-a-project.md) or access to [Desktop Modeler](/components/modeler/desktop-modeler/install-the-modeler.md).
- An [Orchestration Cluster](/components/orchestration-cluster.md) running Camunda 8.10 or later.

## Step 1: Add an MCP start event to your process

The [MCP start event element template](/components/connectors/out-of-the-box-connectors/agentic-ai-mcp-start-event.md) is an element template that you apply to a BPMN message start event. When deployed, it registers the process as an MCP tool.

1. Open your BPMN process in Modeler.
2. Select the start event (or add a new one).
3. In the properties panel, click the element template picker and select **MCP start event** from the **AI Tools** category.

![A BPMN message start event in the Camunda Hub modeler with the MCP start event element template applied, showing the properties panel](img/mcp-start-event-modeler.png)

## Step 2: Configure the MCP tool metadata

The properties you fill in become the MCP tool's metadata, which AI agents and LLMs use to decide when and how to call your process.

Define them in clear and concise language. Vague or incomplete metadata leads to incorrect tool selection or missing arguments.

| Property                  | Required | Description                                                                                                                                                               |
| :------------------------ | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Name**                  | Yes      | The MCP tool identifier used by clients to call this process. Alphanumeric characters, hyphens (`-`), underscores (`_`), and dots (`.`) **only**. Maximum 100 characters. |
| **What it does**          | Yes      | A plain-language description of the process function, shown to LLMs as tool metadata.                                                                                     |
| **Which inputs it needs** | Yes      | A plain-language description of required and optional input parameters, their types, and any constraints.                                                                 |
| **When to use**           | No       | Specific situations or user intents that should trigger this tool.                                                                                                        |
| **When not to use**       | No       | Conditions or situations where this tool should not be invoked.                                                                                                           |
| **What the tool returns** | No       | The outcomes, results, and variable names the process produces on completion.                                                                                             |

## Step 3: Design the process execution

When an MCP client calls the tool:

1. The Processes MCP Server starts a new process instance with the tool call arguments mapped as process variables.
2. The server immediately returns the started process instance key to the MCP client.

You can map the incoming tool call arguments from the LLM to the process variables your process expects using the **Output mapping** property. If you don't define any explicit output mapping, all incoming tool call arguments become process variables with the same names.

## Step 4: Deploy the process

Deploy the process to your Orchestration Cluster. After deployment, the Processes MCP Server automatically registers the process as an MCP tool using the metadata you configured.

:::important Version binding
Only the latest deployed version of a process is exposed as an MCP tool. If you redeploy the process with a changed interface, existing MCP clients holding a cached reference to the old tool will receive a stale-tool error and must re-fetch the tool list. See [version binding](/apis-tools/processes-mcp/processes-mcp-version-binding.md) for more details.
:::

## Step 5: Connect an MCP client

Connect any MCP-compliant client to the Processes MCP Server.

See [Enable and connect](/apis-tools/processes-mcp/processes-mcp-setup.md) for endpoint URLs, authentication options, and other configuration details.

## Step 6: Verify

After deployment, you can verify that your process is registered as an MCP tool in the Orchestration Cluster admin UI. See [MCP processes](/self-managed/components/orchestration-cluster/admin/mcp-processes.md) to learn how.

---

## LLM recommendations for agentic processes

Recommendations and best practices for choosing LLMs and designing effective prompts for agentic processes.

## General model requirements

To implement an agentic process, you must choose a model that meets certain baseline requirements.
These include:

### Tool calling support

The model should be able to invoke external tools and work with work with tool-calling mechanisms, as part of its output.
If a model cannot call tools, it won’t be suitable for an agentic workflow.

### Vendor compatibility

The model must be available through at least one supported vendor or API.

In practice, this means using a model from AWS Bedrock, Google Vertex AI, Azure OpenAI, OpenAI (or any platform compatible with the OpenAI API).
Choosing a model from these ecosystems ensures it will integrate with Camunda’s connectors and the agentic orchestration framework.

### Plain text I/O

The model should accept and return plain text.

Agentic processes rely on text prompts and text-based replies (which may include JSON or other structured text). Avoid models that only produce non-text outputs or require special input formats. _Text in, text out_ is essential for simplicity and reliable tool integration.

### Choose the right model for each use case

Not every decision in a process needs the same model:

- Frontier models deliver stronger reasoning and handle ambiguous inputs well, but carry higher per-call costs and depend on external infrastructure.
- Open-weight models, hosted via Ollama or a compatible inference platform, offer lower costs and full infrastructure control. They're a good fit for high-volume or simpler decisions.

With the right model choice, you can keep accuracy where it counts and control costs everywhere else.

## General recommendations for agentic processes

As well as choosing the right model, you should follow best practices in designing your agentic process.
These recommendations help your AI agent work effectively and safely within a workflow.

### Use detailed tool descriptions

When defining tools for the agent to use be very specific about what each tool does and what input it expects:

- The more context you give the AI about the tool’s purpose, the more accurately it will use that tool.
- Write clear, instructive descriptions for each tool call.

You can do so via [`fromAi` expressions](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions.md#ai-generated-parameters-via-fromai) in Camunda.
For example, `fromAi(toolCall.emailBody, "Body of the email to be sent")`.

### Mind the context window

Consider the model’s context size when designing your agent’s interactions:

- For example, if your model has a 4k token limit, plan your prompt and tool usage so you don’t exceed that. Only include relevant information in the prompt and trim any unnecessary details.
- When defining tools’ input and output, anticipate how large those could be. A large chunk of text returned from a tool can quickly consume the context window, leaving little room for the model’s reasoning or response.

### Avoid overfilling the prompt with tool output

Be cautious that tool responses don’t unintentionally fill the entire context.

- If a tool returns very large data, consider post-processing it before feeding it back into the model.
- For example, you might take only a summary of a document rather than the full text.
  This prevents the model’s next prompt from being dominated by irrelevant or excessive content, which can degrade performance and increase cost.

### Sanitize tool outputs

Sanitizing ensures the agent doesn’t accidentally get confused or manipulated by malformed tool data, and also reduces the risk of prompt injections coming from external tool results:

- Always clean and validate the output from tools before the AI agent uses it in a prompt, by removing any irrelevant, sensitive, or potentially prompt-breaking content. This is important for both security and prompt clarity.
- For example, if a web search tool returns HTML or script tags, strip those out or convert them to plain text.

### Account for limited memory and long processes

Agentic workflows can be long-running. The AI model won’t “remember” everything forever, as its memory is essentially the prompt history within the context window.

- If your process spans multiple steps or lengthy pauses, store important information outside the model’s short-term memory. Use Camunda’s document storage or your own persistent storage layer, such as a database, to save key data between steps.
- For example, if the agent gathers info in an early step that’s needed much later, persist that info so it can be reloaded into the prompt when required. This way, the agent can retrieve past knowledge without relying on an ever-growing prompt history.

:::note
An agentic process might pause or wait for events, causing the context to reset between runs. By saving state to a database or Camunda document storage, you ensure nothing vital is lost when the process continues. Think of it as the agent’s long-term memory—use it for any details the agent might need beyond the current prompt.
:::

### Incorporate human feedback when appropriate

Consider adding a “human in the loop” as one of the agent’s tools. In practice, this could be a special tool, such as `ask_human` or a review task, that the agent can invoke to get confirmation or guidance from a user.

- This is especially useful for high-stakes decisions or if the AI is unsure how to proceed. Designing your process with a human feedback option means the agent can defer to a person instead of guessing.
- For example, the workflow might include a step where an employee reviews the AI’s draft output or where the AI explicitly asks the user to clarify an ambiguous request. This supervision loop can greatly improve the quality and safety of the agent’s actions.

## Prompting recommendations

Constructing effective prompts is critical for guiding the model in an agentic process. Keep the following guidelines in mind.

### Leverage vendor-specific best practices

Each model has recommended prompting techniques. Refer to the official documentation for each model:

- [Anthropic Claude](https://docs.anthropic.com/claude/docs)
- [OpenAI GPT / reasoning models](https://platform.openai.com/docs/guides/prompt-engineering)
- [Google Gemini](https://cloud.google.com/vertex-ai/generative-ai/docs/models)
- [Cohere Command-R](https://docs.cohere.com/docs/the-cohere-platform)
- [Meta Llama](https://llama.meta.com/docs/)
- [Mistral / Mixtral / Codestral](https://docs.mistral.ai/)
- [Alibaba Qwen](https://qwen.readthedocs.io/)

### Use chain-of-thought and examples for complex tasks

Don’t hesitate to let the model “think out loud” or guide it through tricky scenarios. Chain-of-thought prompting asks the model to solve problems step by step, for example, by including a phrase like “Let’s reason this out step by step...” or using a hidden `<reflection>` tag if supported.
This approach helps improve reasoning accuracy.

Also, provide a few in-context examples (few-shot prompting) to show how to handle edge cases, compliance rules, or specific output formats. Illustrate any structured output formats in the prompt, and if possible, configure the connector's [response format](../connectors/out-of-the-box-connectors/agentic-ai-aiagent.md) options to enforce JSON or parsed text responses. Clear examples and format guidance set expectations for the AI, ensuring consistency and reducing errors.

### Define when and how the agent should seek user input

In your system or prompt instructions, make it clear when the AI should involve a human. For example, you could say, “If the user’s request is unclear or more information is needed, the assistant should ask a follow-up question via the customer communication tool.”

Decide which points in the process need user feedback, such as after showing an intermediate result or when the AI is unsure about a critical decision. Specify this in the prompt so the model knows it is acceptable or expected to ask for clarification.

The instructions should also guide the AI on using the human feedback tool. For example, “Before finalizing an answer, if confidence is low, call the `ask_human` tool to confirm the details.” Being explicit helps the agent make better decisions.

### Set a clear persona and objective in the system prompt

Always start your prompt by defining the AI’s role and goal. For example, in an agentic process, the model could act as a specialized assistant: “You are OrderAgent, an AI assistant helping users track and modify their orders.”

Include the persona’s traits and main objective. For example: “Your goal is to resolve customer inquiries using the tools provided while following all company guidelines.” Defining the persona and objective helps the model maintain a consistent tone and produce focused, coherent outputs.

:::tip
Prompt engineering is iterative. After writing an initial prompt, test it with your model and sample scenarios. If the agent’s behavior isn’t quite right, refine the wording or add another example.

Small phrasing changes can have a big impact. Continue to experiment and refine to achieve reliable, compliant results for your specific agentic use case.
:::

### Example of a generic prompt

```text
You are **OrderAgent**, a helpful AI assistant supporting order management.
Your objective is to resolve requests by:
1. Using the available tools when external action is required.
2. Asking for clarification when input is incomplete or ambiguous.
3. Returning outputs in JSON format if requested by the connector.

Let’s reason step by step.

Comportments for tool usage:
- **Direct actions:**
  - Use `cancel_order` when a clear and valid order ID is provided.
  - Use `send_email` only when communication with the customer is explicitly required.

- **Chained actions:**
  - If cancelling an order also requires notifying the customer, first call `cancel_order`, then call `send_email`.
  - If a tool returns a status update that triggers a follow-up action (for example, an order is “on hold”), use the corresponding resolution tool in sequence.

- **Ambiguity handling:**
  - If the order reference is missing, request clarification before proceeding with a tool.
  - If multiple orders match the request, return options and request the user (or `ask_human`) to disambiguate.

- **Escalation to human (`ask_human`):**
  - If the requested action could have irreversible impact (e.g., “delete all orders”), always escalate.
  - If tool outputs are malformed, incomplete, or contradictory, escalate for review.
  - If confidence in the decision path is low (for example, conflicting data across tools), escalate rather than guessing.

- **Unexpected tool outputs:**
  - If a tool returns irrelevant or excessive data (e.g., HTML instead of plain text), sanitize and summarize before continuing.
  - If output cannot be parsed or mapped correctly, escalate with `ask_human`.

The goal is to use tools precisely, combine them logically when workflows require multiple steps, and defer to a human when safety, ambiguity, or unexpected results make autonomous resolution unreliable.

```

---

## Add long-term memory to your AI agents

Use Retrieval-Augmented Generation (RAG) with the [Vector Database connector](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md) to give your AI agents access to persistent, domain-specific knowledge that grows over time.

## When to use long-term memory

A standard AI agent operates within a fixed context window. This works well for many tasks, but becomes limiting when the agent needs access to large or frequently updated knowledge.

Long-term memory solves this by storing knowledge outside the agent in a vector database and retrieving only the most relevant fragments at runtime. Common use cases include:

- **Policy and procedure lookup**: The agent answers questions about internal rules or processes by retrieving the relevant document sections on demand.
- **Product and catalog search**: The agent finds product details, specifications, or pricing from a large catalog without loading it all into context.
- **Support knowledge base**: Answers to previously resolved questions are stored and surfaced automatically when similar questions arise in the future.
- **Compliance and audit**: The agent retrieves the exact policy text needed to justify or explain a decision, making its reasoning traceable.

## How it works

The [Vector Database connector](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md) supports two operations that together implement long-term memory:

- **Retrieve document**: Performs a semantic similarity search and returns the most relevant results from a vector index. Use this to let the agent query its knowledge base.
- **Embed document**: Converts text into a vector embedding and stores it in the vector index. Use this to add new knowledge to the agent's memory.

The LLM is responsible for generating natural language queries when retrieving, and for deciding what content is worth storing. The actual vector operations (encoding, indexing, and searching) are handled by the connector and the underlying vector store.

To configure either operation, you need:

- A supported [vector store](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#vector-stores) and connection credentials.
- A supported [embedding model](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#embedding-models) and its provider credentials.
- An index name that identifies the collection to read from or write to.

## Retrieve from the vector database

To perform a semantic search from a vector database, you can use one of the following two approaches.

### Add a vector database query tool

To let an agent query a vector database, add a **Vector Database connector task** with no incoming sequence flows inside the AI Agent's [ad-hoc sub-process](/components/modeler/bpmn/ad-hoc-subprocesses/ad-hoc-subprocesses.md).

:::note
Tasks with no incoming flows are treated as available [tools](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions.md) by the AI Agent connector.
:::

Configure the task as follows:

1. Give the task a clear **Name** and write a descriptive **Element documentation** to help the LLM understand when to use this tool. The element documentation is passed to the LLM as the [tool description](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions.md#tool-definitions).
2. Set **Operation** to **Retrieve document**.
3. Set **Search query** using the [`fromAi()`](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent-tool-definitions.md#ai-generated-parameters-via-fromai) function so the LLM generates the query dynamically at runtime:

```feel
fromAi(toolCall.query, "The query you're making to the vector database.")
```

4. Set **Max results** to control the maximum number of documents returned. For example, set it to five.
5. Configure the [**Embedding model**](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#embedding-models) with your provider credentials.
6. Configure the [**Vector store**](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#vector-stores) with your database connection details and **index name**. The index name identifies the collection of documents the agent searches. You can use different indexes for different knowledge domains.
7. In the **Output mapping** section, set the output **Result variable** to `toolCallResult`.

### Isolate content with dynamic index names

When multiple agents, tenants, or conversations share the same vector database, you can isolate their content by using **dynamic index names**. Instead of hardcoding a single index, construct the index name at runtime using process variables. For example, by appending a tenant ID or conversation ID:

```feel
"knowledge-base-" + tenantId
```

This ensures each scope reads and writes only its own documents, without requiring metadata-based filtering at query time.

Because indexes are created on demand when documents are first embedded, a retrieval task may run before any documents have been stored for a given scope. This may result in an `index_not_found` error.
See how to [handle missing or empty results](#handle-missing-or-empty-results).

#### Handle missing or empty results

To prevent process failures when no results are retrieved, you can set an error handler to inform the agent as follows.

1. In the **Error handling** section, set the **Error expression** to handle these scenarios. For example:

```
if contains(error.message, "index_not_found") then bpmnError("index_not_found", "The index does not exist") else null
```

2. Add an [**error boundary event**](/components/modeler/bpmn/call-activities/call-activities.md#boundary-events) to the Vector Database connector:
3. In the boundary event's **Output mapping** section, add an output variable as follows:

- Set **Process variable name** to `toolCallResult`.
- Set **Variable assignment value** to:
  ```
  {
    "searchResult": "Nothing was found"
  }
  ```

### Prefetch context with a vector database retrieval

Instead of letting the agent decide when to query the vector database via a tool, you can retrieve relevant context **before** the agent runs. This ensures the agent always has access to relevant knowledge from the first interaction, without requiring a tool call.

This pattern is useful when:

- The user's query is predictable enough to retrieve meaningful context upfront.
- You want to reduce the number of tool calls and agent reasoning steps.
- The agent should ground its first response in domain-specific knowledge without deciding whether to search.

#### Configure the retrieval task

1. Add a **Vector Database connector task** in your process, sequenced before the AI Agent connector task.
2. Set **Operation** to **Retrieve document**.
3. Set **Search query** to the user's input. For example, if the user query is stored in a process variable:

```feel
userQuery
```

4. Set **Max results** to control the maximum number of documents returned. For example, set it to five.
5. Configure the [**Embedding model**](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#embedding-models) with your provider credentials.
6. Configure the [**Vector store**](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#vector-stores) with your database connection details and **index name**. The index name identifies the collection of documents the agent searches. You can use different indexes for different knowledge domains.
7. In the **Output mapping** section, set the output **Result variable**. For example, `retrievalResult`.

### Pass retrieved context to the agent

Once the retrieval task completes, include its results in the AI Agent's user message. There are two approaches:

#### Concatenate as text

Build the user message by appending the retrieved text to the original query:

```feel
userQuery + "

Use the following context to inform your answer:
" + " ".join(retrievalResult.searchResult)
```

This works well when the retrieved content is short and you want the agent to treat it as inline context.

#### Attach as documents

If the Vector Database connector returns structured document objects, you can add them to the user message's document list. This keeps the user query and the supporting documents separate, which can help the LLM distinguish between the question and the reference material.

Refer to the [AI Agent connector documentation](/components/connectors/out-of-the-box-connectors/agentic-ai-aiagent.md) for details on how to structure the message input with documents.

### Prefetch vs. tool-based approach

| Consideration      | Prefetch                                             | Tool-based retrieval                                       |
| ------------------ | ---------------------------------------------------- | ---------------------------------------------------------- |
| **Agent autonomy** | Agent does not choose when to search                 | Agent decides if and when to search                        |
| **Latency**        | Retrieval runs once before the agent starts          | Retrieval adds a tool-call round trip                      |
| **Query control**  | Uses the raw user query directly                     | LLM reformulates the query dynamically                     |
| **Relevance**      | Best when the user query maps well to stored content | Best when the agent needs to refine or decompose the query |

:::tip
You can combine both patterns: prefetch broad context to prime the agent, and still expose a retrieval tool for follow-up searches the agent initiates on its own.
:::

## Store in the vector database

You can store knowledge in the vector database in two ways:

- **Batch import**: Documents are embedded and stored before the agent starts processing, typically as part of a data preparation process. Use a Vector Database connector task in a separate BPMN process or script.
- **Runtime ingestion**: New knowledge is added to the vector database as the agent encounters it. For example, when a human provides an answer that did not previously exist in the database.

:::note
Re-embedding the same document is **not idempotent**: if you store it again without deleting the existing chunks first, you’ll create **duplicate chunks** in the vector database.
:::

For both approaches, add a **Vector Database connector task** and configure it as follows:

1. Set **Operation** to **Embed document**.
1. Set **Document source** to **Plain text**.
1. Provide the text to embed. This can be a process variable, a form output, or any string value.
1. Configure the same [**Embedding model**](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#embedding-models) and [**Vector store**](/components/connectors/out-of-the-box-connectors/embeddings-vector-db.md#vector-stores) settings used by the retrieval method so both operations target the same index.

:::important
Make sure the embedding model configuration, including vector dimensions, matches your retrieval setup.
:::

## Gate memory writes with human approval

Allowing an agent to write to its own knowledge database without human oversight can lead to incorrect
or irrelevant data being stored.

Besides, an effective pattern for building long-term memory is to combine a human escalation tool with runtime knowledge ingestion. When the agent can’t find an answer in the vector database, it escalates to a human. The human responds to the agent and decides whether it’s worth storing the answer in the vector database for future queries.

Over time, this creates a self-improving knowledge base: as humans answer previously unknown questions, the agent's ability to resolve those questions autonomously increases and the rate of human escalations decreases.

To implement this pattern:

1. Add a [user task](/components/modeler/bpmn/user-tasks/user-tasks.md) inside the AI Agent's ad-hoc sub-process. The agent will invoke it as a tool when it cannot resolve a query from its existing knowledge.
2. Configure the user task's **Input mapping** to pass the agent's question to the form using `fromAi()`. For example:

```feel
fromAi(toolCall.question, "The question the agent needs a human to answer.")
```

3. Add a [form](/components/modeler/forms/camunda-forms-reference.md) to the user task. It should capture the human's answer and include a decision checkbox for whether to store it in long-term memory.
4. Configure the user task's **Output mapping** to set the human's answer as `toolCallResult` so it is returned directly to the agent.
5. Add an [exclusive gateway](/components/modeler/bpmn/exclusive-gateways/exclusive-gateways.md) after the user task with two outgoing paths:
   - **Approved**: [Store in the vector database](#store-in-the-vector-database).
   - **Rejected**: Do not store.
6. Use the human's output variable as the gateway condition.

---

## Access control(Overview)

Reference the permissions required to access audit log entries.

## About

To access entries in the audit log, you must have the relevant authorizations to match your needs:

| Authorization type                                                                                                                                                                                       | Resource type        | Resource ID                                                                                       | Permission              |
| :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------- | :------------------------------------------------------------------------------------------------ | :---------------------- |
| View audit log entries.                                                                                                                                                                                  | `AUDIT_LOG`          | An operation category (`ADMIN`, `DEPLOYED_RESOURCES`, or `USER_TASKS`) or `*` for all categories. | `READ`                  |
| View `DEPLOYED_RESOURCES` and `USER_TASKS` operation logs for instances of a specific process definition. This provides access to both the general and process instance-level operation logs in Operate. | `PROCESS_DEFINITION` | A process definition ID or `*` for all process definitions.                                       | `READ_PROCESS_INSTANCE` |
| View `USER_TASKS` operation logs for instances of a specific process definition. This provides access to the operation log in Operate and the task history in Tasklist.                                  | `PROCESS_DEFINITION` | A process definition ID or `*` for all process definitions.                                       | `READ_USER_TASK`        |
| View operations related to specific tasks the user has access to based on task properties. This provides access to task history records in Tasklist.                                                     | `USER_TASK`          | A user task property (assignee, candidateUsers, candidateGroups).                                 | `READ`                  |

Learn more about the operation categories in [Recorded operations](./recorded-operations.md).

---

## Operation data structure

Learn more about how operation data from the audit log is presented in different contexts.

## Applications

Depending on the view you're using to access the audit log in [Operate](../../operate/userguide/audit-operations.md), [Admin](../../admin/audit-operations.md), or [Tasklist](../../tasklist/userguide/audit-task-history.md), you'll see a subset of the following operation details:

| Property       | Description                                                                 |
| :------------- | :-------------------------------------------------------------------------- |
| Status         | The status of the operation.                                                |
| Operation type | The type of operation applied.                                              |
| Entity type    | The type of entity the operation was applied to.                            |
| Entity key     | The key and name of the entity the operation was applied to, if applicable. |
| Parent entity  | The key and name of the parent entity, if applicable.                       |
| Related entity | The ID or name of the related entity, if applicable.                        |
| Details        | Details about the operation.                                                |
| Actor          | The user, client, agent, or MCP tool that applied the operation.            |
| Date           | The date and time at which the operation was applied.                       |

### Entity key

Some audit log entries contain extra details about the entity in the **entity key** field:

| Operation type | Entity type      | Entity key    |
| :------------- | :--------------- | :------------ |
| Create         | Process instance | Process name  |
| Delete         | Process instance | Process name  |
| Create         | Variable         | Variable name |
| Create         | Resource         | Resource name |
| Delete         | Resource         | Resource name |
| Create         | Decision         | Decision name |
| Delete         | Decision         | Decision name |

### Details

Some audit log entries contain extra details about the operation in the **details** field:

| Operation type | Entity type   | Details                            |
| :------------- | :------------ | :--------------------------------- |
| Create         | Batch         | Batch operation type               |
| Assign         | User task     | Assignee                           |
| Unassign       | User task     | Assignee                           |
| Create         | Authorization | Owner(entity type, entity name)    |
| Assign         | Tenant        | Assignee(entity type, entity name) |
| Unassign       | Tenant        | Assignee(entity type, entity name) |
| Assign         | Role          | Assignee(entity type, entity name) |
| Unassign       | Role          | Assignee(entity type, entity name) |
| Assign         | Group         | Assignee(entity type, entity name) |
| Unassign       | Group         | Assignee(entity type, entity name) |

### Actor

The following actor types can trigger operations:

| Actor type | Identifier |
| :--------- | :--------- |
| User       | Username   |
| Client     | Client ID  |

Agents can perform operations on behalf of a user or client. In this case, you will see the agent's information in the record.

### Inbound channel

Alongside the actor, operations record the inbound channel through which they were triggered, when available, identifying how the operation entered the system:

| Channel  | Description                                                                                                                                                                          |
| :------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| REST     | The operation was triggered through the Orchestration Cluster REST API.                                                                                                              |
| GRPC     | The operation was triggered through the gRPC API.                                                                                                                                    |
| MCP      | The operation was triggered through the [Model Context Protocol (MCP)](../../agentic-orchestration/expose-process-as-mcp-tool.md), for example, by an AI agent invoking an MCP tool. |
| INTERNAL | The operation was triggered internally by Camunda.                                                                                                                                   |

When the operation was triggered through MCP, the record also captures the name of the MCP tool that triggered it, so you can distinguish operations initiated by AI agents through MCP from those performed directly by users or clients.

In the REST API, these values are exposed as `inboundChannelType` and `inboundChannelToolName`.
In Operate, when the inbound channel is `MCP`, it is shown separately in the **Actor** column. The channel and the channel tool name are also shown in the operation details popup.

## REST API

With the API, you can access more operation data than you can in the applications. See the [API response schema](../../../apis-tools/orchestration-cluster-api-rest/specifications/search-audit-logs.api.mdx#responses) for more information.

---

## Recorded operations

Learn more about which operations are recorded in the audit log.

## Limitations and constraints

The audit log contains operations performed using:

- [Operate](../../operate/userguide/audit-operations.md), [Admin](../../admin/audit-operations.md), and [Tasklist](../../tasklist/userguide/audit-task-history.md)
- [Orchestration Cluster REST API](../../../apis-tools/orchestration-cluster-api-rest/specifications/search-audit-logs.api.mdx)

However, only operations that are authenticated, authorized, and reach execution with a success or execution‑time failure are recorded. Operations rejected before execution are not recorded in the audit log.

Additionally, only user operations are tracked by default, not [client](../../zeebe/technical-concepts/architecture.md#clients) operations. Unlike the other constraints, you can configure this behavior.

## Recorded operations

There are three categories of recorded operations:

- `USER_TASKS`
- `ADMIN`
- `DEPLOYED_RESOURCES`

### `USER_TASKS` operations

You can review the full history of user task actions, including assignment changes, completions, and updates. With this, you can resolve disputes, investigate SLA breaches, and validate that required steps were followed during case handling.

These operations belong to the category `USER_TASKS`. The following operations are recorded in the audit log:

| Operation type | Entity    | Tracked rejections |
| :------------- | :-------- | :----------------- |
| Update         | User task | INVALID_STATE      |
| Assign         | User task | INVALID_STATE      |
| Unassign       | User task | INVALID_STATE      |
| Complete       | User task | INVALID_STATE      |

### `ADMIN` operations

You can track all changes to identity resources, like authorizations, users, and tenants. With this, you can detect misconfigurations and investigate potential unauthorized access to sensitive process data.

These operations belong to the category `ADMIN`. The following operations are recorded in the audit log:

| Operation type | Entity        | Tracked rejections |
| :------------- | :------------ | :----------------- |
| Create         | Authorization | –                  |
| Update         | Authorization | –                  |
| Delete         | Authorization | –                  |
| Create         | User          | –                  |
| Update         | User          | –                  |
| Delete         | User          | –                  |
| Create         | Tenant        | –                  |
| Update         | Tenant        | –                  |
| Delete         | Tenant        | –                  |
| Assign         | Tenant        | –                  |
| Unassign       | Tenant        | –                  |
| Create         | Role          | –                  |
| Update         | Role          | –                  |
| Delete         | Role          | –                  |
| Assign         | Role          | –                  |
| Unassign       | Role          | –                  |
| Create         | Group         | –                  |
| Update         | Group         | –                  |
| Delete         | Group         | –                  |
| Assign         | Group         | –                  |
| Unassign       | Group         | –                  |
| Create         | Mapping rule  | –                  |
| Update         | Mapping rule  | –                  |
| Delete         | Mapping rule  | –                  |

### `DEPLOYED_RESOURCES` operations

You can audit user and client actions that modified or influenced deployed resources and dependent entities, like process instances, batch operations, and variables. With this, you can identify manual corrections and confirm the sequence of actions that led to a process failure or escalation.

These operations belong to the category `DEPLOYED_RESOURCES`. The following operations are recorded in the audit log:

| Operation type | Entity           | Tracked rejections              |
| :------------- | :--------------- | :------------------------------ |
| Create         | Process instance | –                               |
| Cancel         | Process instance | –                               |
| Modify         | Process instance | –                               |
| Migrate        | Process instance | INVALID_STATE, PROCESSING_ERROR |
| Create         | Variable         | –                               |
| Update         | Variable         | –                               |
| Resolve        | Incident         | INVALID_STATE                   |
| Create         | Resource         | –                               |
| Delete         | Resource         | –                               |
| Create         | Batch            | –                               |
| Suspend        | Batch            | INVALID_STATE                   |
| Resume         | Batch            | INVALID_STATE                   |
| Cancel         | Batch            | INVALID_STATE                   |
| Create         | Decision         | –                               |
| Delete         | Decision         | –                               |
| Evaluate       | Decision         | –                               |

#### Batch operations

While the operations for creating and managing batch operations are recorded in the audit log, the batch operation state changes aren't. For more information, learn how to [monitor batch operations](../../operate/userguide/monitor-batch-operations.md).

## Log scope

`ADMIN` and `BATCH` operations are not scoped to a particular tenant. Instead, they're applied at a global scope because Identity-related operations don't belong to an individual tenant and batch operations may include items from multiple tenants.

Keep this in mind when you filter by tenant ID with the [search audit logs API](/apis-tools/orchestration-cluster-api-rest/specifications/search-audit-logs.api.mdx) or the [Operate user interface](/components/operate/userguide/audit-operations.md). As these operations aren't scoped to a tenant, selecting a particular tenant ID will filter out these operations.

---

## Audit log

View and audit a comprehensive record of operations across process, identity, and user task domains.

## About

The audit log provides a record of operations, including who performed an operation, when it was performed, and on which entities the operation was performed.

Use the audit log to:

- **Prove compliance:** Produce defensible evidence of operation ownership and history during internal and external audits.
- **Meet governance and regulatory requirements:** Validate if required steps were followed during case handling, and investigate unauthorized access to sensitive process data.
- **Maintain operational integrity and transparency:** See a complete record of actions taken to resolve disputes and investigate SLA breaches.
- **Troubleshoot issues:** Review user and client actions that modified or influenced process instances to confirm the sequence of actions that led to a process failure.

## Impact on secondary storage

When the audit log is active, a record is written to [secondary storage](../../self-managed/concepts/secondary-storage/index.md) for every applicable operation instance. By default, only user operations are tracked, not [client](../zeebe/technical-concepts/architecture.md#clients) operations. With this default behavior, you can expect a 3.5% increase in disk usage.

:::warning
The audit log is enabled by default. Because of the increase in resource usage on secondary storage, you may see increased costs associated with this feature.
:::

You can configure the audit log to fine tune log thoroughness and resource usage according to your needs:

- [SaaS](../hub/organization/manage-clusters/configure-audit-log.md)
- [Self-Managed](../../self-managed/concepts/audit-log/configure.md)

## Get started

Start auditing operations in Operate, Tasklist, and Admin (formerly Orchestration Cluster Identity).

<AoGrid ao={[
{
link: "../../operate/userguide/audit-operations",
title: "Audit operations in Operate",
image: PlayIcon,
description: "Learn how to audit operations in Camunda 8 Operate.",
},
{
link: "../../tasklist/userguide/audit-task-history",
title: "Audit task history in Tasklist",
image: PlayIcon,
description: "Learn how to audit task history in Camunda 8 Tasklist.",
},
{
link: "../../admin/audit-operations",
title: "Audit operations in Admin",
image: PlayIcon,
description: "Learn how to audit operations in Camunda 8 Admin.",
},
]} columns={3}/>

## Learn the fundamentals

Learn fundamental concepts about how the audit log works and how to access its data.

<AoGrid ao={[
{
link: "recorded-operations",
title: "Recorded operations",
image: DocsIcon,
description: "Learn what operations are recorded in the audit log.",
},
{
link: "access-control",
title: "Access control",
image: DocsIcon,
description: "Reference the permissions required to access audit log entries.",
},
{
link: "operation-structure",
title: "Operation data structure",
image: DocsIcon,
description: "Learn how operation data from the audit log is presented in different contexts.",
},
]} columns={3}/>

## Explore further resources

Once you have a foundational understanding of the audit log, explore these additional resources:

- [Use the Camunda REST API to access the audit log](../../apis-tools/orchestration-cluster-api-rest/specifications/search-audit-logs.api.mdx)

---

## Data flow

Understand how data moves through Camunda 8.8+ and why it matters when sizing your environment.

## About

Camunda 8.8 introduced a consolidated [Orchestration Cluster](/components/orchestration-cluster.md).
This is an overview of Camunda 8.8+ architecture:

![Camunda 8.8+ architecture overview](assets/architecture-8.8plus.jpg)

<!-- Source: Miro board https://miro.com/app/board/uXjVGiNnJBc=/ -->

See the [reference architecture](/self-managed/reference-architecture/reference-architecture.md) for a component-topology overview.

### How Camunda stores data

Every record in Camunda passes through two distinct storage layers. Understanding the difference between them is the key to understanding sizing.

- **[Primary storage](/reference/glossary.md#primary-storage)** is the multi-Raft cluster in Camunda, with partitions as the scaling unit. Each partition has a Raft append-only log, RocksDB to store internal state, and snapshots for compaction. All writes land here first. It is durable and strongly consistent, but it is not directly queryable from outside the cluster. Each partition has exactly one leader responsible for both processing commands and exporting records.
- **[Secondary storage](/reference/glossary.md#secondary-storage)** is an external data storage where events are written, such as Elasticsearch, OpenSearch, or an RDBMS (available from 8.9). It is eventually consistent and populated asynchronously by the export pipeline. Everything Operate, Tasklist, Identity, and the REST Query API reads comes exclusively from secondary storage.

## Command processing path

A command travels from the client to primary storage and then to the engine. A response only comes back after processing.
Its processing path (command lifecycle) follows this pattern:

**Client (REST or gRPC) → Camunda API (Gateway) → Broker (Command API) → Raft partition (log) → Raft replication → Processing Engine → event on log → RocksDB state update → Client response**

See it in green in the diagram below:

![Camunda 8.8+ architecture overview - Data Flow Command processing path](assets/architecture-8.8plus-data-flow-command.jpg)

Client responses are not sent until the command is fully processed by the engine. The engine can only process a command once it has been committed to the log (as part of the Raft consensus protocol). Commands are read sequentially per partition, only one command per partition is processed at a time, and only the Raft partition leader runs the engine.

This means command response latency is bounded below by Raft commit time, engine processing time, and processing queue length. In a healthy and stable cluster, this typically results in sub-second response latency for simple commands.

If the engine cannot process commands fast enough, for example, because disk I/O is saturated, network latency is high, or the backlog is large, the Command API applies backpressure to the client.

See [internal processing](../../zeebe/technical-concepts/internal-processing.md) for more details.

## Export pipeline

After the engine processes a command, it confirms its state change with an event on the log. Exporters asynchronously read such events from the log (only committed events) and write them to secondary storage in _batches_. See it in blue in the diagram below:

![Camunda 8.8+ architecture overview - Data Flow Export pipeline](assets/architecture-8.8plus-data-flow-export-path.jpg)

**The exporters run on the same leader as the engine.** They are partition-bounded and cannot scale independently of partition count. There are three built-in exporters in play:

- **[Camunda Exporter](../../../self-managed/components/orchestration-cluster/zeebe/exporters/camunda-exporter.md)**: aggregates and writes enriched data to secondary storage (ES/OS) for Operate, Tasklist, and the REST Query API
- **[RDBMS Exporter](../../../self-managed/components/orchestration-cluster/zeebe/exporters/rdbms-exporter.md)**: aggregates and writes enriched data to secondary storage (RDBMS) for Operate, Tasklist, and the REST Query API.
- **[Elasticsearch Exporter](../../../self-managed/components/orchestration-cluster/zeebe/exporters/elasticsearch-exporter.md) / [OpenSearch Exporter](../../../self-managed/components/orchestration-cluster/zeebe/exporters/opensearch-exporter.md)**: writes raw engine events into specific Elasticsearch/OpenSearch indices, consumed by Optimize.

The Camunda Exporter and RDBMS Exporter are mutually exclusive, only one can be enabled at a time. The Elasticsearch/OpenSearch exporter is independent and can be enabled alongside either of the other two.

:::note
Read events are applied to the registered exporters one by one, in the same order as they appear on the log. Each event is applied to ALL exporters before the next event is processed.
:::

The exporters track their position in the Exporter state (backed by RocksDB). If the exporting backlog grows over a certain threshold, Camunda reduces the record write rate via a corresponding [flow control](/self-managed/operational-guides/configure-flow-control/configure-flow-control.md) mechanics to keep the exporting backlog manageable. In extreme cases, client commands are rejected via the standard backpressure mechanism.

Exporter behavior and performance is important for the system, because:

- If an exporter falls behind, it holds up all exporters for that partition.
- Slow secondary storage directly reduces process execution throughput.
- Custom exporters can have a high impact on overall throughput if they are not performant enough.

## Query path

Operate, Tasklist, and the REST Query API (`GET /v2/...`) read exclusively from the configured secondary storage. They never read directly from the engine.
See it in red in the diagram below:

![Camunda 8.8+ architecture overview - Data Flow Query path](assets/architecture-8.8plus-data-flow-query.jpg)

Query results depend on the performance of both the primary (processing path) and secondary storage (exporting pipeline). They are **eventually consistent**: there is always some lag between a command completing in the engine and the result being visible in search results or the UI. This is measured as the **data availability latency**.

Data availability latency is bounded below by export pipeline lag; if the exporter is behind, data availability is behind. This can be caused by a slow or overloaded secondary storage.

## Optimize data flow

Optimize sits on top of the export pipeline as a second-tier consumer. See it in violet in the diagram below:

![Camunda 8.8+ architecture overview - Data Flow Optimize](assets/architecture-8.8plus-data-flow-optimize.jpg)

1. The Elasticsearch/OpenSearch exporter writes raw engine events into per-partition Elasticsearch/OpenSearch indices.
2. Optimize's **importer** reads from those indices and transforms the data into its own analytics indices.
3. Optimize writes the analytics indices **back into the same or another Elasticsearch/OpenSearch cluster**.

This means Optimize has an additional hop in the data flow compared to Operate and Tasklist, and it writes to secondary storage twice: once for the raw events and once for the analytics indices. As a result, data availability latency for Optimize is higher than for Operate and Tasklist, and the overall write load on Elasticsearch/OpenSearch is significantly higher when Optimize is enabled.

Optimize's indices store variables differently from the raw export. Each variable is stored in its owning process instance document, and its value is indexed in several forms simultaneously. This allows Optimize's variable filters and reports to support the following query types without requiring separate reindexing:

- An exact-match form.
- A case-insensitive form.
- A substring-searchable form.
- A best-effort date form.
- Best-effort numeric forms for long and double values.

As a result, Optimize's storage cost per variable is significantly higher than the cost of the raw exported record. The storage cost increases further for high-cardinality string variables because the substring-searchable form scales with the number of distinct values:

- Variables with a small number of repeated values, such as a status field, compress efficiently.
- Variables with a different value for almost every process instance, such as a customer or order ID, compress poorly.

See [Impact of Optimize](./sizing-your-environment.md#impact-of-optimize) for measured examples, including how object variable flattening compounds this by multiplying variable count rather than variable value size.

:::note
This is exactly why the architecture was changed in 8.8: the Camunda Exporter now aggregates the data for Operate and Tasklist, which previously both used an Exporter-Importer architecture similar to Optimize. See this [blog post](https://camunda.com/blog/2025/02/one-exporter-to-rule-them-all-exploring-camunda-exporter/) for more details.
:::

See the [sizing guide](./sizing-your-environment.md#impact-of-optimize) for details on the impact of running Optimize and how to reduce it.

:::note
Optimize is not supported with RDBMS backends. If Optimize is required, a separate Elasticsearch/OpenSearch instance must be present even if the core platform uses RDBMS.
:::

## Performance and sizing factors

The paths above map directly to the factors to consider when [sizing your environment](sizing-your-environment.md):

- **Partition count** bounds both command path throughput and export pipeline parallelism. More partitions means more parallel processing and exporting, up to the available hardware.
- **Elasticsearch/OpenSearch resources** is the most common cause of operational delay and degradation. Monitor and scale storage before hitting performance bottlenecks.
- **Optimize** significantly increases secondary storage write load. Size Elasticsearch/OpenSearch accordingly, or use a dedicated Elasticsearch/OpenSearch instance, if Optimize is enabled.

For hardware recommendations based on these factors, see how to [size your environment](sizing-your-environment.md).

---

## Deciding about your stack

Our greenfield stack recommendation is a result of extensive discussions and evaluations. While not the only option, it is a solid choice if there are no specific reasons to choose an alternative.

Your choice of programming language should align with your team's expertise; we suggest Java or JavaScript for their broad applicability and support, and have outlined the Java greenfield stack below with Camunda 8 SaaS.

## The Java greenfield stack

![greenfield stack architecture diagram](deciding-about-your-stack-assets/greenfield-architecture.png)

This architecture diagram illustrates the flow of requests from a user's browser through Camunda SaaS, where workflows and decisions are orchestrated. The process then moves to the Spring Boot application, which is responsible for executing business logic, handling database interactions with PostgreSQL, and managing various components such as custom REST endpoints, BPMN/DMN definitions, and external task workers.

### Why this stack?

- SaaS simplifies workflow engine integration.
- Spring Boot is widely adopted for Java application development.
- Flexible for both on-premises and cloud environments.

Discover more in our [getting started guide using Spring](/guides/getting-started-example.md) or the [Camunda Spring Boot Starter instructions](../../../apis-tools/camunda-spring-boot-starter/getting-started.md).

### Set up the stack

For a Java-based setup using Camunda 8 SaaS and Spring Boot, use the following stack:

#### Camunda 8 SaaS account and cluster

If you're new to Camunda SaaS, check out our [getting started guide](/guides/introduction-to-camunda-8.md#getting-started) to set up your environment.

After signing up, create a cluster by following [creating a cluster in Camunda 8](/components/hub/organization/manage-clusters/create-cluster.md), which provides step-by-step instructions on setting up a new cluster in the Camunda 8 environment.

#### Spring Boot

Develop your own process solutions as [Spring Boot](https://spring.io/projects/spring-boot) applications. This involves setting up a new Spring Boot project, either manually or using tools like [Spring Initializr](https://start.spring.io/).

Integrate the [Camunda Spring Boot Starter](../../../apis-tools/camunda-spring-boot-starter/getting-started.md) into the Spring Boot project by adding necessary dependencies to the project’s `pom.xml` file, and configure the application to use Camunda services.

#### Maven

Use [Maven](https://maven.apache.org/) to manage the build lifecycle of the application.

#### IDE selection

Select an Integrated Development Environment (IDE) that supports Java development, Maven, and Spring Boot. Frequently used options include Visual Studio Code, IntelliJ IDEA, or Eclipse.

#### Java runtime

Install and use OpenJDK 17 as your Java runtime environment. Download it from the [official JDK 17 download page](https://jdk.java.net/17/).

#### Modeling

Download and use Camunda Modeler for designing and modeling business processes. Modeler is available [here](https://camunda.org/download/modeler/).

#### Code integration

Incorporate all Java code and BPMN process models into the Spring Boot project, ensuring that they are structured correctly and referenced properly within the application.

### Run the process application:

To run the process application, transfer the `jar` to the desired server.

Start the application using the command `java -jar YourProcessApplication.jar`. Frequently, this deployment process is managed through Docker for ease of use.

For a practical implementation, refer to our [example application on GitHub](https://github.com/camunda-community-hub/camunda-cloud-examples/tree/main/twitter-review-java-springboot), which demonstrates a typical setup for a Spring Boot-based process application with Camunda.

<!-- This should be moved from the Community Hub -->

## Customize your stack

### Polyglot stacks

You can develop process solutions as described with Java above also in any other programming language, including JavaScript. Use the [existing language clients and SDKs](/apis-tools/working-with-apis-tools.md) for doing this.

### Run Camunda 8 Self-Managed

Run Camunda 8 on your Kubernetes cluster. For local development, a [Docker Compose configuration is available](/self-managed/deployment/docker/docker.md), though not for production use. Learn more in the [deployment docs](/self-managed/deployment/helm/install/quick-install.md).

---

## Run benchmarks

Run your own benchmarks to validate [Camunda 8 sizing](./sizing-your-environment.md) for your specific workload.

## Reference benchmark scenario

The sizing recommendations for [SaaS](sizing-saas.md) and [Self-Managed](sizing-self-managed.md) are based on a reference benchmark scenario. Your actual workload may differ significantly, so running your own benchmarks is the most reliable way to validate that your chosen configuration meets your needs.

Camunda uses the following realistic benchmark scenario:

- **Process model:** [bankCustomerComplaintDisputeHandling.bpmn](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/bankCustomerComplaintDisputeHandling.bpmn) (a credit card fraud dispute handling process from the [Camunda Marketplace blueprint](https://marketplace.camunda.com/en-US/apps/449510/credit-card-fraud-dispute-handling)).
- **Payload:** [realisticPayload.json](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/realisticPayload.json) (~11 KB).
- This setup produces approximately **101 tasks per second at 1 PI/s** due to internal sub-process instantiation (50 sub-process instances per root instance).

:::note
The official sizing numbers on this page are produced using the [load-tester](https://github.com/camunda/camunda/tree/main/load-tests/load-tester) tool from the Camunda monorepo.
:::

## Run your own benchmarks

Use the [Camunda 8 Benchmark project (c8b)](https://github.com/camunda-community-hub/camunda-8-benchmark), a Spring Boot application, to run load tests against your cluster.

### Key features

- Starts process instances at a configurable rate and **automatically adjusts based on backpressure**.
- Completes tasks that appear in the process instances.
- **Bring your own BPMN process model and payload**, which can be provided as URLs, such as GitHub Gists.
- **Automatic job type discovery** from BPMN files.
- Configurable **task completion delay** to simulate real worker behavior.
- Built-in **Prometheus metrics and Grafana dashboards** for observability.

### Quick start

Run the following command against your cluster:

```bash
mvn spring-boot:run
```

With Docker:

```bash
docker run camundacommunityhub/camunda-8-benchmark:main
```

Customize it with your own process and payload:

```bash
benchmark.bpmnResource=url:https://your-gist-url/your-process.bpmn
benchmark.payloadPath=url:https://your-gist-url/your-payload.json
benchmark.processInstanceStartRate=25
benchmark.taskCompletionDelay=200
```

:::important
To run meaningful benchmarks, use a **properly sized environment**. SaaS trial clusters and local developer machines have limited resources and will hit bottlenecks too early. Use either a correctly sized Camunda SaaS cluster (with help from your Camunda representative) or a properly provisioned Self-Managed Kubernetes environment.
:::

## When to benchmark

Running your own benchmarks when:

- Your process models or payload sizes **differ significantly** from the reference scenario.
- **Latency or cycle time requirements** are critical to your use case.
- You are running Optimize with **payloads larger than the reference ~11 KB** or retention periods **exceeding 6 months**. Larger payloads and longer retention amplify Elasticsearch disk consumption and Optimize import times.
- You are **upgrading from a pre-8.8 version** and want to validate resource requirements.
- You are using **RDBMS (PostgreSQL) as secondary storage** and want to validate throughput differences.

## What to measure

When running benchmarks, focus on these key metrics:

- **Sustained throughput (tasks/second):** The rate your cluster can handle continuously without increasing backpressure.
- **Backpressure rate:** Should remain below 10% for sustainable operation.
- **Process instance latency (p99):** End-to-end time from instance creation to completion. Target depends on your SLO.
- **Elasticsearch disk growth rate:** Helps you forecast disk capacity needs.
- **Data availability latency:** The time between an event in the engine and its appearance in Operate/Tasklist.
  - Note: to measure this, you have to compare the time from starting an instance and its availability in query APIs using the Orchestration Cluster REST API
- **CPU usage and throttling:** High CPU usage or frequent throttling indicates a need for more CPU resources or additional brokers.
- **Memory usage:** Sustained high memory usage suggests the need for larger memory limits or additional nodes.

<!-- TODO: Define the exact SLO boundary used for "max throughput" in the official benchmark tables (e.g., "max sustainable throughput where backpressure remains below 10% and p99 process duration stays under 1 second"). If the exact boundary is not standardized, document the methodology. -->

---

## Size your SaaS cluster

Select the right Camunda 8 SaaS cluster size based on your needs. For an overview of the factors that influence sizing, see [Size your environment](./sizing-your-environment.md).

## Determine your cluster size

Camunda 8 defines four [cluster sizes](/components/concepts/clusters.md#cluster-size) (1x, 2x, 3x, and 4x) you can select after choosing your [cluster type](/components/concepts/clusters.md#cluster-type).

To do so, follow these steps:

1. Calculate your throughput and storage requirements using the guidance in [Size your environment](./sizing-your-environment.md).
2. Use the [sizing tables](#sizing-tables) to find the cluster size that meets your needs.

:::note
To increase the cluster size beyond 4x, [reach out to Camunda](https://camunda.com/contact-us/). This requires custom sizing and pricing.
:::

### Sizing tables

| Cluster size                                         |                              1x |                              2x |                              3x |                              4x |
| :--------------------------------------------------- | ------------------------------: | ------------------------------: | ------------------------------: | ------------------------------: |
| Max Throughput **Tasks/day** **\***                  |                             9 M |                            18 M |                            27 M |                            36 M |
| Max Throughput **Tasks/second** **\***               |                             100 |                             200 |                             300 |                             400 |
| Max Throughput **Process Instances/second** **\*\*** |                               5 |                              10 |                              15 |                              20 |
| Max Total Number of PI stored (in ES) **\*\*\***     |                           200 k |                           400 k |                           600 k |                           800 k |
| Approximate resources provisioned **\*\*\*\***       | 11 vCPU, 22 GB mem, 192 GB disk | 22 vCPU, 44 GB mem, 384 GB disk | 33 vCPU, 66 GB mem, 576 GB disk | 44 vCPU, 88 GB mem, 768 GB disk |

<!-- TODO: Validate "with Optimize" numbers against 8.9 benchmarks. The numbers above were measured with Camunda 8.8. Also confirm whether the "max throughput" boundary condition is defined as backpressure < 10% and p99 process duration < 1s, or another SLO. -->

:::note
The numbers in the tables were measured using Camunda 8 (version 8.8), [the benchmark project](https://github.com/camunda-community-hub/camunda-8-benchmark) running on its own Kubernetes cluster, and using a [realistic process](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/bankCustomerComplaintDisputeHandling.bpmn) with this [payload](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/reducedPayload.json) (~1.4 KB). To calculate day-based metrics, an equal distribution over 24 hours is assumed.
:::

**\*** Tasks (including service, send, and user tasks, among others) completed per day are the primary metric, as this is easy to measure and strongly influences resource consumption. This number assumes a constant load throughout the day. Tasks/day and Tasks/second are scaled linearly.

**\*\*** Because tasks are the primary resource driver, the number of process instances supported by a cluster is calculated assuming an average of 10 tasks per process. As a customers, you can calculate a more accurate process instance estimate using your anticipated number of tasks per process.

**\*\*\*** Maximum total number of historical process instances within the retention period.
For active process instances, this is limited mostly by Zeebe resources; for historical instances, it is limited mostly by Elasticsearch resources. Calculated assuming a typical set of process variables per process instance. Note that it makes a difference whether you add one or two strings (requiring ~1 KB of space) to your process instances or attach a full JSON document containing 1 MB, as this data must be stored in various places, influencing memory and disk requirements. If this number increases, you can still retain the runtime throughput, but Tasklist, Operate, and/or Optimize may lag behind.
The provisioned disk size is calculated as the sum of the disk size used by Zeebe and Elasticsearch.

**\*\*\*\*** These are the resource limits configured in the Kubernetes cluster and are subject to change.

## Data retention

The maximum throughput numbers should be considered peak loads, and the data retention configuration considered when defining the amount of data kept for completed instances in your cluster. See [Camunda 8 SaaS data retention](/components/saas/data-retention.md) for the default retention times for Zeebe, Tasklist, Operate, and Optimize.

- If process instances are completed and older than the configured retention time for an application, the data is removed.
- If a process instance is older than the configured retention time but still active and incomplete, it continues to function at runtime and is _not_ removed.

Camunda can adjust data retention on request (up to certain limits). Consider retention time adjustments and/or storage capacity increases if you plan to run more than \[max PI stored in ES\] / \[configured retention time\].

:::note Why is the total number of process instances stored that low?
This is related to the limited resources provided to Elasticsearch, which can cause performance problems when too much data is stored there. By increasing the available memory for Elasticsearch, you can also increase that number. At the same time, even with this rather low number, you can always guarantee the throughput of the core workflow engine during peak loads, as this performance is not affected. You can also increase memory for Elasticsearch later if needed.
:::

## Next steps

Validate your chosen configuration by [running your own benchmarks](sizing-benchmarks.md).

---

## Self-Managed resource planning

Provisioning Camunda 8 on your Self-Managed cluster depends on several factors. Use [Kubernetes with Helm](/self-managed/deployment/helm/index.md) to deploy and manage your Self-Managed cluster.

Use the configurations and guidance below as a baseline, then adjust based on your workload. For background on the factors that drive provisioning requirements, see [Size your environment](sizing-your-environment.md).

## Camunda 8.8+ resource consumption

Camunda 8.8 introduced a streamlined architecture that consolidates the broker, gateway, Operate, Tasklist, and Identity into a single application, the [Orchestration Cluster](/components/orchestration-cluster.md). This changes how you think about resource consumption compared to older versions.

If you are upgrading from a pre-8.8 version, expect different resource profiles:

- The Orchestration Cluster requires **more CPU per broker** compared to 8.7 (approximately 75% more CPU, for example, 2 to 3.5 cores, to maintain equivalent throughput).
- Throughput at the default 2 CPU cores drops ~35% compared to 8.7.x.
- With properly aligned resources (3.5 CPU cores), 8.8.x achieves similar throughput to 8.7.x with **significantly lower latency** (approximately a 2x improvement).
- The streamlined architecture reduces operational complexity (fewer pods to manage) but consolidates resource consumption into fewer, larger pods.

All components are clustered to provide high-availability, fault-tolerance, and resilience.

The Orchestration Cluster scales horizontally by adding more nodes (pods). This is limited by the [number of partitions](/components/zeebe/technical-concepts/partitions.md) configured for a cluster, as the work within one partition cannot be parallelized by design. Hence, you need to define enough partitions to utilize your hardware. The [number of partitions can be scaled up](/self-managed/components/orchestration-cluster/zeebe/operations/cluster-scaling.md) after the cluster is initially provisioned, but not yet scaled down.

Camunda 8 runs on Kubernetes. Every component runs as a pod with assigned resources. These resources can be scaled vertically (assigned more or fewer resources dynamically) within certain limits. Vertical scaling does not always increase throughput, since the components depend on each other.

:::note
Camunda licensing does not depend on the provisioned hardware resources, making it easy to size according to your needs.
:::

## Baseline performance

Considering this [baseline resource configuration](#baseline-resource-configuration), you can expect the following performance:

| Metric                                          | Value                                          |
| ----------------------------------------------- | ---------------------------------------------- |
| Completed process instances per second          | 51 (includes root and child process instances) |
| Completed flow node instances (FNIs) per second | 560                                            |
| Completed tasks per second                      | 100                                            |
| Data availability (query API latency)           | < 5 seconds                                    |

:::important
These numbers were measured using Camunda's [load test application](https://github.com/camunda/camunda/tree/main/load-tests/load-tester) with a [realistic reference process](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/bankCustomerComplaintDisputeHandling.bpmn) and [realistic payload](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/realisticPayload.json) (~11 KB). For details on the testing methodology, see the [reliability testing documentation](https://github.com/camunda/camunda/blob/main/docs/testing/reliability-testing.md).
:::

The realistic reference process starts one root process instance, which spawns 50 sub-process instances via call activities. It covers a wide variety of BPMN elements, including call activities, multi-instance, sub-processes, and DMN. The process is based on the [Credit Card Fraud Dispute Handling](https://marketplace.camunda.com/en-US/apps/449510/credit-card-fraud-dispute-handling) blueprint from the Camunda Marketplace.

## Baseline resource configuration

<Tabs groupId="optimize" defaultValue="with-optimize" values={
[
{ label: 'Without Optimize', value: 'without-optimize', },
{ label: 'With Optimize', value: 'with-optimize', },
]}>

<TabItem value="without-optimize">

The following configuration provides a baseline equivalent to a 1x SaaS cluster without Optimize enabled.

<!-- TODO: Validate these resource numbers against 8.9 benchmarks. The Orchestration Cluster CPU request of 3 cores reflects the 8.8 streamlined architecture. Confirm max throughput and max stored PI for this configuration. -->

| Component                 |                     | Request | Limit |
| ------------------------- | ------------------- | ------: | ----: |
| **Orchestration Cluster** |                     |         |       |
| Brokers                   | 3                   |         |       |
| Partitions                | 3                   |         |       |
| Replication factor        | 3                   |         |       |
|                           | vCPU \[cores\]      |       3 |     3 |
|                           | Memory \[GB\]       |       2 |     2 |
|                           | Disk \[GB\]         |         |   128 |
| **Connectors**            |                     |         |       |
| #                         | 1                   |         |       |
|                           | vCPU \[cores\]      |     0.2 |   0.2 |
|                           | Memory limit \[GB\] |   0.512 |     1 |
| **Elastic**               |                     |         |       |
| #statefulset              | 3                   |         |       |
|                           | vCPU \[cores\]      |       3 |     3 |
|                           | Memory limit \[GB\] |       2 |     2 |
|                           | Disk request \[GB\] |         |   128 |

</TabItem>

<TabItem value="with-optimize">

When Optimize is enabled, additional resources are needed, especially for Elasticsearch, because Optimize's importer reads from and writes to Elasticsearch indices. See [Impact of Optimize](sizing-your-environment.md#impact-of-optimize) for more details.

<!-- TODO: Validate these resource numbers against 8.9 benchmarks. These numbers are based on the Optimize V2 experiment (minimum ES resources for realistic workload at 1 PI/s with 101 tasks/s). -->

| Component                 |                     | Request | Limit |
| ------------------------- | ------------------- | ------: | ----: |
| **Orchestration Cluster** |                     |         |       |
| Brokers                   | 3                   |         |       |
| Partitions                | 3                   |         |       |
| Replication factor        | 3                   |         |       |
|                           | vCPU \[cores\]      |       3 |     3 |
|                           | Memory \[GB\]       |       2 |     2 |
|                           | Disk \[GB\]         |         |   128 |
| **Connectors**            |                     |         |       |
| #                         | 1                   |         |       |
|                           | vCPU \[cores\]      |     0.2 |   0.2 |
|                           | Memory limit \[GB\] |   0.512 |     1 |
| **Optimize**              |                     |         |       |
| #                         | 1                   |         |       |
|                           | vCPU \[cores\]      |     0.6 |     2 |
|                           | Memory limit \[GB\] |       1 |     2 |
| **Elastic**               |                     |         |       |
| #statefulset              | 3                   |         |       |
|                           | vCPU \[cores\]      |       7 |     7 |
|                           | Memory limit \[GB\] |       6 |     8 |
|                           | Disk request \[GB\] |         |   512 |

:::note
The numbers in the tables were measured using a [realistic process](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/bankCustomerComplaintDisputeHandling.bpmn) with a [realistic payload](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/realisticPayload.json) (~11 KB). To calculate day-based metrics, an equal distribution over 24 hours is assumed.
:::

</TabItem>

</Tabs>

## Scale your cluster

Once you have a baseline configuration running, you can scale in several ways:

### Horizontal scaling

Add more brokers and partitions to increase throughput capacity. Partitions can be [scaled up](/self-managed/components/orchestration-cluster/zeebe/operations/cluster-scaling.md) but not down, so avoid over-provisioning.

When scaling horizontally, **secondary storage often becomes the limiting factor**. Adding brokers increases export volume to Elasticsearch/OpenSearch, if secondary storage isn't scaled accordingly, it will bottleneck overall throughput. See [Elasticsearch scaling](#elasticsearch-scaling) for guidance.

### Vertical scaling

Increase CPU and memory per broker. Note that there are **diminishing returns** due to component interdependencies. For example, Elasticsearch indexing speed can bottleneck broker throughput).

### Elasticsearch scaling

- **Memory:** Increase Elasticsearch memory to store more historical data without performance degradation.
- **Nodes:** Add Elasticsearch statefulset replicas for more IOPS and query throughput.
- **Disk size:** Increase disk size based on your data retention requirements. With Optimize enabled and a realistic payload (~11 KB), Elasticsearch disk can fill rapidly (for example, 128 Gi in under 12 hours at 1 PI/s with 30-day retention).
- **Disk type:** Use SSDs for Elasticsearch storage. Disk latency, not throughput, is the critical factor. HDD-backed Elasticsearch has been observed to cause 8–10s flush durations, a growing export backlog, increased broker memory from in-flight records, and up to ~70% throughput degradation versus an equivalent SSD setup. See the [slow disk chaos day experiment](https://camunda.github.io/zeebe-chaos/2026/06/19/Using-slow-disk-with-Camunda) for details, and [Export pipeline](data-flow.md#export-pipeline) for background on how slow secondary storage affects overall throughput.
- **Index replicas:** The disk estimates in the baseline tables above do not account for index-level replicas. In multi-node clusters, configure at least one replica per index for fault tolerance — each replica stores a full copy of the primary shard data, approximately doubling total disk usage. See [managing replicas](/self-managed/concepts/secondary-storage/managing-secondary-storage.md#replicas).

## Primary storage considerations

Primary storage must use low-latency **SSDs**; HDD-backed volumes are not supported. Disk **latency** — not throughput — is the critical metric: cloud providers often report similar throughput figures for HDD and SSD volumes, but the latency difference is what matters for Camunda. In testing, HDD-backed primary storage degraded throughput by around 50% compared to SSDs, increased commit latencies, and triggered additional Raft snapshot replication between brokers.

See [Command processing path](data-flow.md#command-processing-path) for the architectural context on why disk latency sits on the critical path, the [reference architecture minimum cluster requirements](/self-managed/reference-architecture/kubernetes.md#minimum-cluster-requirements) for concrete per-platform disk recommendations, and the [slow disk chaos day experiment](https://camunda.github.io/zeebe-chaos/2026/06/19/Using-slow-disk-with-Camunda) for the detailed findings.

## Secondary storage considerations

The resource tables above assume Elasticsearch as the secondary storage backend. If you are using a different backend:

- **OpenSearch:** Similar resource profile to Elasticsearch. The tables above generally apply.
- **RDBMS (PostgreSQL, available from 8.9):** Replace the Elasticsearch resource block with appropriately sized PostgreSQL resources. Adjust throughput expectations **downward by approximately 30%** compared to the Elasticsearch-based tables. Unlike Elasticsearch, RDBMS scales primarily **vertically** (a larger instance) rather than horizontally, so plan your initial sizing with more headroom, as adding capacity later is more disruptive.

:::note
Optimize is not supported with RDBMS. If you need Optimize, you must also run Elasticsearch alongside your RDBMS.
:::

See [Secondary storage](sizing-your-environment.md#secondary-storage) for more details.

## Next steps

Validate your chosen configuration by [running your own benchmarks](sizing-benchmarks.md).

---

## Size your environment

Understand the aspects relevant to Camunda 8 sizing. Once you do, use the sizing recommendations for [SaaS](sizing-saas.md) or [Self-Managed](sizing-self-managed.md) to select your appropriate configuration.

:::tip Before you size
See [Data flow](data-flow.md) first to understand the factors that drive the recommendations on this page.
:::

<!-- Anchors for backward compatibility with old single-page URLs -->

## Sizing requirements and influencing factors

Consider the following aspects when planning and sizing Camunda SaaS or Self-Managed.

### Data availability latency

Data availability latency is the time between an event occurring in the engine and it being queryable in Operate, Tasklist, or Optimize. Under heavy load or with Optimize enabled, this can lag from seconds to minutes.

Data availability latency is influenced by:

- **Exporter throughput:** The rate at which the Camunda Exporter can write events to Elasticsearch (ES).
- **Elasticsearch indexing speed:** How quickly ES can index incoming documents.
- **Elasticsearch disk usage:** High disk utilization (above ~70%) significantly increases indexing latency. Monitor ES disk usage and scale storage before hitting this threshold.

### Disk space

The workflow engine stores data for each process instance, especially to persist the current state.
In addition, it sends data to secondary storage (Elasticsearch, OpenSearch, or an RDBMS) for indexing, search, analytics, and long-term retention.

You can configure retention times for data stored in secondary storage.

### Impact of Optimize

Optimize is an optional component that provides process analytics and reporting. When enabled, it has significant implications for sizing.

:::note
The data below comes from Camunda 8.9 load tests. Because 8.8 and 8.9 share the same exporter architecture, it applies to 8.8+ as well.
:::

#### In short

- Enabling Optimize roughly **triples to quadruples Elasticsearch CPU and disk usage** at a [realistic workload](./sizing-benchmarks.md#reference-benchmark-scenario) (around 3.4x CPU and 3.6x disk), largely independent of throughput.
- It lowers achievable **processing throughput by 25-50% at maximum load** on the same hardware.
- The single most effective mitigation is to **keep variables out of Optimize**. This recovers around 60% of the storage and 65% of the CPU, plus most of the lost throughput, at the cost of variable-based analytics.
- Size Elasticsearch/OpenSearch accordingly (CPU, disk, **and shard budget**), or run Optimize on a **dedicated Elasticsearch/OpenSearch instance**.

For how Optimize fits into the export pipeline, see [Optimize data flow](./data-flow.md#optimize-data-flow). The full studies behind these numbers are [Impact of Optimize on Camunda](https://camunda.github.io/zeebe-chaos/2026/06/10/Impact-of-Optimize-on-Camunda) and [Reducing Optimize's Elasticsearch overhead](https://camunda.github.io/zeebe-chaos/2026/06/25/Impact-of-Optimize-Variable-Filtering).

#### Why Optimize matters for sizing

- Optimize is a second-tier consumer of the export pipeline: the Elasticsearch/OpenSearch exporter writes raw engine events, Optimize's importer reads them and writes its own analytics indices back to Elasticsearch/OpenSearch, so data is written to secondary storage twice. See [Optimize data flow](./data-flow.md#optimize-data-flow).
- In Camunda 8.8+, the Camunda Exporter and the Elasticsearch exporter run in the same thread within the broker, so Optimize data-pipeline competes directly with core platform exporting for throughput.
- The overhead is **not proportional to throughput.** It scales with process model complexity (multi-instance and call activities) and variable volume. At a realistic workload where Optimize-enabled and Optimize-disabled clusters reached identical throughput with zero backpressure, the Optimize-enabled cluster still consumed **around 3.4x more Elasticsearch CPU.** Budget for this even at comfortable throughput.

#### What Optimize affects

At a [realistic workload](./sizing-benchmarks.md#reference-benchmark-scenario), with Optimize enabled vs. disabled:

- **Elasticsearch CPU:** around 3.4x higher.
- **Elasticsearch disk:** around 3.6x more total data.
- **Throughput:** unaffected at a realistic workload, but 25-50% lower at maximum load on the same hardware.
- **Write-to-exporting latency:** around 2.6x higher.
- **Backpressure at maximum load:** around 45% with Optimize vs. 35% without.
- **Individual import latency:** increases approximately linearly with payload size.
- **Report loading times:** increase approximately linearly with the data complexity (such as process instances and variables) and as historical data accumulates.

Secondary storage memory is not a meaningful differentiator for improving performance.

:::tip
**Watch Optimize import lag.** When Optimize's importer falls behind the export rate, two problems can appear:

- **Optimize's analytics indices grow.** Optimize keeps one document per process instance and can only apply retention-based cleanup once its importer has processed the instance's completion. While the importer lags, completions are recorded late, cleanup is deferred, and Optimize's own indices grow beyond their steady-state size.
- **Data can be missed.** The raw exporter indices are cleaned up on the Elasticsearch/OpenSearch retention schedule. If the importer falls far enough behind, those records are deleted before Optimize imports them, and that data never reaches Optimize. This Exporter-Importer hazard is exactly what the 8.8 Camunda Exporter architecture removed for Operate and Tasklist.

Track import progress with the [Optimize metrics and bundled Grafana dashboards](/self-managed/operational-guides/monitoring/metrics.md). If you see persistent import lag, raise the import throughput (see [mitigations](#mitigations) for details).
:::

#### Mitigations

##### Keep variables out of Optimize (highest impact, lowest risk)

Variables account for most of Optimize's storage and CPU usage in the secondary storage layer. In benchmarks, disabling Optimize's variable storage reduced its disk usage by a factor of **approximately 14** relative to the raw export. Isolating a group of customer-related variables showed an even larger difference, a factor of **approximately 29**, driven primarily by object variable flattening, described below, rather than by the variable values themselves. See [Optimize data flow](./data-flow.md#optimize-data-flow) for an explanation of the underlying storage mechanism.

Almost all of this cost comes from Optimize's indices. The following three levers are listed from most to least aggressive:

- **Stop exporting variables entirely.** Set `camunda.data.exporters.elasticsearch.args.index.variable: false` (OpenSearch: `camunda.data.exporters.opensearch.args.index.variable: false`) at the exporter to drop all variable records. This is the only lever that also recovers throughput because the exporter write path is the bottleneck at maximum load.
- **Export only the variables you need (name and prefix filters).** Keep a subset with name or prefix filters, for example only `customer`-prefixed variables. Use this when some variables drive Optimize reports, but most are noise. On SaaS, configure variable name filters in [cluster settings](/components/hub/organization/manage-clusters/settings.md#data-filters). On Self-Managed, see [Optimize export filtering](/self-managed/components/optimize/configuration/optimize-export-filtering.md).
- **[Disable variable import](/self-managed/components/optimize/configuration/variable-import.md) in Optimize.** Available on all supported versions; achieves the storage savings but does not recover throughput, because the records are still written by the exporter.

**Trade-off:** Filtered variables are unavailable in Optimize reports, including variable filters, variable-based grouping, and raw-data variable columns. These levers affect **Optimize only**; Operate and Tasklist read through the Camunda Exporter, so their variables stay intact.

##### Disable object variable flattening (high impact for object-heavy processes)

By default, Optimize [flattens each object variable](/self-managed/components/optimize/configuration/object-variables.md) into a separate variable for each property and stores the full raw object as another variable. Each generated variable incurs its own storage cost, so an object variable with several properties can require several times more storage than a single scalar variable.

If you don't rely on flattened object-variable filtering, grouping, or raw-data columns in Optimize reports, disable it by setting:

- Environment variable: `CAMUNDA_OPTIMIZE_ZEEBE_INCLUDE_OBJECT_VARIABLE=false`
- Configuration property: `zeebe.includeObjectVariableValue: false`

:::note
This behavior is enabled by default in Self-Managed and disabled in Camunda 8 SaaS.
:::

In an isolated benchmark that changed only this setting for the same workload:

- Optimize's share of total Elasticsearch disk usage dropped from 62.8% to 7.6%, a reduction by a factor of 8.3.
- Total secondary storage per created process instance dropped from 6.34 MB to 2.97 MB, a reduction by a factor of 2.13. This reduction was smaller because the setting does not affect Zeebe or Camunda Exporter storage.

See [Confirming Optimize's object variable flattening cost with a controlled A/B test](https://camunda.github.io/zeebe-chaos/2026/07/09/Optimize-Object-Variable-Flattening/) for the complete methodology and additional measurements.

:::warning
These ratios are specific to the benchmark's payload and process models; they are not universal constants. Object variable flattening processes nested JSON recursively without a depth limit, so payloads with deeper nesting or more object fields can require considerably more storage than measured here. Measure your workload before using these numbers for capacity planning.
:::

##### Other mitigations

- **Run Optimize on a separate Elasticsearch/OpenSearch instance.** Contention is bidirectional: Optimize's write spikes degrade Operate, Tasklist, and the Camunda Exporter, while heavy exporter activity degrades Optimize import. Isolation removes this mutual interference.
- **Tune retention periods.** Shorter retention means less data in Elasticsearch/OpenSearch and better performance.
- **Increase import throughput if Optimize lags.** If you notice a significant lag between the rate of exported Zeebe records and imported Optimize data, raise `CAMUNDA_OPTIMIZE_ZEEBE_MAX_IMPORT_PAGE_SIZE` so each import cycle fetches more exported records. This helps Optimize keep pace under high load, but increases memory use per fetch and can negatively impact individual record latency, as Optimize must wait to fill larger batches before processing.

#### Elasticsearch/OpenSearch shard budget

:::warning
Optimize creates a dedicated index per deployed process definition, each using at least one shard. Elasticsearch and OpenSearch cap the number of shards per node (1,000 by default), so a cluster's total shard budget is `nodes × per-node limit` (for example, 3,000 on a three-node cluster). A large or growing number of deployed process definitions consumes this budget and can approach the ceiling; small development or test clusters with few nodes reach it quickly. Once the ceiling is hit, new index creation is rejected, which cascades into exporter backpressure and stalled processing.

Account for shard budget when sizing the Elasticsearch/OpenSearch cluster, not just CPU, memory, and disk. See [impact of high process deployments on Elasticsearch](https://camunda.github.io/zeebe-chaos/2026/05/28/Impact-of-High-Process-Deployments-on-Elasticsearch).
:::

#### Zeebe record ILM retention

When the [Elasticsearch exporter retention policy](/self-managed/components/orchestration-cluster/zeebe/exporters/elasticsearch-exporter.md#retention) is enabled, Zeebe record indices are deleted after the configured `minimum-age`. Optimize reads from these same indices, so the retention window must be long enough to cover Optimize's worst-case import lag. If the exporter deletes records before Optimize imports them, process instance completion events are permanently lost: Optimize records the instance as `ACTIVE` with no `endDate`, and history cleanup can never remove it.

**Minimum recommended retention:** Set `minimum-age` to at least **3 days** when running Optimize; **7 or more days** is recommended. This provides headroom for:

- Import lag that grows as the Optimize process instance index grows larger.
- Recovery time after Elasticsearch cluster events such as node restarts, rolling upgrades, and shard rebalancing.

The default `minimum-age` of `30d` provides sufficient headroom. If you reduced it to limit disk usage, verify that the new value still exceeds your observed Optimize import lag before applying it to production.

**Disk sizing:** A longer ILM retention window means Zeebe record indices are kept on disk longer before deletion. Factor the additional raw exporter index volume into your Elasticsearch disk budget when increasing `minimum-age` beyond the default.

**Self-reinforcing failure mode:** As Optimize's process instance index grows, Elasticsearch write latency increases, which raises per-batch import lag. Higher import lag increases the probability of an ILM race on the next cluster event. This cycle compounds on long-lived clusters running at sustained load. To break it, increase ILM retention and reduce the Optimize index size through history cleanup or variable filtering.

**Symptom:** If Optimize history cleanup runs on schedule but consistently completes in zero seconds against a large dataset, orphaned `ACTIVE` documents are likely accumulating. See [diagnosing stalled cleanup](/self-managed/components/optimize/configuration/history-cleanup.md#diagnosing-stalled-cleanup).

The sizing guidance for [Self-Managed](./sizing-self-managed.md#baseline-resource-configuration) provides configurations with and without Optimize to help you plan accordingly.

### Latency and cycle time

In some use cases, process cycle time (or even individual task cycle time) matters. For example, you might expose a REST endpoint that starts a process instance to calculate a customer score. The process runs four service tasks, and the REST request must return synchronously within 250 ms.

While service-task duration depends on the work performed, you can measure the workflow engine’s own overhead.

<!-- TODO: Replace the following latency measurements with current 8.8/8.9 benchmark data. The old measurements (Camunda 8 1.2.4: ~10 ms/node, ~50 ms remote worker latency) are outdated. -->

:::note
The latency measurements below are approximate and were last validated against an earlier version of Camunda 8. Updated measurements for 8.8/8.9 are pending. With the 8.8 streamlined architecture and properly aligned resources (3.5 CPU cores per broker), latency is expected to improve by approximately 2x compared to the previous distributed deployment.

Actual latency is highly environment-dependent — factors like network latency between workers and the cluster, disk I/O speed (commit latency), and cloud region placement significantly affect these numbers.
:::

As a rough estimate, you can expect:

- Single-digit millisecond processing time per process node.
- Approximately 50 ms latency to process service tasks in remote workers when running worker code in the same cloud region as the Camunda cluster.

Hence, executing four service tasks results in roughly 200-250 ms workflow engine overhead.

As you push throughput toward the cluster’s limits, latency increases because requests compete for resources, especially disk writes. If cycle time and latency matter, leave enough headroom and avoid running the cluster near full utilization to prevent resource contention.

:::tip
A good rule of thumb is to size for about **20x your average load**. This gives you capacity for peaks and keeps latency low during normal operation.
:::

| Indicator                                                      |    Number | Calculation method | Notes                                                                                      |
| :------------------------------------------------------------- | --------: | :----------------: | :----------------------------------------------------------------------------------------- |
| Onboarding instances per year                                  | 5,000,000 |                    | Business input.                                                                            |
| Expected process instances on peak day                         |   150,000 |                    | Business input.                                                                            |
| Process instances per second within business hours on peak day |      5.20 |   / (8\*60\*60)    | Only looking at the seconds within the eight business hours of a day.                      |
| Process instances per second including buffer                  |    104.16 |       \* 20        | Adding some buffer is recommended for critical, high-performance or low-latency use cases. |

### Payload size

Each process instance can hold a payload, known as [process variables](/components/concepts/variables.md). The workflow engine must manage the variables for all running instances, and data from both running and completed process instances is forwarded to Operate and Tasklist.

Process variable size affects resource requirements. For example, there’s a big difference between storing a few strings (around 1 KB) and storing a full 1 MB JSON document. That’s why payload size is a key sizing factor.

Camunda's official benchmarks use two reference payloads:

- [**Typical payload**](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/typical_payload.json): Used for baseline measurements (~0.5 KB, 15 simple variables).
- [**Realistic payload**](https://github.com/camunda/camunda/blob/main/load-tests/load-tester/src/main/resources/bpmn/realistic/realisticPayload.json): Used for the reference sizing benchmarks. This better represents real-world payloads (~11 KB).

:::note
Payload size has a multiplicative effect, affecting Zeebe storage, Elasticsearch export volume, Optimize import time, and query/report performance. An 11 KB payload vs. a 0.5 KB payload can change disk consumption by **10-20x**.
:::

Consider these general rules for payload size:

- The maximum [variable size per process instance is limited](/components/concepts/variables.md#variable-size-limitation), currently to roughly three MB.
- Camunda does not recommend storing large amounts of data in your process context. Refer to our [best practices on handling data in processes](/components/best-practices/development/handling-data-in-processes.md) for more details.
- Each [partition](/components/zeebe/technical-concepts/partitions.md) of the Zeebe installation can typically handle up to one GB of payload in total. Larger payloads can lead to slower processing. For example,
  one million process instances with four KB each is about 3.9 GB, so you need at least four partitions. In practice, you’d typically use six partitions, since the number of partitions is usually a multiple of the replication factor (three by default).

### Peak loads

In most scenarios, your load will be volatile rather than constant. For example, your company might start 90% of its monthly process instances on a single day of the month. The **ability to handle those peaks is the more crucial requirement and should drive your decision**, rather than the average load.

In this example, that single peak day defines your overall throughput requirements.

In addition, sizing for peaks may mean you shouldn’t assume a full 24-hour day. Instead, you might size for just the eight business hours, or even the busiest two hours—depending on your workload.

### Secondary storage

Starting with Camunda 8.9, the platform supports three secondary storage backends, each with different sizing implications.

#### Elasticsearch (default)

- The **most mature and most benchmarked** option.
- Required if you use Optimize.
- Provides full-text search capabilities used by Operate and Tasklist.

:::important
Sizing data provided throughout this guide assumes Elasticsearch unless stated otherwise.
:::

#### OpenSearch

- A drop-in alternative to Elasticsearch with a similar resource profile.
- Supported for all components including Optimize. See [supported environments](/reference/supported-environments.md) for more details.
- Sizing recommendations for Elasticsearch generally apply to OpenSearch as well.

#### RDBMS

- A different storage paradigm: a relational database instead of a document store. See the full list of [supported databases](/self-managed/concepts/databases/relational-db/rdbms-support-policy.md#supported-rdbms).
- A different resource profile: CPU/memory-oriented rather than disk/IOPS-oriented.
- Write throughput is approximately **70% of Elasticsearch** on equivalent hardware.
- **No Optimize support**: If you need Optimize, you must run Elasticsearch alongside RDBMS.
- **Scales primarily vertically** rather than horizontally like Elasticsearch. Plan initial sizing with more headroom, as adding capacity is more disruptive.
- Ideal for organizations that already operate a supported RDBMS at scale and want to avoid adding Elasticsearch to their infrastructure.
  <!-- To be validated - Potentially lower total disk space required for the same data volume (preliminary benchmarks suggest this, but detailed results are still being validated). -->
  <!-- TODO: Link to RDBMS benchmark results page once PR #8159 is merged -->

### Throughput

Throughput defines how many process instances can be executed within a certain timeframe.

It is typically easy to estimate the number of process instances per day you need to execute.
However, hardware sizing depends more on the **number of BPMN tasks** in a process model. If you already know your future process model, you can use it to count the number of tasks in the process. For example, the following onboarding process contains five service tasks in a typical execution:

:::tip
If you don't yet know the number of service tasks, Camunda recommends assuming **10 service tasks** as a rule of thumb.
:::

The number of tasks per process allows you to calculate the number of tasks per day. You can also convert this to tasks per second. For example:

| Indicator                          |    Number | Calculation method | Notes                                        |
| :--------------------------------- | --------: | :----------------: | :------------------------------------------- |
| Onboarding instances per year      | 5,000,000 |                    | Business input.                              |
| Process instances per business day |    20,000 |       / 250        | Average number of working days in a year.    |
| Tasks per day                      |   100,000 |        \* 5        | Tasks in the process model as counted above. |
| Tasks per second                   |      1.16 |   / (24\*60\*60)   | Seconds per day.                             |

In most cases, Camunda defines throughput per day, as this time frame is easier to understand. However, in high-performance use cases, you might need to define the throughput per second.

## Plan non-production environments

All clusters can be used for development, testing, integration, Q&A, and production.

For typical integration or functional test environments, you can usually deploy a small cluster even if your production environment is sized larger. This is typically sufficient, as functional tests run much smaller workloads.

Load or performance tests should ideally run on the same sizing configuration as your production cluster to yield reliable results.

A typical customer setup consists of:

- A production cluster.
- An integration or pre-production cluster (equal in size to your anticipated production cluster if you want to run load tests or benchmarks).
- A test cluster.
- Development clusters.

## Next steps

Now that you understand the factors that influence sizing:

- **SaaS customers:** [Size your SaaS cluster](sizing-saas.md) to select the right cluster size.
- **Self-Managed admins:** Provision your Kubernetes cluster using these [baseline resource settings](sizing-self-managed.md).
- **Validate sizing:** [Run your own benchmarks](sizing-benchmarks.md) to test your specific workload.

For current secondary storage benchmarks, see [RDBMS benchmark results](/self-managed/concepts/secondary-storage/rdbms-benchmark-results.md).

---

## Understanding human task management

## Using task assignment features

The lifecycle of human task orchestration (like assigning, delegating, and completing tasks) is mostly a generic issue. There is no need to model common aspects into all your processes, if often makes models unreadable. Use Camunda task management features or implement your requirements in a generic way.

![Task assignment](understanding-human-tasks-management-assets/human-tasks.png)

So every task can be assigned to either a group of people, or a specific individual. An individual can 'claim' a task, indicating that they are picking the task from the pool (to avoid multiple people working on the same task).

As a general rule, you should assign human tasks, like [user tasks](/components/modeler/bpmn/user-tasks/user-tasks.md) or [manual tasks](/components/modeler/bpmn/manual-tasks/manual-tasks.md), in your business process to _groups of people_ instead of specific individuals.

```xml
<bpmn:userTask id="task_approve_vacation">
  <bpmn:extensionElements>
    <zeebe:assignmentDefinition candidateGroups="manager" />
  </bpmn:extensionElements>
```

Then, require individual members of that group to explicitly _claim tasks_ before working on them. This way, you avoid different people working on the same task at the same time. Refer to [`assign`](/apis-tools/orchestration-cluster-api-rest/specifications/assign-user-task.api.mdx).

You can also directly claim tasks in Camunda Tasklist with the click of a button.

![Claim](understanding-human-tasks-management-assets/claim.png)

While assigning users to groups is advised, it's not the only option. You could always assign a task to a _single person_ who is supposed to complete the task (e.g. the individual 'customer' of your process or a coworker having specific knowledge for the case). You will need to have access to the specific person relevant for your process instance, e.g. via a process variable:

```xml
<bpmn:userTask id="task_approve_vacation">
  <bpmn:extensionElements>
    <zeebe:assignmentDefinition assignee="=assistant_username" />
  </bpmn:extensionElements>
```

## Deciding about your task list frontend

If you are orchestrating human tasks in your process, you must make up your mind on how exactly you want to let your users work on their tasks and interact with the workflow engine. You have basically three options:

- [Camunda Tasklist](/components/tasklist/introduction-to-tasklist.md): The Tasklist application shipped with Camunda. This works out-of-the-box and has a low development effort. However, it is limited in terms of customizability and how much you can influence the user experience.

- Custom task list application: You can develop a custom task list and adapt this to your needs without compromises. User tasks are shown inside your custom application, following your style guide and usability concept. You will use the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) in the background. This is very flexible, but requires additional development work.

- Third party tasklist: If our organization already has a task list application rolled out to the field, you might want to use this for tasks created by Camunda. You will need to develop some synchronization mechanism. The upside of this approach is that your end users might not even notice that you introduce a new workflow engine.

### Considerations for developing custom task lists

When building a custom tasklist/application, you must plan for the following aspects. You will need to

- _Query_ for user tasks and _generate lists_ of those tasks.
- _Filter the list_ along specific attributes like current assignee, candidate groups, etc.
- _Select_ and _display_ the right forms for starting processes and completing tasks.
- Use _custom/business value_ data in order to _filter_ with those values and _display_ them correlated with the task list and within forms.
- _Authorize_ users to access those lists, filters, and forms.

### Considerations for using third party task lists

When integrating a third party tasklist, you must plan for the following aspects. You will need to take care of:

- _Creating_ tasks in the third party tasklist based on the user tasks created by Camunda.
- _Completing_ tasks in Camunda and move on process execution based on user action in the third party tasklist.
- _Cancelling_ tasks, triggered by Camunda or triggered by the user in the third-party tasklist.
- Transferring _business data_ to be edited in the third-party tasklist back and forth.

Your third party tasklist application also needs to allow for some programmatic control of the lifecycle of its tasks. The third-party application _must have_ the ability:

- To programmatically _create_ a new task.
- To _hook in code_ which programmatically informs other systems that the user is about to change a task's state.
- To _manage custom attributes_ connected to a task and programmatically access them.

Additionally, it _should have_ the ability

- To programmatically _delete_ a task which was cancelled in Camunda. Without this possibility such tasks remain in the users tasklist and would need to be removed manually. Depending on the way you integrate the task completion mechanism, when the user tries to complete such tasks, they would immediately observe an error or the action would just not matter anymore and serve as a removal from the list.

Transfer just the minimal amount of business data in between Camunda and your third-party tasklist application.

For creating tasks, transfer just the taskId and important business data references/ids to your domain objects. As much as possible should be retrieved later, and just when needed (e.g. when displaying task forms to the user) by requesting data from the process engine or by requesting data directly from other systems.

For completing tasks, transfer just the business data which originated from Camunda and was changed by the user. This means, in case you just maintain references, nothing needs to be transferred back. All other business data changed by the user will be directly transferred to the affected systems.

### Task lists may not look like task lists

There are situations where you might want to show a user interface that does not look like a task list, even if it is fed by tasks. The following _example_ shows such a situation in the document _input management_ process of a company. Every document is handled by a separate process instance, but users typically look at complete mailings consisting of several such documents. In a customer scenario, there were people in charge of assessing the scanned mailing and distributing the individual documents to the responsible departments. It was important to do that in one step, as sometimes documents referred to each other.

So you have several user tasks which are heavily _interdependent_ from a business point of view and should therefore be completed _in one step_ by the same person.

The solution to this was a custom user interface that basically queries for human tasks, but show them grouped by mailings:

![custom tasklist mockup](understanding-human-tasks-management-assets/tasklist-mockup.png)

1

The custom tasklist shows each mailing as one "distribution task", even though they consist of several human tasks fetched from the workflow instance.

2

The custom user interface allows you to work on all four human tasks at once. By dragging and dropping a document within the tree, the user can choose to which department the document is delivered to.

3

In case the user detects a scanning problem, they can request a new scan of the mailing. But as soon
as all documents are quality assured, the button **Distribute Mailing** gets enabled. By clicking on it, the system completes all four human tasks - one for each document - which moves forward the four process instances associated with the documents.

---

## Best Practices

The Camunda Best Practices distill our experience with BPMN and DMN on the Camunda toolstack, incorporating insights from consulting, community feedback, and various interactions. They offer a blend of conceptual and practical guidance, representing our current practical project experience in a generalized context. While not definitive, these practices acknowledge that learning is ongoing and effectiveness may vary based on your specific situation.

Please note that, like the core product, Camunda extends the same guarantee to Best Practices. However, we cannot ensure the absolute accuracy or timeliness of the information provided, and any liability for damages resulting from the application of these recommendations is disclaimed.

## Project management Best Practices

<DocCardList items={[{type:"link", href:"/docs/next/components/best-practices/management/following-the-customer-success-path/", label: "The Customer Success Path", docId:"components/best-practices/management/following-the-customer-success-path"},
{
type:"link", href:"/docs/next/components/best-practices/management/doing-a-proper-poc/", label: "Proper POC Execution", docId:"components/best-practices/management/doing-a-proper-poc"
}
]}/>

## Architecture Best Practices

<DocCardList items={[{type:"link", href:"/docs/next/components/best-practices/architecture/deciding-about-your-stack/", label: "Choosing Your Tech Stack", docId:"components/best-practices/architecture/deciding-about-your-stack"},
{
type:"link", href:"/docs/next/components/best-practices/architecture/sizing-your-environment/", label: "Environment Sizing", docId:"components/best-practices/architecture/sizing-your-environment",
},
{
type:"link", href:"/docs/next/components/best-practices/architecture/understanding-human-tasks-management/", label: "Human Task Management", docId:"components/best-practices/architecture/understanding-human-tasks-management"
}
]}/>

## Development Best Practices

<DocCardList items={[{type:"link", href:"/docs/next/components/best-practices/development/connecting-the-workflow-engine-with-your-world/", label: "Workflow Engine Integration", docId:"components/best-practices/development/connecting-the-workflow-engine-with-your-world"},
{
type:"link", href:"/docs/next/components/best-practices/development/service-integration-patterns/", label: "Service Integration Patterns", docId:"components/best-practices/development/service-integration-patterns",
},
{
type:"link", href:"/docs/next/components/best-practices/development/writing-good-workers/", label: "Writing Effective Workers", docId:"components/best-practices/development/writing-good-workers",
},
{
type:"link", href:"/docs/next/components/best-practices/development/dealing-with-problems-and-exceptions/", label: "Problems and Exceptions", docId:"components/best-practices/development/dealing-with-problems-and-exceptions",
},
{
type:"link", href:"/docs/next/components/best-practices/development/handling-data-in-processes/", label: "Data Handling in Processes", docId:"components/best-practices/development/handling-data-in-processes",
},
{
type:"link", href:"/docs/next/components/best-practices/development/routing-events-to-processes/", label: "Routing Events to Processes", docId:"components/best-practices/development/routing-events-to-processes",
},
{
type:"link", href:"/docs/next/components/best-practices/development/testing-process-definitions/", label: "Testing Process Definitions", docId:"components/best-practices/development/testing-process-definitions"
},
{
type:"link", href:"/docs/next/components/best-practices/development/local-development-with-element-templates/", label: "Local development with element templates and Camunda 8 Run", docId:"components/best-practices/development/local-development-with-element-templates"
}
]}/>

## Modeling Best Practices

<DocCardList items={[{type:"link", href:"/docs/next/components/best-practices/modeling/creating-readable-process-models/", label: "Readable Process Models", docId:"components/best-practices/modeling/creating-readable-process-models"},
{
type:"link", href:"/docs/next/components/best-practices/modeling/naming-bpmn-elements/", label: "Naming BPMN Elements", docId:"components/best-practices/modeling/naming-bpmn-elements",
},
{
type:"link", href:"/docs/next/components/best-practices/modeling/naming-technically-relevant-ids/", label: "Technically Relevant IDs", docId:"components/best-practices/modeling/naming-technically-relevant-ids",
},
{
type:"link", href:"/docs/next/components/best-practices/modeling/modeling-beyond-the-happy-path/", label: "Model Beyond the Happy Path", docId:"components/best-practices/modeling/modeling-beyond-the-happy-path",
},
{
type:"link", href:"/docs/next/components/best-practices/modeling/modeling-with-situation-patterns/", label: "Situation Patterns", docId:"components/best-practices/modeling/modeling-with-situation-patterns",
},
{
type:"link", href:"/docs/next/components/best-practices/modeling/building-flexibility-into-bpmn-models/", label: "Building Flexibility in BPMN", docId:"components/best-practices/modeling/building-flexibility-into-bpmn-models",
},
{
type:"link", href:"/docs/next/components/best-practices/modeling/choosing-the-dmn-hit-policy/", label: "Choosing DMN Hit Policy", docId:"components/best-practices/modeling/choosing-the-dmn-hit-policy"
}
]}/>

## Operations Best Practices

<DocCardList items={[{type:"link", href:"/docs/next/components/best-practices/operations/versioning-process-definitions/", label: "Versioning Process Definitions", docId:"components/best-practices/operations/versioning-process-definitions"},
{
type:"link", href:"/docs/next/components/best-practices/operations/reporting-about-processes/", label: "Process Reporting", docId:"components/best-practices/operations/reporting-about-processes"
}
]}/>

---

## Element templates at scale

To effectively manage large libraries of reusable building blocks ([element templates](/components/concepts/element-templates.md)), you can create a pipeline that:

- Provisions the [dependencies of element templates](/components/modeler/element-templates/element-template-with-dependencies.md) to required clusters.
- Makes templates available at design time to multiple [workspaces](/components/hub/workspace/modeler/collaboration/use-shared-project-for-organization-wide-collaboration.md) within an organization.

<!--- source: https://www.figma.com/design/VyyoV0hNbazXV8DKcMMEU9/Camunda-Documentation-Assets?node-id=2078-301&t=YNT70ktAMXBBupbJ-1 --->

![Pipeline goal](./img/pipeline-goal.png)

This guide covers conceptually what your pipeline needs to do, from obtaining credentials to runtime provisioning and template syncing.

## Prerequisites

Before building your pipeline, ensure you have the following:

| Prerequisite                                                                                                                           | Purpose                                                                                                                                                                                                                                                         |
| -------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Git Repository](https://en.wikipedia.org/wiki/Git)                                                                                    | Store all element templates                                                                                                                                                                                                                                     |
| Template state management                                                                                                              | Maintain an authoritative inventory (for example, via Git or an IaC tool like Terraform) that defines which templates are applied to each cluster and which workspaces depend on them. This source acts as the single source of truth for template deployments. |
| Camunda Hub API token ([SaaS](/apis-tools/hub-api-saas/authentication.md) or [Self-Managed](/apis-tools/hub-api-sm/authentication.md)) | Access Camunda Hub programmatically                                                                                                                                                                                                                             |
| [Orchestration Cluster API client](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-authentication.md)        | Provision dependencies to clusters                                                                                                                                                                                                                              |

For simplicity, this guide assumes:

- One organization
- One cluster
- One [workspace](/components/hub/workspace/modeler/collaboration/use-shared-project-for-organization-wide-collaboration.md)
- A pipeline handling runtime provisioning and template syncing

## Runtime provisioning

### Secrets

You can use sensitive information in your element templates without exposing it in your BPMN processes by referencing secrets.

These guides show you how to configure them depending on the environment you are using:

- **SaaS**: Use the [Administration API](/apis-tools/administration-api/administration-api-reference.md) or [Camunda Hub UI](/components/hub/organization/manage-clusters/manage-secrets.md) to configure secrets.
- **Self-Managed/local development**: Configure secrets outside the pipeline. See [connector secrets](/self-managed/components/connectors/connectors-configuration.md#secrets).

### Job Workers

As part of the pipeline, you may spin up a service that will connect to a Camunda cluster to perform specific tasks. For example, you can use the [Spring Boot Camunda Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md) to start a job worker.

Recommended resources:

- [Outbound connectors vs. job workers](/components/concepts/outbound-connectors-job-workers.md)
- [Host custom connectors](/components/connectors/custom-built-connectors/host-custom-connector.md)

### Other dependencies

The following dependency types are provisioned at runtime using the [Orchestration Cluster API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md):

| Dependency                                                            | Purpose                     |
| --------------------------------------------------------------------- | --------------------------- |
| [Camunda forms](/components/modeler/forms/camunda-forms-reference.md) | Used in user tasks          |
| [RPA scripts](/components/rpa/overview.md)                            | Used in service tasks       |
| [BPMN processes](/components/modeler/bpmn/bpmn.md)                    | Used in call activities     |
| [DMN decisions](/components/modeler/dmn/dmn.md)                       | Used in business rule tasks |

To deploy dependencies, send a [POST request](/apis-tools/orchestration-cluster-api-rest/specifications/create-deployment.api.mdx) with the files. This works for SaaS, Self-Managed, and local development.

For example:

```bash
curl -L 'http://localhost:8080/v2/deployments' \
-H 'Accept: application/json' \
-F resources=@/path/to/your/form/user-signup.form
```

You will get a response containing the details of the deployed elements:

```json
{
  "deployments": [
    {
      "form": {
        "formKey": "KEY_OF_THE_FORM",
        "formId": "user-signup",
        "version": 1,
        "resourceName": "user-signup.form",
        "tenantId": "<default>"
      }
    }
  ],
  "deploymentKey": "KEY_OF_THE_DEPLOYMENT",
  "tenantId": "<default>"
}
```

When referencing a dependency such as a form, Camunda recommends using a `versionTag` as your [binding type](/components/best-practices/modeling/choosing-the-resource-binding-type.md#supported-binding-types). This option ensures the right version of the target resource is always used.

## Make templates available in Camunda Hub

Make templates available in Camunda Hub with the Camunda Hub API ([SaaS](/apis-tools/hub-api-saas/overview.md) or [Self-Managed](/apis-tools/hub-api-sm/overview.md)).

### Get the workspace key

Search for your workspace to get the `workspaceKey`:

```bash
POST /api/v2/workspaces/search
{
    "filter": {
        "name": "(WORKSPACE NAME)"
    }
}
```

You'll use the `workspaceKey` to filter projects to the target workspace.

### Get projects

With the `workspaceKey`, retrieve the projects that belong to the workspace:

```bash
GET /api/v2/workspaces/(WORKSPACE KEY)
```

Under `content`, get the `projectKey` for the project you want to update.

### Get file metadata

With the `projectKey`, retrieve a list of files and metadata:

```bash
GET /api/v2/projects/(PROJECT KEY)
```

Using `content`, compare the files in Camunda Hub to the files in your repository.

### Create or update files

For each file in your repository that doesn't match the content in Camunda Hub, [create](/apis-tools/hub-api-saas/specifications/create-file.api.mdx) or [update](/apis-tools/hub-api-saas/specifications/update-file.api.mdx) the appropriate file resource.

### Create new file versions

If desired, [create a new file version](https://modeler.camunda.io/swagger-ui/index.html#/Versions) for each of the affected files:

```bash
POST /api/v2/versions
{
  "fileKey": "(FILE KEY)",
  "name": "(VERSION NAME)"
}
```

## Making templates available in Desktop Modeler

To set up your local environment:

- Access the VCS repository containing the templates.
- Choose how to [configure them](/components/modeler/desktop-modeler/element-templates/configuring-templates.md) depending on your needs. If your templates are reused across multiple projects, configuring them globally will make it easier to maintain. For project-specific templates, consider making them available only for that project to avoid exposing templates to projects that should not be using them.

:::note
If you are the template creator/maintainer, include a `README` file in your repository that lists the requirements for using your templates -- for example, which dependencies need to be provisioned in advance.
:::

## Next steps

Refer to [integrate Camunda Hub in CI/CD](/components/hub/workspace/modeler/integrate-modeler-in-ci-cd.md) for additional CI/CD-related guidance.

---

## Connecting the workflow engine with your world

One of your first tasks to build a process solution is to sketch the basic architecture of your solution. To do so, you need to answer the question of how to connect the workflow engine (Zeebe) with your application or with remote systems.

The workflow engine is a remote system for your applications, just like a database. Your application connects with Zeebe via remote protocols (like [gRPC](https://grpc.io/) or REST), which is typically hidden from you, like when using a database driver based on ODBC or JDBC.

With Camunda 8 and the Zeebe workflow engine, there are two basic options:

1. Write some **programming code** that typically leverages the client library for the programming language of your choice.
2. Use some **existing connector** which just needs a configuration.

The trade-offs will be discussed later; let’s look at the two options first.

## Programming glue code

To write code that connects to Zeebe, you typically embed [the Zeebe client library](../../../apis-tools/working-with-apis-tools.md) into your application. An application can of course also be a service or microservice.

If you have multiple applications that connect to Zeebe, all of them will require the client library. If you want to use a programming language where no such client library exists, you can [generate a gRPC client yourself](https://camunda.com/blog/2018/11/grpc-generating-a-zeebe-python-client/).

![Clients to Zeebe](connecting-the-workflow-engine-with-your-world-assets/clients.png)

Your application can basically do two things with the client:

1. **Actively call Zeebe**, for example, to start process instances, correlate messages, or deploy process definitions.
2. **Subscribe to tasks** created in the workflow engine in the context of BPMN service tasks.

### Calling Zeebe

Using the Zeebe client’s API, you can communicate with the workflow engine. The two most important API calls are to start new process instances and to correlate messages to a process instance.

**Start process instances using the** [**Java Client**](../../../apis-tools/java-client/getting-started.md)**:**

```java
processInstance = zeebeClient.newCreateInstanceCommand()
  .bpmnProcessId("someProcess").latestVersion()
  .variables( someProcessVariablesAsMap )
  .send()
  .exceptionally( throwable -> { throw new RuntimeException("Could not create new instance", throwable); });
```

<!-- **Start process instances using the** **Node.js client****:**

```js
const processInstance = await zbc.createWorkflowInstance({
  bpmnProcessId: "someProcess",
  version: 5,
  variables: {
    testData: "something",
  },
});
``` -->

**Correlate messages to process instances using the Java Client**:

```java
zeebeClient.newPublishMessageCommand() //
  .messageName("messageA")
  .messageId(uniqueMessageIdForDeduplication)
  .correlationKey(message.getCorrelationid())
  .variables(singletonMap("paymentInfo", "YeahWeCouldAddSomething"))
  .send()
  .exceptionally( throwable -> { throw new RuntimeException("Could not publish message " + message, throwable); });
```

**Correlate messages to process instances using the Node.js client**:

```js
zbc.publishMessage({
  name: "messageA",
  messageId: messageId,
  correlationKey: correlationId,
  variables: {
    valueToAddToWorkflowVariables: "here",
    status: "PROCESSED",
  },
  timeToLive: Duration.seconds.of(10),
});
```

This allows you to connect Zeebe with any external system by writing some custom glue code. We will look at common technology examples to illustrate this in a minute.

### Subscribing to tasks using a job worker

To implement service tasks of a process model, you can write code that subscribes to the workflow engine. In essence, you will write some glue code that is called whenever a service task is reached (which internally creates a job, hence the name).

**Glue code in Java:**

```java
class ExampleJobHandler implements JobHandler {
  public void handle(final JobClient client, final ActivatedJob job) {
    // here: business logic that is executed with every job
    client.newCompleteCommand(job.getKey()).send()
      .exceptionally( throwable -> { throw new RuntimeException("Could not complete job " + job, throwable); });;
  }
}
```

**Glue code in Node.js:**

```js
function handler(job, complete, worker) {
  // here: business logic that is executed with every job
  complete.success();
}
```

Now, this handler needs to be connected to Zeebe, which is generally done by subscriptions, which internally use long polling to retrieve jobs.

**Open subscription via the Zeebe Java client:**

```java
zeebeClient
  .newWorker()
  .jobType("serviceA")
  .handler(new ExampleJobHandler())
  .timeout(Duration.ofSeconds(10))
  .open()) {waitUntilSystemInput("exit");}
```

**Open subscription via the Zeebe Node.js client:**

```js
zbc.createWorker({
  taskType: "serviceA",
  taskHandler: handler,
});
```

You can also use integrations in certain programming frameworks, like the [Camunda Spring Boot Starter](../../../apis-tools/camunda-spring-boot-starter/getting-started.md) in the Java world, which starts the job worker and implements the subscription automatically in the background for your glue code.

**A subscription for your glue code is opened automatically by the Spring integration:**

```java
@JobWorker(type = "serviceA")
public void handleJobFoo(final JobClient client, final ActivatedJob job) {
  // here: business logic that is executed with every job
  // you do not need to call "complete" on the job, as autoComplete is turned on above
}
```

There is also documentation on [how to write a good job worker](../writing-good-workers/).

## Technology examples

Most projects want to connect to specific technologies. Currently, most people ask for REST, messaging, or Kafka.

REST and messaging are common core integration patterns. Kafka is different: it is optional infrastructure that you would typically introduce for event streaming or broader event-driven architectures, not because Zeebe requires it to execute workflows.

### REST

You could build a piece of code that provides a REST endpoint in the language of choice and then starts a process instance.

The [Ticket Booking Example](https://github.com/berndruecker/ticket-booking-camunda-cloud) contains an example using Java and Spring Boot for the [REST endpoint](https://github.com/berndruecker/ticket-booking-camunda-cloud/blob/master/booking-service-java/src/main/java/io/berndruecker/ticketbooking/rest/TicketBookingRestController.java#L35).

Similarly, you can leverage the [Spring Boot extension](https://github.com/zeebe-io/spring-zeebe/) to startup job workers that will [execute outgoing REST calls](https://github.com/berndruecker/ticket-booking-camunda-cloud/blob/master/booking-service-java/src/main/java/io/berndruecker/ticketbooking/adapter/GenerateTicketAdapter.java#L29).

![REST example](connecting-the-workflow-engine-with-your-world-assets/rest-example.png)

You can find [Spring Boot sample code for the REST endpoint](https://github.com/berndruecker/flowing-retail/blob/master/zeebe/java/checkout/src/main/java/io/flowing/retail/checkout/rest/ShopRestController.java) in the [Flowing Retail example](https://github.com/berndruecker/flowing-retail).

### Messaging

You can do the same for messages, which is often [AMQP](https://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol) nowadays.

The [Ticket Booking Example](https://github.com/berndruecker/ticket-booking-camunda-cloud) contains an example for RabbitMQ, Java, and Spring Boot. It provides a message listener to correlate incoming messages with waiting process instances, and [glue code to send outgoing messages onto the message broker](https://github.com/berndruecker/ticket-booking-camunda-cloud/blob/master/booking-service-java/src/main/java/io/berndruecker/ticketbooking/adapter/RetrievePaymentAdapter.java).

![Messaging example](connecting-the-workflow-engine-with-your-world-assets/messaging-example.png)

[Service integration patterns](../service-integration-patterns/) goes into details of if you want to use a send and receive task here, or prefer simply one service task (spoiler alert: send and receive tasks are used here because the payment service might be long-running; think about expired credit cards that need to be updated or wire transfers that need to happen).

<!-- The same concept will apply to other programming languages. For example, you could use the [Node.js client for RabbitMQ](https://www.rabbitmq.com/tutorials/tutorial-one-javascript.html) and the [Node.js client for Zeebe](https://github.com/camunda-community-hub/zeebe-client-node-js) to create the same type of glue code as shown above. -->

### Apache Kafka

Kafka is not required for Camunda 8 or Zeebe to work. Zeebe executes workflows itself, while Kafka can optionally be used as an event backbone around the workflow engine.

Typical Kafka-based patterns are:

- **Kafka to Zeebe**: Consume records from a Kafka topic and translate them into Zeebe API calls, such as starting a process instance or correlating a message.
- **Zeebe to Kafka**: When a workflow reaches a service task or other integration point, write a record to Kafka so downstream systems can react asynchronously.

You can implement these patterns with custom glue code. The [Flowing Retail example](https://github.com/berndruecker/flowing-retail) shows this using Java, Spring Boot, and Spring Cloud Streams. There is [code to subscribe to a Kafka topic and start new process instances for new records](https://github.com/berndruecker/flowing-retail/blob/master/kafka/java/order-zeebe/src/main/java/io/flowing/retail/kafka/order/messages/MessageListener.java#L39), and there is some glue code to create new records when a process instance executes a service task. Of course, you could also use other frameworks to achieve the same result.

This means Kafka is a good fit if you already use Kafka, need loose coupling, or want to broadcast workflow-related events to multiple consumers. If you simply need to call a remote system from a workflow, a job worker or connector is often the more direct option.

![Kafka Example](connecting-the-workflow-engine-with-your-world-assets/kafka-example.png)

## Designing process solutions containing all glue code

Typical applications will include multiple pieces of glue code in one codebase.

![Architecture with glue code](connecting-the-workflow-engine-with-your-world-assets/architecture.png)

For example, the onboarding microservice shown in the figure above includes:

- A REST endpoint that starts a process instance (1)
- The process definition itself (2), probably auto-deployed to the workflow engine during the startup of the application.
- Glue code subscribing to the two service tasks that shall call a remote REST API (3) and (4).

A job worker will be started automatically as part of the application to handle the subscriptions. In this example, the application is written in Java, but again, it could be [any supported programming language](/apis-tools/working-with-apis-tools.md).

As discussed in [writing good workers](../writing-good-workers/), you typically will bundle all workers within one process solution, but there are exceptions where it makes sense to have single workers as separate application.

## Connectors

The glue code is relatively simple, but you need to write code. You might prefer using an out-of-the-box component, connecting Zeebe with the technology you need just by configuration. This component is called a **Connector**.

A connector can be uni or bidirectional and is typically one dedicated application that implements the connection that translates in one or both directions of communication. Such a connector might also be helpful in case integrations are not that simple anymore.

![Connectors](connecting-the-workflow-engine-with-your-world-assets/connector.png)

For example, the [HTTP connector](https://github.com/camunda-community-hub/zeebe-http-worker) is a one-way connector that contains a job worker that can process service tasks doing HTTP calls as visualized in the example in the following figure:

![REST connectors](connecting-the-workflow-engine-with-your-world-assets/rest-connector.png)

Another example is the [Kafka connector](https://github.com/camunda-community-hub/kafka-connect-zeebe), as illustrated below.

![Kafka connector](connecting-the-workflow-engine-with-your-world-assets/kafka-connector.png)

This is a bidirectional connector which contains a Kafka listener for forwarding Kafka records to Zeebe and also a job worker which creates Kafka records every time a service task is executed. In other words, the connector helps Kafka exchange events with Zeebe; it does not replace Zeebe's own workflow execution or state handling. This is illustrated by the following example:

![Kafka connector Details](connecting-the-workflow-engine-with-your-world-assets/kafka-connector-details.png)

### Out-of-the-box connectors

As well as Camunda-maintained connectors, additional connectors are maintained by the community (made up of consultants, partners, customers, and enthusiastic individuals). You can find a list of connectors in the [Camunda Marketplace](https://marketplace.camunda.com/).

### Reusing your own integration logic by extracting connectors

If you need to integrate with certain infrastructure regularly, for example your CRM system, you might also want to create your own CRM connector, run it centralized, and reuse it in various applications.

In general, we recommend not to start such connectors too early. Don’t forget that such a connector gets hard to adjust once in production and reused across multiple applications. Also, it is often much harder to extract all configuration parameters correctly and fill them from within the process, than it would be to have bespoke glue code in the programming language of your choice.

Therefore, only extract a full-blown connector if you understand exactly what you need.

Don’t forget about the possibility to extract common glue code in a simple library that is then used at different places.

:::note
Updating a library that is used in various other applications can be harder than updating one central connector. In this case, the best approach depends on your scenario.
:::

Whenever you have such glue code running and really understand the implications of making it a connector, as well as the value it will bring, it can make a lot of sense.

## Recommendation

As a general rule of thumb, prefer custom glue code whenever you don’t have a good reason to go with an existing connector.

A good reason to use connectors is if you need to solve complex integrations where little customization is needed, such as the [Camunda RPA bridge](https://docs.camunda.org/manual/latest/user-guide/camunda-bpm-rpa-bridge/) to connect RPA bots (soon to be available for Camunda 8).

Good use of connectors are also scenarios where you don’t need custom glue code. For example, when orchestrating serverless functions on AWS with the [AWS Lambda connector](https://github.com/camunda-community-hub/zeebe-lambda-worker). This connector can be operated once and used in different processes.

Some use cases also allow you to create a **reusable generic adapter**; for example, to send status events to your business intelligence system.

But there are also common downsides with connectors. First, the possibilities are limited to what the creator of the connector has foreseen. In reality, you might have slightly different requirements and hit a limitation of a connector.

Second, the connector requires you to operate this connector in addition to your own application. The complexity associated with this depends on your environment.

Third, testing your glue code gets harder, as you can’t easily hook in mocks into such a connector as you could in your own glue code.

---

## Dealing with problems and exceptions

## Understanding workers

:::caution Camunda 8 only
The description of workers targets Camunda 8, even if [external tasks in Camunda 7](https://docs.camunda.org/manual/latest/user-guide/process-engine/external-tasks/) are conceptually similar.
:::

First, let's briefly examine how a worker operates.

Whenever a process instance arrives at a service task, a new job is created and pushed to an internal persistent queue within Camunda 8. A client application can subscribe to these jobs with the workflow engine by the task type name (which is comparable to a queue name).

If there is no worker subscribed when a job is created, the job is simply put in a queue. If multiple workers are subscribed, they are competing consumers, and jobs are distributed among them.

![Worker concept](dealing-with-problems-and-exceptions-assets/worker-concept.png)

Whenever the worker has finished whatever it needs to do (like invoking the REST endpoint), it sends another call to the workflow engine, which [can be one of these three](/components/concepts/job-workers.md#completing-or-failing-jobs):

- [`CompleteJob`](/apis-tools/zeebe-api/gateway-service.md#completejob-rpc): The service task went well, the process instance can move on.
- [`FailJob `](/apis-tools/zeebe-api/gateway-service.md#failjob-rpc): The service task failed, and the workflow engine should handle this failure. There are two possibilities:
  - `remaining retries > 0`: The job is retried.
  - `remaining retries <= 0`: An [incident](/components/concepts/incidents.md) is raised and the job is not retried until the incident is resolved.
- [`ThrowError`](/apis-tools/zeebe-api/gateway-service.md#throwerror-rpc): A BPMN error is reported, which typically is handled on the BPMN level.

As the glue code in the worker is external to the workflow engine, there is **no technical transaction spanning both components**. Technical transactions refer to ACID (atomic, consistent, isolated, durable) properties, mostly known from relational databases.

If, for example, your application leverages those capabilities, your business logic is either successfully committed as a whole, or rolled back completely in case of any error. However, those ACID transactions cannot be applied to distributed systems (the talk [lost in transaction](https://www.youtube.com/watch?v=WRR26jJNh68) elaborates on this). In other words, things can get out of sync if either the job handler or the workflow engine fails.

A typical example scenario is the following, where a worker calls a REST endpoint to invoke business logic:

![Typical call chain](dealing-with-problems-and-exceptions-assets/typical-call-chain.png)

Technical ACID transaction will only be applied in the business application. The job worker mostly needs to handle exceptions on a technical level, e.g. to control retry behavior, or pass it on to the process level, where you might need to implement business transactions.

## Handling exceptions on a technical level

### Leveraging retries

Using the [`FailJob `](/apis-tools/zeebe-api/gateway-service.md#failjob-rpc) API is pretty handy to leverage the built-in retry mechanism of Zeebe. The initial number of retries is set in the BPMN process model:

```xml
    <bpmn:serviceTask id="TaskRetrieveMoney">
      <bpmn:extensionElements>
        <zeebe:taskDefinition retries="5" />
      </bpmn:extensionElements>
    </bpmn:serviceTask>
```

This number is typically decremented with every attempt to execute the service task. Note that you need to do that in your worker code. Example in Java:

```java
  @JobWorker(type = "retrieveMoney", autoComplete = false)
  public void retrieveMoney(final JobClient client, final ActivatedJob job) {
    try {
        // your code
    } catch (Exception ex) {
        jobClient.newFailCommand(job)
          .retries(job.getRetries()-1) // <1>: Decrement retries
          .errorMessage("Could not retrieve money due to: " + ex.getMessage()) // <2>
          .send()
          .exceptionally(t -> {throw new RuntimeException("Could not fail job: " + t.getMessage(), t);});
    }
  }
```

1

Decrement the retries by one.

2

Provide a meaningful error message, as this will be displayed to a human operator once an incident is created in Operate.

Example in Node.js:

```js
zbc.createWorker("retrieveMoney", (job) => {
  try {
    // ...
  } catch (e) {
    job.fail("Could not retrieve money due to: " + e.message, job.retries - 1);
  }
});
```

### Using incidents

Whenever a job fails with a retry count of `0`, an incident is raised. An incident requires human intervention, typically using Operate. Refer to [incidents in the Operate docs](/components/operate/userguide/resolve-incidents-update-variables.md).

### Writing idempotent workers

Zeebe uses the **at-least-once strategy** for job handlers, which is a typical choice in distributed systems. This means that the process instance only advances in the happy case (the job was completed, the workflow engine received the complete job request and committed it). A typical failure case occurs when the worker who polled the job crashes and cannot complete the job anymore. [In this case, the workflow engine gives the job to another worker after a configured timeout](/components/concepts/job-workers.md#timeouts). This ensures that the job handler is executed at least once.

But this can mean that the handler is executed more than once! You need to consider this in your handler code, as the handler might be called more than one time. The [technical term describing this is idempotency](https://en.wikipedia.org/wiki/Idempotence).

For example, typical strategies are described in [3 common pitfalls in microservice integration — and how to avoid them](https://blog.bernd-ruecker.com/3-common-pitfalls-in-microservice-integration-and-how-to-avoid-them-3f27a442cd07). One possibility is to ask the service provider if it has already seen the same request. A more common approach is to implement the service provider in a way that allows for duplicate calls. There are two ways of mastering this:

- **Natural idempotency**. Some methods can be executed as often as you want because they just flip some state. Example: `confirmCustomer()`.
- **Business idempotency**. Sometimes you have business identifiers that allow you to detect duplicate calls (e.g. by keeping a database of records that you can check). Example: `createCustomer(email)`.

If these approaches do not work, you will need to add a **custom idempotency handling** by using unique IDs or hashes. For example, you can generate a unique identifier and add it to the call. This way, a duplicate call can be easily spotted if you store that ID on the service provider side. If you leverage a workflow engine you probably can let it do the heavy lifting. Example: `charge(transactionId, amount)`.

See this snippet of a process about how to support custom idempotency handling in a process model:

Whatever strategy you use, make sure that you’ve considered idempotency consciously.

## Handling errors on the process level

You often encounter deviations from the "happy path" (the default scenario with a positive outcome) which shall be modeled in the process model.

### Using BPMN error events

A common way to resolve these deviations is using a BPMN error event, which allows a process model to react to errors within a task. For example:

1

We decide that we want to deal with an exception in the process: in case the invoice cannot be sent automatically...

2

...we assign a task to a human user, who is now in charge of taking care of delivering the invoice.

Learn more about the usage of [error events](/components/modeler/bpmn/error-events/error-events.md) in the user guide.

### Throwing and handling BPMN errors

In BPMN process definitions, we can explicitly model an end event as an error.

1

In case the item is not available, we finish the process with an **error end event**.

:::note
You can mimic a BPMN error in your glue code by using the [`ThrowError`](/apis-tools/zeebe-api/gateway-service.md#throwerror-rpc) API. The consequences for the process are the same as if it were an explicit error end event. So, in case your 'purchase' activity is not a subprocess, but a service task, it could throw a BPMN Error informing the process that the good is unavailable.
:::

Example in Java:

```java
jobClient.newThrowErrorCommand(job)
   .errorCode("GOOD_UNAVAILABLE")
   .errorMessage()
   .send()
   .exceptionally(t -> {throw new RuntimeException("Could not throw BPMN error: " + t.getMessage(), t);});
```

### Thinking about unhandled BPMN exceptions

It is crucial to understand that if a BPMN error is not handled anywhere in the process, Camunda 8 raises an [incident](/components/concepts/incidents.md) (for example, `Unhandled error event`) instead of silently terminating the process instance. Therefore, you can and normally should always handle the BPMN error. You can, of course, also handle it in a parent process scope like in the example below:

1

The boundary error event deals with the case that the item is unavailable.

### Distinguishing between exceptions and results

As an alternative to throwing a Java exception, you can also write a problematic result into a process variable and model an XOR-Gateway later in the process flow to take a different path if that problem occurs.

From a business perspective, the underlying problem then looks less like an error and more like a result of an activity, so as a rule of thumb we deal with _expected results_ of activities by means of gateways, but model exceptional errors, which _hinder us in reaching the expected result_ as boundary error events.

1

The task is to "check the customer's credit-worthiness", so we can reason that we _expect as a result_ to know whether the customer is credit-worthy or not.

2

We can therefore model an _exclusive gateway_ working on that result and decide via the subsequent process flow what to do with a customer who is not credit-worthy. Here, we just consider the order to be declined.

3

However, it could be that we _cannot reach a result_, because while we are trying to obtain knowledge about the customer's creditworthiness, we discover that the ID we have is not associated with any known real person. We can't obtain the expected result and therefore model a _boundary error event_. In the example, the consequence is just the same and we consider the order to be declined.

### Business vs. technical errors

Note that you have two different ways of dealing with problems at your disposal now:

- **Retrying**. You don't want to model the retrying, as you would have to add it to each and every service task. This will bloat the visual model and confuse business personnel. Instead, either retry or fall back to incidents as described above. This is hidden in the visual.
- Branch out **separate paths**, as described with the error event.

In this context, we found the terms **business error** and **technical error** can be confusing, as they emphasize the source of the error too much. This can lead to long discussions about whether a certain problem is technical or not, and if you are allowed to observe technical errors in a business process model.

It's much more important to look at how you react to certain errors. Even a technical problem can qualify for a business reaction. In the above example, upon technical problems with the invoice service you can decide to manually send the invoice (business reaction) or to retry until the invoice service becomes available again (technical reaction).

Or, for example, you could decide to continue a process in the event that a scoring service is not available, and simply give every customer a good rating instead of blocking progress. The error is clearly technical, but the reaction is a business decision.

In general, we recommend talking about business reactions, which are modeled in your process, and technical reactions, which are handled generically using retries or incidents.

## Embracing business transactions and eventual consistency

### Technical vs business transactions

Applications using databases can often leverage ACID (atomic, consistent, isolated, durable) capabilities of that database. This means that some business logic is either successfully committed as a whole, or rolled back completely in case of any error. It is normally referred to as "transactions".

Those ACID transactions cannot be applied to distributed systems (the talk [lost in transaction](https://www.youtube.com/watch?v=WRR26jJNh68) elaborates on this), so if you call out to multiple services from a process, you end up with separate ACID transactions at play. The following illustrations are taken from the O'Reilly book [Practical Process Automation](https://processautomationbook.com/):

![Multiple ACID transactions](dealing-with-problems-and-exceptions-assets/multiple-acid-transactions.png)

In the above example, the CRM system and the billing system have their local ACID transactions. The workflow engine itself also runs transactional. However, there cannot be a joined technical transaction. This requires a new way of dealing with consistency on the business level, which is referred to as **business transaction**:

![Businss vs technical transaction](dealing-with-problems-and-exceptions-assets/business-vs-technical-transaction.png)

A **business transaction** marks a section in a process for which 'all or nothing' semantics (similar to a technical transaction) should apply, but from a business perspective. You might encounter inconsistent states in between (for example a new customer being present in the CRM system, but not yet in the billing system).

### Eventual consistency

It is important to be aware that these temporary inconsistencies are possible. You also have to understand the failure scenarios they can cause. In the above example, you could have created a marketing campaign at a moment when a customer was already in the CRM system, but not yet in billing, so they got included in that list. Then, even if their order gets rejected and they never end up as an active customer, they might still receive an upgrade advertisement.

You need to understand the effects of this happening. Furthermore, you have to think about a strategy to resolve inconsistencies. The term **eventual consistency** suggests that you need to take measures to get back to a consistent state eventually. In the onboarding example, this could mean you need to deactivate the customer in the CRM system if adding them to the billing system fails. This leads to the consistent state that the customer is not visible in any system anymore.

### Business strategies to handle inconsistency

There are three basic strategies if a consistency problem occurs:

- Ignore it. While it sounds strange to consider ignoring a consistency issue, it actually can be a valid strategy. It’s a question of how much business impact the inconsistency may have.
- Apologize. This is an extension of the strategy to ignore. You don’t try to prevent inconsistencies, but you do make sure that you apologize when their effects come to light.
- Resolve it. Tackle the problem head-on and actively resolve the inconsistency. This could be done by different means, such as the reconciliation jobs mentioned earlier, but this practice focuses on how BPMN can help by looking into the Saga pattern.

Selecting the right strategy is a clear business decision, as none of them are right or wrong, but simply more or less well suited to the situation at hand. You should always think about the cost/value ratio.

### The Saga pattern and BPMN compensation

The Saga pattern describes long-running transactions in distributed systems. The main idea is simple: when you can’t roll back tasks, you undo them. (The name Saga refers back to a paper written in the 1980s about long-lived transactions in databases.)

Camunda supports this through BPMN compensation events, which can link tasks with their undo tasks.

1

Assume the customer was already added to the CRM system...

2

...when an error occurred...

3

...the process triggers the compensation to happen. This will roll back the business transaction.

4

All compensating activities of successfully completed tasks will be executed, in this case also this one.

5

As a result, the customer will be deactivated, as the API of the CRM system might not allow to simply delete it.

---

## Handling data in processes

When using Camunda, you have access to a dynamic map of process variables, which lets you associate data to every single process instance (and local scopes in case of user tasks or parallel flows). Ensure you use these mechanisms in a lightweight and meaningful manner, storing just the relevant data in the process instance.

Depending on your programming language, consider accessing your process variables in a type safe way, centralizing (simple and complex) type conversion and using constants for process variable names.

## Understanding data handling in Camunda

When reading and interpreting a business process diagram, you quickly realize there is always data necessary for tasks, but also to drive the process through gateways to the correct next steps.

Examine the following tweet approval process example:

1

The process instance starts with a freshly written `tweet` we need to remember.

2

We need to present this `tweet` so that the user can decide whether to `approve` it.

3

The gateway needs to have access to this information: was the tweet `approved`?

4

To publish the tweet, the service task again needs the `tweet` itself!

Therefore, the tweet approval process needs two variables:

| Variable name | Variable type | Sample value     |
| ------------- | ------------- | ---------------- |
| `tweet`       | String        | "@Camunda rocks" |
| `approved`    | Boolean       | true             |

In Camunda 8, [values are stored as JSON](/components/concepts/variables.md#variable-values).

:::caution Camunda 7 handles variables slightly differently
This best practice describes variable handling within Camunda 8. Process variables are handled slightly differently with Camunda 7. Consult the [Camunda 7 documentation](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/) for details. In essence, variable values are not handled as JSON and thus there are [different values](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/#supported-variable-values) supported.
:::

You can dynamically create such variables by assigning an object of choice to a (string typed) variable name; for example, by passing a `Map<String, Object>` when [completing](/apis-tools/orchestration-cluster-api-rest/specifications/complete-user-task.api.mdx) the "Review tweet" task via the API:

```
// TODO: Double check!
completeTask(
    taskId: "547811"
    variables: [
        {
            name: "approved"
            value: true
        }
    ]
)
```

In Camunda, you do _not_ declare process variables in the process model. This allows for a lot of flexibility. Refer to recommendations below on how to overcome possible disadvantages of this approach.

Consult the [docs about variables](/components/concepts/variables.md#variable-values) to learn more.

Camunda does not treat BPMN **data objects** () as process variables. We recommend using them occasionally _for documentation_, but you need to [avoid excessive usage of data objects](../../modeling/creating-readable-process-models#avoiding-excessive-usage-of-data-objects).

## Storing just the relevant data

Do not excessively use process variables. As a rule of thumb, store _as few variables as possible_ within Camunda.

Please note the [technical limitations of variables sizes](/components/concepts/variables.md#variable-size-limitation).

### Storing references only

If you have leading systems already storing the business relevant data...

![Hold references only](handling-data-in-processes-assets/hold-references-only.svg)

...then we suggest you store references only (e.g. ID's) to the objects stored there. So instead of holding the `tweet` and the `approved` variable, the process variables would now, for example, look more like the following:

| Variable name | Variable type | Value |
| ------------- | ------------- | ----- |
| `tweetId`     | Long          | 8213  |

### Use cases for storing payload

Store _payload_ (actual business data) as process variables, if you....

- ...have data only of interest within the process itself (e.g. for gateway decisions).

In case of the tweet approval process, even if you are using a tweet domain object, it might still be meaningful to hold the approved value explicitly as a process variable, because it serves the purpose to guide the gateway decision in the process. It might not be true if you want to keep track in the tweet domain objects regarding the approval.

| Variable name | Variable type | Value |
| ------------- | ------------- | ----- |
| `tweetId`     | Long          | 8213  |
| `approved`    | Boolean       | true  |

- ...communicate in a _message oriented_ style. For example, retrieving data from one system and handing it over to another system via a process.

When receiving external messages, consider storing just those parts of the payload relevant for you, and not the whole response. This not only serves the goal of having a lean process variables map, it also makes you more independent of changes in the service's message interface.

- ...want to use the process engine as kind of _cache_. For example, you cannot query relevant customer data in every step for performance reasons.

- ...need to _postpone data changes_ in the leading system to a later step in the process. For example, you only want to insert the Tweet in the Tweet Management Application if it is approved.

- ...want to track the _historical development_ of the data going through your process.

- ...don't have a leading system for this data.

## Using constants and data accessors

Avoid the copy/paste of string representations of your process variable names across your code base. Collect the variable names for a process definition in _constants_. For example, in Java:

```java
public interface TwitterDemoProcessConstants {
  String VAR_NAME_TWEET = "tweet";
  String VAR_NAME_APPROVED = "approved";
}
```

This way, you have much more security against typos and can easily make use of refactoring mechanisms offered by your IDE.

However, if you also want to solve necessary type conversions (casting) or probably even complex serialization logic, we recommend that you use a **Data Accessor** class. It comes in two flavors:

- A **Process Data Accessor**: Knows the names and types of all process variables of a certain process definition. It serves as the central point to declare variables for that process.
- A **Process Variable Accessor**: Encapsulates the access to exactly one variable. This is useful if you reuse certain variables in different processes.

Consider, for example, the BPMN "Publish on Twitter" task in the Tweet Approval Process:

1

We use a **TweetPublicationDelegate** to implement the "Publish on Twitter" task:

```java
public class PublishTweetJobHandler implements JobHandler  {
    public void handle(JobClient client, ActivatedJob job) throws Exception {
        String tweet = job.getVariablesAsType(TwitterDemoProcessVariables.class).getTweet();
        // ...
```

The `tweet` variable is accessed in a type safe way.

This reusable **Process Data Accessor** class could, for example, be a simple object. The Java client API can automatically deserialize the process variables as JSON into this object, while all process variables that are not found in that class are ignored.

```java
public class TwitterDemoProcessVariables {

    private String tweet;
    private boolean approved;

    public String getTweet() {
        return tweet;
    }

    public void setTweet(String tweet) {
        this.tweet = tweet;
    }
}
```

The getters and setters could further take care of additional serialization and deserialization logic for complex objects.

Your specific implementation approach might differ depending on the programming language and framework you are using.

## Complex data as entities

There are some use cases when it is clever to _introduce entities alongside the process_ to store complex data in a relational database. You can observe this logically as _typed process context_ where you create custom tables for your custom process deployment. Then, you can even use **Data** **Accessor** classes to access these entities in a convenient way.

You will only store a reference to the entity's primary key (typically an artificial UUID) as real process variable within Camunda.

Some people refer to this as **externalized process context**.

There are a couple of advantages of this approach:

- You can do very _rich queries_ on structured process variables via typical SQL.
- You can apply custom _data migration strategies_ when deploying new versions of your process or services, which require data changes.
- Data can be designed and modeled properly, even graphically by, for example, leveraging UML.

It requires additional complexity by adding the need for a relational database and code to handle this.

---

## Local development with element templates and Camunda 8 Run

When working with [element templates](/components/concepts/element-templates.md) in your local development environment using [Camunda 8 Run with Docker Compose](/self-managed/quickstart/developer-quickstart/c8run.md), ensure all dependencies are provisioned before you start.

This guide explains how to set up element templates in your local environment.

## Prerequisites

- [Camunda 8 Run](/self-managed/quickstart/developer-quickstart/c8run.md) installed on your local machine.
- Basic knowledge of [element templates with dependencies](/components/modeler/element-templates/element-template-with-dependencies.md).
- Familiarity with [custom connectors](/components/connectors/manage-connector-templates.md).

## Provisioning secrets

If your element templates use secrets, you must provide these values to the connector runtime.

Add secrets to the `connector-secrets.txt` file in the root directory of your Camunda 8 Run setup. Use the following format, with one secret per line:

```
NAME=VALUE
```

These secrets will then be available in the connector runtime using the format `secrets.NAME`.

For example:

```
MY_TOKEN=value
AWS_KEY=keyValue
...
```

In this case, the `MY_TOKEN` secret can be referenced as `secrets.MY_TOKEN`.

This applies when custom connectors are deployed as part of the Camunda 8 Run Docker Compose setup.
If you choose to run connectors differently, as described in the [custom connector hosting guide](/components/connectors/custom-built-connectors/host-custom-connector.md#wiring-your-connector-with-a-camunda-cluster), configure secrets as environment variables instead.

## Provisioning a custom connector runtime

You can add a custom connector runtime to Camunda 8 Run by copying the `.jar` file containing all connector dependencies into the `custom_connectors` directory in the root folder of your Camunda 8 Run setup.

This guide uses a generic [connector template](https://github.com/camunda/connector-template-outbound) as a reference.

1. Clone the repository and run the following command to generate a deployable file:

   ```bash
   mvn clean verify package
   ```

This command creates a file named `target/connector-template-0.1.0-SNAPSHOT-with-dependencies.jar`.

2. Copy the `.jar` file into the `custom_connectors` directory.
3. Start Camunda 8 Run with Docker Compose. For example, from the Docker Compose directory in your Camunda 8 Run setup, run:

```bash
docker compose up -d
```

4. Your connector is ready to execute jobs when a process references it.

If you use a different [connector runtime environment](/components/connectors/custom-built-connectors/connector-sdk.md#runtime-environments), ensure that secrets are also exposed to that runtime.

## Provisioning other dependencies

### Using Desktop Modeler

Deploy element template dependencies using [Desktop Modeler](/components/modeler/desktop-modeler/index.md) by following the [self-managed deployment guide](/self-managed/components/modeler/desktop-modeler/deploy-to-self-managed.md).

This process applies to BPMN diagrams, forms, DMN diagrams, and RPA scripts.

### Using the Cluster API

For an automated approach, write scripts that use the [Orchestration Cluster REST API](/apis-tools/orchestration-cluster-api-rest/orchestration-cluster-api-rest-overview.md) to deploy dependencies.

To deploy additional dependencies—such as forms, DMN diagrams, or subprocesses—send a [POST request](/apis-tools/orchestration-cluster-api-rest/specifications/create-deployment.api.mdx) with the relevant files.

For example:

```

curl -L 'http://localhost:8080/v2/deployments' \
-H 'Accept: application/json' \
-F resources=@/pathToYourForm/user-signup.form

```

You will get a response containing the details of the deployed elements:

```json
{
  "deployments": [
    {
      "form": {
        "formKey": "KEY_OF_THE_FORM",
        "formId": "user-signup",
        "version": 1,
        "resourceName": "user-signup.form",
        "tenantId": "<default>"
      }
    }
  ],
  "deploymentKey": "KEY_OF_THE_DEPLOYMENT",
  "tenantId": "<default>"
}
```

You can use element templates that reference the `user-signup.form`.

## Configure element templates in Desktop Modeler

To make your element templates available in Desktop Modeler, see the [configuration guide](/components/modeler/desktop-modeler/element-templates/configuring-templates.md).

## Additional resources and next steps

- [Using element templates in Desktop Modeler](/components/modeler/desktop-modeler/element-templates/using-templates.md)
- [Run your first local Camunda 8 project](/guides/getting-started-example.md)
- [Available connectors](/components/connectors/out-of-the-box-connectors/available-connectors-overview.md)

---

## Routing events to processes

To start a new process instance or to route a message to an already running instance, you have to choose the appropriate technology option to do so, like using the existing API or using customized possibilities including SOAP, AMQP, or Kafka. Leverage the possibilities of the universe of your runtime (like Java or Node.js) and the frameworks of your choice to support the technologies or protocols you need.

## Choosing the right BPMN event

### Start events

Several BPMN start events can be used to start a new process instance.

|                         | None Event                                                                    | Message Event                                                           | Timer Event                                                            | Signal Event                                                          | Conditional Event                                                                |
| ----------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------- | ---------------------------------------------------------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
|                         | ![none start](/img/bpmn-elements/none-start.svg)                              | ![message start](/img/bpmn-elements/message-start.svg)                  | ![timer start](/img/bpmn-elements/timer-start.svg)                     | ![signal start](/img/bpmn-elements/signal-start.svg)                  | ![conditional start](/img/bpmn-elements/conditional-start.svg)                   |
| Use when                | You have only **one start event** or a start event which is clearly standard. | You have to differentiate **several start events**.                     | You want to automatically start process instances **time controlled**. | You need to start **several process instances** at once. Rarely used. | When a specific **condition** is met, a process instance is created.             |
| Supported for Execution | ✔                                                                             | ✔                                                                       | ✔                                                                      | ✔                                                                     | Determine occurrence of condition externally yourself and use the message event. |
|                         | [Learn more](/components/modeler/bpmn/none-events/none-events.md)             | [Learn more](/components/modeler/bpmn/message-events/message-events.md) | [Learn more](/components/modeler/bpmn/timer-events/timer-events.md)    | [Learn more](/components/modeler/bpmn/signal-events/signal-events.md) |                                                                                  |

1

This none start event indicates the typical starting point. Note that only _one_ such start event can exist in one process definition.

2

This message start event is defined to react to a specific message type...

3

...hence you can have _multiple_ message start events in a process definition. In this example, both message start events seems to be exceptional cases - for equivalent cases we recommend to just use message instead of none start events.

### Intermediate events

Several BPMN intermediate events (and the receive task) can be used to make a process instance _wait_ for and _react_ to certain triggers.

|                         | Message Event                                                                | Receive Task                                                                            | Timer Event                                                                    | Signal Event                                                              | Conditional Event                                                            |
| ----------------------- | ---------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
|                         | ![message intermediate](/img/bpmn-elements/message-intermediate.svg)         | ![task receive](/img/bpmn-elements/task-receive.svg)                                    | ![timer intermediate](/img/bpmn-elements/timer-intermediate.svg)               | ![signal intermediate](/img/bpmn-elements/signal-intermediate.svg)        | ![conditional intermediate](/img/bpmn-elements/conditional-intermediate.svg) |
| Use when                | You route an incoming **message** to a specific and unique process instance. | As alternative to message events (to leverage BPMN boundary events, for example, for timeouts). | You want to make your process instance wait for a certain (point in) **time**. | You route an incoming **signal** to all process instances waiting for it. | When a specific **condition** is met, the waiting process instance moves on. |
| Supported for Execution | ✔                                                                            | ✔                                                                                       | ✔                                                                              | ✔                                                                         | Not yet supported in Camunda 8                                               |
|                         | [Learn more](/components/modeler/bpmn/message-events/message-events.md)      | [Learn more](/components/modeler/bpmn/receive-tasks/receive-tasks.md)                   | [Learn more](/components/modeler/bpmn/timer-events/timer-events.md)            | [Learn more](/components/modeler/bpmn/signal-events/signal-events.md)     |                                                                              |

Consider this example:

1

This intermediate message event causes the process instance to wait unconditionally for a _specific_ event...

2

...whereas the intermediate message event attached to the boundary of an activity waits for an _optional_ event, potentially arriving while we are occupied with the activity.

## Reacting to process-internal events

Events relevant for the process execution can occur from within the workflow engine itself.

Consider the following loan application process - or at least the initial part with which the applicant's income is confirmed either via the employer or via the last income tax statement.

1

In case the employer does not confirm the income within three business days, a **timer event** triggers and a human clerk now tries to contact the employer and investigate the situation.

2

This could end with a successful income confirmation. However, it could also end with new findings regarding the applicant's employment status. We learn that the applicant is actually unemployed.

3

In this case, a **conditional event** watching this data (for example, a process variable changed by the user task) triggers and causes the process to reconsider the consequences of the new findings.

A conditional event's condition expression is evaluated at it's "scope" creation time, too, and not just when variable data changes. For our example of a boundary conditional event, that means that the activity it is attached to could principally be left immediately via the boundary event. However, our process example evaluates the data via the exclusive gateway - therefore such a scenario is semantically impossible.

## Routing events from the outside to the workflow engine

Most events actually occur somewhere external to the workflow engine and need to be routed to it. The core workflow engine is by design not concerned with the technical part of receiving external messages, but you can receive messages and route them to the workflow engine by the following ways:

- Using API: Receive the message by means of your platform-specific activities such as connecting to a AMQP queue or processing a REST request and then route it to the process.
- Using connectors: Configure a connector to receive messages such as Kafka records and rote it to the process. Note that this possibility works for Camunda 8 only.

### Starting process instance by BPMN process ID

If you have only one starting point (none start event) in your process definition, you reference the process definition by the ID in the BPMN XML file.

:::note
This is the most common case and requires using the [`CreateProcessInstance`](/apis-tools/zeebe-api/gateway-service.md#createprocessinstance-rpc) API.
:::

Example in Java:

```java
processInstance = zeebeClient.newCreateInstanceCommand()
  .bpmnProcessId("invoice").latestVersion()
  .send()
  .exceptionally( throwable -> { throw new RuntimeException("Could not create new process instance", throwable); });
```

Example in Node.js:

```js
zbc.createWorkflowInstance({
  bpmnProcessId: "invoice",
});
```

This starts a new process instance in the latest version of the process definition. You can also start a specific version of a process definition:

```java
processInstance = zeebeClient.newCreateInstanceCommand()
  .bpmnProcessId("invoice").version(5)
  //...
```

or

```js
zbc.createWorkflowInstance({
  bpmnProcessId: "invoice",
  version: 6,
});
```

You can also use [`CreateProcessInstanceWithResult`](/apis-tools/zeebe-api/gateway-service.md#createprocessinstancewithresult-rpc) instead, if you want to block the execution until the process instance has completed.

### Starting process instance by message

As soon as you have multiple possible starting points, you have to use named messages to start process instances. The API method is [`PublishMessage`](/apis-tools/zeebe-api/gateway-service.md#publishmessage-rpc):

```java
client.newPublishMessageCommand()
  .messageName("message_invoiceReceived") // <1>
  .corrlationKey(invoiceId) // <2>
  .variables( // <3>
	  //...
  ).send()
  .exceptionally( throwable -> { throw new RuntimeException("Could not publish message", throwable); });
```

1

Message name as defined in the BPMN.

2

Correlation key has to be provided, even if a start event does not require correlation.

3

_Payload_ delivered with the message.

On one hand, now you do not have to know the key of the BPMN process. On the other hand, you cannot influence the version of the process definition used when starting a process instance by message.

The message name for start events should be unique for the whole workflow engine - otherwise you might experience side effects you did not intend (like starting other processes too).

## Technology examples for messages sent by external systems

In this section, we give examples for _technical messages_, which are received from other systems, typically by leveraging technologies like SOAP, REST, JMS, and others.

1

You will need a mechanism receiving that message and routing it to the workflow engine. That could be a direct API call to Camunda. It could also be a AMQP or Kafka consumer or a SOAP endpoint using the Camunda API internally. It could even be a hotfolder polled by some framework like Apache Camel.

API examples for REST, AMQP, and Kafka are shown in [connecting the workflow engine with your world](../connecting-the-workflow-engine-with-your-world/).

## Using the Camunda BPMN framework

If you use the **Camunda BPMN Framework** as described in the book ["Real Life BPMN"](https://page.camunda.com/wp-real-life-bpmn-book-excerpt) you will typically have message start events (even if you only have a single start event) to connect the surrounding human flows to the technical flow via messages:

1

This is a message start event, which allows you to show the collaboration between the human and the technical flows. However, it is the only the starting point of the technical pool and could be a none start event in terms of execution.

If there is _exactly one message start event_ for the whole process definition, it can also be treated as if it were a none start event when starting a process instance.

## Sending messages to other processes

If messages are exchanged between different processes deployed in the workflow engine you have to implement the communication yourself by writing some code that starts a new process instance.

1

Use some simple code on the sending side to route the message to a new process instance, for example by starting a new process instance by the BPMN ID in Java:

```java
@JobWorker(type="routeInput")
public void routeInput(@Variable String invoiceId) {
  Map<String, Object> variables = new HashMap<String, Object>();
  variables.put("invoiceId", invoiceId);
  zeebeClient.newCreateInstanceCommand()
    .bpmnProcessId("invoice").latestVersion()
	.variables(variables)
    .send()
    .exceptionally( throwable -> { throw new RuntimeException("Could not create new process instance", throwable); });
}
```

2

Use some simple code on the sending side to correlate the message to a running process instance, for example in Java:

```java
@JobWorker(type="notifyOrder")
public void notifyOrder(@Variable String orderId, @Variable String paymentInformation) {
  Map<String, Object> variables = new HashMap<String, Object>();
  variables.put("paymentInformation", paymentInformation);

  zeebeClient.newPublishMessageCommand()
    .messageName("MsgPaymentReceived")
    .corrlationKey(orderId)
    .variables(variables)
    .send()
    .exceptionally( throwable -> { throw new RuntimeException("Could not publish message", throwable); });
}
```

## Handling messages sent by a user

Sometimes explicit "user tasks" are not an appropriate choice to involve a human user to participate in a process: the user does not want to observe a task in Tasklist, but rather have the possibility to actively trigger some action right at the time when it becomes necessary from a business perspective. The difference is which event gives the _active trigger_.

1

We did not model a user task in this process, as the user will not immediately be triggered. The user cannot do anything at the moment when the process enters this event. Instead, we made it wait for a "message" which is later triggered by a human user.

2

The accountant actually receives the "external trigger" by actively looking at new payments in the bank account.

3

Every new payment now has to be correlated to the right waiting process instance manually. In this situation it is often the better choice not to model a user task, but let the process wait for a "message" generated from a user.

These scenarios are not directly supported by Camunda Tasklist. A custom search screen built for the accountant might allow you to observe and find orders waiting for a payment. By interacting with such a screen, the accountant communicates with those process instances all at once. When hitting a 'Paid' button, a piece of custom code using the API must now correlate the user's message to the affected process instance(s).

---

## Service integration patterns with BPMN

When integrating systems and services, you can choose between various modeling possibilities in BPMN. This practice will give you an overview and advice on how to decide between alternatives.

You will note that service tasks in general are a good choice, but there are also situations where you might want to switch to send and receive tasks or events.

## Understanding communication patterns

Let's briefly examine the three typical communication patterns to integrate systems:

- **Request/response using synchronous communication styles**: You use a synchronous protocol, like HTTP, and block for the result.
- **Request/response using asynchronous communication styles**: You use asynchronous communication, for example, by sending messages via a message broker, but wait for a response message right after. Technically, these are two independent asynchronous messages, but the sender blocks until the response is received, hence logically making it a request/response.
- **Asynchronous messages or events:** If a peer service needs a long time to process a request, the response is much later than the request, say hours instead of milliseconds. In this case, the response is typically handled as a separate message. Additionally, some of your services might also wait for messages or events that are not connected to a concrete request, especially in event-driven architectures.

The following table gives a summary of the three options:

|                                   | Synchronous request/response | Asynchronous request/response | Asynchronous messages or events |
| --------------------------------- | :--------------------------- | :---------------------------- | :------------------------------ |
| **Business level**                | Synchronous                  | Synchronous                   | Asynchronous                    |
| **Technical communication style** | Synchronous                  | Asynchronous                  | Asynchronous                    |
| **Example**                       | HTTP                         | AMQP, JMS                     | AMQP, Apache Kafka              |

You can dive more into communication styles in the webinar [Communication Between Loosely Coupled Microservices](https://page.camunda.com/wb-communication-between-microservices) ([slides](https://www.slideshare.net/BerndRuecker/webinar-communication-between-loosely-coupled-microservices), [recording](https://page.camunda.com/wb-communication-between-microservices) and [FAQ](https://blog.bernd-ruecker.com/communication-between-loosely-coupled-microservices-webinar-faq-a02708b3c8b5)).

## Integrating services with BPMN tasks

Let’s look at using BPMN tasks to handle these communication patterns before diving into BPMN events later.

### Service task

The [service task](/components/modeler/bpmn/service-tasks/service-tasks.md) is the typical element to implement synchronous request/response calls, such as REST, gRPC or SOAP. You should **always use service tasks for synchronous request/response**.

![Service task](service-integration-patterns-assets/service-task.png)

### Send task

Technically, **send tasks behave exactly like service tasks**. However, the alternative symbol makes the meaning of sending a message easier to understand for some stakeholders.

You **should use send tasks for sending asynchronous messages**, like AMQP messages or Kafka records.

![Send task](service-integration-patterns-assets/send-task.png)

There is some gray area whenever you call a synchronous service that then sends an asynchronous message. A good example is email. Assume your process does a synchronous request/response call to a service that then sends an email to inform the customer. The call itself is synchronous because it gives you a confirmation (acknowledgement, or ACK for short) that the email has been sent. Now is the "inform customer" task in your process a service, or a send task?

![Asynchronous ACK](service-integration-patterns-assets/synchronous-ack.png)

This question is not easy to answer and **depends on what your stakeholders understand more intuitively**. The more technical people are, the more you might tend towards a service task, as this is technically correct. The more you move towards the business side, the more you might tend to use a send task, as business people will consider sending an email an asynchronous message.

In general, we tend to **let the business win** as it is vital that business stakeholders understand business processes.

However, if you follow a microservice (or service-oriented architecture) mindset, you might argue that you don’t need to know exactly how customers are informed within the process. Hiding the information if the notification is synchronous or asynchronous is good to keep your process model independent of such choices, making it more robust whenever the implementation of the notification service changes. This is a very valid concern too, and might motivate for a service task.

:::note
In case you can’t easily reach a conclusion, save discussion time and just use a service task.
:::

You could also argue to use send tasks to invoke synchronous request/response calls when you are not interested in the response. However, this is typically confusing, and we do not recommend this.

### Receive task

A [receive task](/components/modeler/bpmn/receive-tasks/receive-tasks.md) waits for an asynchronous message. Receive tasks **should be used for incoming asynchronous messages or events**, like AMQP messages or Kafka records.

![Receive task](service-integration-patterns-assets/receive-task.png)

Receive tasks can be used to receive the response in asynchronous request/response scenarios, which is discussed next.

### Service task vs. send/receive task combo

For asynchronous request/response calls, you can use a send task for the request, and a following receive task to wait for the response:

![Send and receive task](service-integration-patterns-assets/send-and-receive-task.png)

You can also use a service task, which is sometimes unknown even to advanced users. A service task can technically wait for a response that happens at any time, a process instance will wait in the service task, as it would in the receive task.

![Service task](service-integration-patterns-assets/service-task.png)

Deciding between these options is not completely straightforward. You can find a table listing the decision criteria below.

As a general rule-of-thumb, we recommend using **the service task as the default option for synchronous _and_ asynchronous request/response** calls. The beauty of service tasks is that you remove visual clutter from the diagram, which makes it easier to read for most stakeholders.

This is ideal if the business problem requires a logically synchronous service invocation. It allows you to ignore the technical details about the protocol on the process model level.

The typical counter-argument is that asynchronous technical protocols might lead to different failure scenarios that you have to care about. For example, when using a separate receive task, readers of the diagram almost immediately start to think about what happens if the response will not be received. But this also has the drawback that now business people might start discussing technical concerns, which is not necessarily good.

Furthermore, this is a questionable argument, as synchronous REST service calls could also timeout. This is exactly the same situation, just hidden deeper in network abstraction layers, as every form of remote communication uses asynchronous messaging somewhere down in the network stack. On a technical level, you should always think about these failure scenarios. The talk [3 common pitfalls in microservice integration and how to avoid them](https://blog.bernd-ruecker.com/3-common-pitfalls-in-microservice-integration-and-how-to-avoid-them-3f27a442cd07) goes into more detail on this.

On a business level, you should be aware of the business implications of technical failures, but not discuss or model all the nuts and bolts around it.

However, there are also technical implications of this design choice that need to be considered.

**Technical implications of using service tasks**

You can keep a service task open and just complete it later when the response arrives, but in **to complete the service task, you need the _job instance key_** from Zeebe. This is an internal ID from the workflow engine. You can either:

- Pass it around to the third party service which sends it back as part of the response message.
- Build some kind of lookup table, where you map your own correlation information to the right job key.

:::note
Later versions of Zeebe might provide query possibilities for this job key based on user controlled data, which might open up more possibilities.
:::

Using workflow engine internal IDs can lead to problems. For example, you might cancel and restart a process instance because of operational failures, which can lead to a new ID. Outstanding responses cannot be correlated anymore in such instances.

Or, you might run multiple workflow engines which can lead to internal IDs only being unique within one workflow engine. All of this might not happen, but the nature of an internal ID is that it is internal and you have no control over it — which bears some risk.

In practice, however, using the internal job instance key is not a big problem if you get responses in very short time frames (milliseconds). Whenever you have more long-running interactions, you should consider using send and receive tasks, or build your own lookup table that can also address the problems mentioned above.

This is also balanced by the fact that service tasks are simply very handy. The concept is by far the easiest way to implement asynchronous request/response communication. The job instance key is generated for you and unique for every message interchange. You don’t have to think about race conditions or idempotency constraints yourself. [Timeout handling and retry logic](/components/concepts/job-workers.md#timeouts) is built into the service task implementation of Zeebe. There is also [a clear API to let the workflow engine know of technical or business errors](/components/concepts/job-workers.md#completing-or-failing-jobs).

**Technical implications of using send and receive tasks**

Using send and receive tasks means to use [the message concept built into Zeebe](/components/concepts/messages.md). This is a powerful concept to solve a lot of problems around cardinalities of subscriptions, correlation of the message to the right process instances, and verification of uniqueness of the message (idempotency).

When using messages, you need to provide the correlation ID yourself. This means that the correlation ID is fully under your control, but it also means that you need to generate it yourself and make sure it is unique. You will most likely end up with generated UUIDs.

You can leverage [message buffering](/components/concepts/messages.md#message-buffering) capabilities, which means that the process does not yet need to be ready to receive the message. You could, for example, do other things in between, but this also means that you will not get an exception right away if a message cannot be correlated, as it is simply buffered. This leaves you in charge of dealing with messages that can never be delivered.

Retries are not built-in, so if you need to model a loop to retry the initial service call if no response is received. And (at least in the current Zeebe version), there is no possibility to trigger error events for a receive task, which means you need to model error messages as response payload or separate message types — both are discussed later in this post.

A final note for high-performance environments: These powerful messaging capabilities do not come for free and require some overhead within the engine. For pure request/response calls that return within milliseconds, none of the features are truly required. If you are looking to build a high-performance scenario, using service tasks instead of message correlation for request/response calls, you can tune your overall performance or throughput. However, as with everything performance related, the devil is in the detail, so [reach out to us](/reference/contact.md) to discuss such a scenario in more depth.

**Summary And recommendations**

The following table summarizes the possibilities and recommendations.

| Case                   | Synchronous request/response                                                                                                | Synchronous request/response                                                                                          | Asynchronous request/response                                                                                                                                                                        | Asynchronous request/response                                                                                                                                                                     |
| :--------------------- | :-------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| BPMN element           | Service task                                                                                                                | Send task                                                                                                             | Service task                                                                                                                                                                                         | Send + receive task                                                                                                                                                                               |
|                        | ![Service task](/img/bpmn-elements/task-service.svg)                                                                        | ![Send task](/img/bpmn-elements/task-send.svg)                                                                        | ![Service task](/img/bpmn-elements/task-service.svg)                                                                                                                                                 | ![Send and receive task](/img/bpmn-elements/send-and-receive-task.png)                                                                                                                            |
| Technical implications |                                                                                                                             | Behaves like a service task                                                                                           | A unique correlation ID is generated for you. You don’t have to think about race conditions or idempotency. Timeout handling and retry logic are built-in. API to flag business or technical errors. | Correlation ID needs to be generated yourself, but is fully under control. Message buffering is possible but also necessary. Timeouts and retries need to be modeled. BPMN errors cannot be used. |
| Assessment             | Very intuitive.                                                                                                             | Might be more intuitive for fire and forget semantics, but can also lead to discussions.                              | Removes visual noise which helps stakeholders to concentrate on core business logic, but requires use of internal job instance keys.                                                                 | More visual clutter, but also more powerful options around correlation and modeling patterns.                                                                                                     |
| Recommendation         | Default option, use unless it is confusing for business stakeholders (e.g. because of fire and forget semantics of a task). | Use for fire and forget semantics, unless it leads to unnecessary discussions, in this case use service task instead. | Use when response is within milliseconds and you can pass the Zeebe-internal job instance key around.                                                                                                | Use when the response will take time (> some seconds), or you need a correlation ID you can control.                                                                                              |

## Integrating services with BPMN events

Instead of using send or receive **tasks**, you can also use send or receive **events** in BPMN.

![Events vs tasks](service-integration-patterns-assets/events-vs-tasks.png)

Let's first explore when you want to do that, and afterwards look into some more advanced patterns that become possible with events.

### Tasks vs. events

The **execution semantics of send and receive events is identical with send and receive tasks**, so you can express the very same thing with tasks or events.

However, there is one small difference that might be relevant: **only tasks can have boundary events**, which allows to easily model when you want to cancel waiting for a message:

![Boundary events](service-integration-patterns-assets/boundary-event.png)

Despite this, the whole visual representation is of course different. In general, tasks are easier understood by most stakeholders, as they are used very often in BPMN models.

However, in certain contexts, such as event-driven architectures, events might be better suited as the concept of events is very common. Especially, if you apply domain-driven design (DDD) and discuss domain events all day long, it might be intuitive that events are clearly visible in your BPMN models.

Another situation better suited for events is if you send events to your internal reporting system besides doing “the real” business logic. Our experience shows that the smaller event symbols are often unconsciously treated as less important by readers of the model, leading to models that are easier to understand.

|                | Send task                | Receive task             | Send event                                                                                                              | Receive event                                                                                                           |
| :------------- | :----------------------- | :----------------------- | :---------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------- |
| Recommendation | Prefer tasks over events | Prefer tasks over events | Use only if you consistently use events over tasks and have a good reason for doing so (e.g. event-driven architecture) | Use only if you consistently use events over tasks and have a good reason for doing so (e.g. event-driven architecture) |

:::note
The choice about events vs. commands also [needs to be reflected in the naming of the element](../../modeling/naming-bpmn-elements), as a task emphasizes the action (e.g. "wait for response") and the event reflects what happened (e.g. "response received").
:::

### Handling different response messages

Very often the response payload of the message will be examined to determine how to move on in the process.

![Gateway handling response](service-integration-patterns-assets/response-gateway.png)

In this case, you receive exactly one type of message for the response. As an alternative, you could also use different message types, to which the process can react differently. For example, you might wait for the validation message, but also accept a cancellation or rejection message instead:

![Boundary message event to capture different response messages](service-integration-patterns-assets/response-boundary-message-events.png)

This modeling has the advantage that it is much easier to note the expected flow of the process (also called the happy path), with exceptions deviating from it. On the other hand, this pattern mixes receive tasks and events in one model, which can confuse readers. Keep in mind that it only works for a limited number of non-happy messages.

To avoid the task/event mixture you could use a so-called event-based gateway instead, this gateway waits for one of a list of possible message types to be received:

![Event based gateway to capture different response messages](service-integration-patterns-assets/response-event-based-gateway.png)

We typically try to avoid the event-based gateway, as it is hard to understand for non-BPMN professionals. At the same time, it shares the downside of the first pattern with the decision gateway after the receive task: the happy path cannot be easily spotted.

As a fourth possibility, you can add event subprocesses, which get activated whenever some event is received while the process is still active in some other area. In the above example, you could model the happy path and model all deviations as event subprocesses.

![Event subprocess to capture different response messages](service-integration-patterns-assets/response-event-subprocess.png)

This pattern is pretty handy, but also needs some explanation to people new to BPMN. It has one downside you need to know: once your process instance moves to the subprocess, you can’t easily go back to the typical flow. To some extent this problem can be solved by advanced modeling patterns like shown in the [allow for order cancellation anytime](../../modeling/building-flexibility-into-bpmn-models/#allow-for-order-cancellation-any-time) example.

At the same time, the event subprocess has a superpower worth mentioning: you can now wait for cancellation messages in whole chunks of your process — it could arrive anytime.

|                   | Receive task with boundary events                                                                     | Payload and XOR-gateway                                                                   | Event-based gateway                                                                          | Event subprocess                                                                       |
| ----------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
|                   | ![Boundary Events](service-integration-patterns-assets/response-boundary-message-events.png)          | ![XOR Gateway](service-integration-patterns-assets/response-gateway.png)                  | ![Event-based Gateway](service-integration-patterns-assets/response-event-based-gateway.png) | ![Event Subprocess](service-integration-patterns-assets/response-event-subprocess.png) |
| Understandability | Easy                                                                                                  | Very easy                                                                                 | Hard                                                                                         | Medium                                                                                 |
| Assessment        | Limitation on how many message types are possible                                                     | Happy path not easily visible                                                             |                                                                                              | Might need some explanation for readers of the model                                   |
| Recommendation    | Use when it is important to observe message types in the visual, limit to two boundary message events | Use when there are more response types or if the response type can be treated as a result | Try to avoid                                                                                 | Use if you need bigger scopes where you can react to events                            |

### Message type on the wire != BPMN message type

There is one important detail worth mentioning in the context of message response patterns: The message type used in BPMN models does not have to be exactly the message type you get on the wire. When you correlate technical messages, e.g. from AMQP, you typically write a piece of glue code that receives the message and calls the workflow engine API. This is described in [connecting the workflow engine with your world](../connecting-the-workflow-engine-with-your-world/), including a code example. In this glue code you can do various transformations, for example:

- Messages on different message queues could lead to the same BPMN message type, probably having some additional parameter in the payload indicating the origin.
- Some message header or payload attributes could be used to select between different BPMN message types being used.

It is probably not best practice to be as inconsistent as possible between technical message types and BPMN message types. Still, the flexibility of a custom mapping might be beneficial in some cases.

## Hiding technical complexity behind call activities

Whenever technical details of one service integration become complicated, you can think of creating a separate process model for the technicalities of the call and use a [call activity](/components/modeler/bpmn/call-activities/call-activities.md) in the main process.

An example is given in chapter 7 of [Practical Process Automation](https://processautomationbook.com/):

![Hiding technical details behind call activity](service-integration-patterns-assets/hiding-technical-details-behind-call-activity.png)

In the customer scenario, a document storage service was long-running, but could not do a real callback or response message for technical reasons (in short, firewall limitations). As a result, the document storage service needed to be regularly polled for the response. In the customer scenario, this was done by a "document storage adapter" process that leveraged workflow engine features to implement the polling every minute, and especially the persistent waiting in between. In the main business process, this technical adapter process was simply invoked via a call activity, meaning no technicalities bloated that diagram.

---

## Testing process definitions

Test your executable BPMN processes as you would any software. When possible, write fast automated unit tests using a localized and isolated workflow engine. Before releasing, verify your implementation with integration tests in an environment that closely mirrors your production setup, which may include human-driven, exploratory integration tests.

This best practice uses the following process example for incoming invoices that need to be approved:

1

Invoices need to be approved.

2

The invoice sender is notified about a rejection.

3

Approved invoices get processed.

4

If the approval task takes too long, the process takes an alternative path—in this case, the invoice is automatically approved.

5

If an error occurs while communicating with the archive system (assume you have an unreliable legacy system), the process takes a detour to handle this situation manually.

## Testing scopes

There are three typical test scopes used when building process solutions:

1. **Unit tests**: Testing glue code or programming code you developed for your process solution. How to unit test your software itself is not discussed here, as this is a common practice for software development.

2. **Process tests**: Testing the expected behavior of the process model, including glue code and specifically the data flowing through the process model. These tests should run frequently, so they should behave like unit tests (quick turnaround, no need for external resources).

3. **Integration tests**: Testing the system in a close-to-production environment to ensure it works correctly. This is typically done before releasing a new version of your system. These tests include _human-driven_, _exploratory_ tests.

![Scopes](testing-process-definitions-assets/scopes.png)

## Writing process tests in Java

This section describes how to write process tests as unit tests in Java. We are working on additional information for writing tests in other languages, such as Node.js or C#.

When using Java, most customers use Spring Boot, so we describe this approach in this best practice. While this is a common setup for customers, it is not the only one. Find more examples of plain Java process tests in [Getting Started with Camunda Process Test](../../../apis-tools/testing/getting-started.md).

### Technical setup using Spring

:::caution

- Camunda Process Test was introduced with **Camunda 8.8**.
- You must use **JUnit 5** in every test class. The `@Test` annotation you import must be `org.junit.jupiter.api.Test`.
  :::

1. Use [_JUnit 5_](http://junit.org) as your unit test framework.
2. Use the [Camunda Spring Boot Starter](../../../apis-tools/camunda-spring-boot-starter/getting-started.md).
3. Use `@CamundaSpringProcessTest` to start a process engine.
4. Ensure you have Docker installed locally to use [TestContainers](../../../apis-tools/testing/getting-started.md#prerequisites), which is the easiest way to run tests.
5. Use assertions from [Camunda Process Test](../../../apis-tools/testing/assertions.md) to verify that your expectations about the process state are met.
6. Use a mocking framework of your choice (such as [Mockito](http://mockito.org)) to mock service methods and verify that services are called as expected.
7. Use utilities from [Camunda Process Test](../../../apis-tools/testing/utilities.md) to mock job workers you don't want to run (for example, connectors).

The following code shows an example test:

```java
@SpringBootTest(
    properties = {
      "camunda.client.worker.defaults.enabled=false", // disable job workers and enable them selectively
      "camunda.client.worker.override.archive-invoice.enabled=true",
    })
@CamundaSpringProcessTest
public class InvoiceApprovalTest {

  @Autowired
  private CamundaClient client;
  @Autowired
  private CamundaProcessTestContext processTestContext;
  @Autowired
  private ObjectMapper objectMapper;

  // Mock services that are called from the job workers
  @MockitoBean
  private ArchiveService archiveService;
  @MockitoBean
  private AccountingService accountingService;

  // Sample data used
  private final String invoiceJson =
      """
      {
        "id": "INV-1001",
        "amount": 12000,
        "currency": "EUR",
        "supplier": {
          "id": "0815",
          "name": "Acme GmbH"
        },
        "contactEmail": "accounting@acme.com"
      }""";

  @Test
  public void happyPath() throws Exception {
    final HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("approver", "Zee");
    variables.put("invoice", objectMapper.readTree(invoiceJson));

    // After all preparations, start the process instance
    final var processInstance =
        client
            .newCreateInstanceCommand()
            .bpmnProcessId("Process_InvoiceApproval")
            .latestVersion()
            .variables(variables)
            .send()
            .join();

    // assert the User Task was created
    assertThat(byElementId("UserTask_ApproveInvoice")).isCreated().hasAssignee("Zee");
    // and simulate the user completing it
    processTestContext.completeUserTask(byElementId("UserTask_ApproveInvoice"),
        Map.of("approved", true));

    // This should make the process instance execute to completion
    assertThat(processInstance)
        .hasCompletedElementsInOrder(
            byId("StartEvent_InvoiceReceived"),
            byId("UserTask_ApproveInvoice"),
            byId("ServiceTask_ArchiveInvoice"),
            byId("ServiceTask_AddInvoiceAccounting"),
            byId("EndEvent_InvoiceApproved"))
        .isCompleted();

    // verify that side effects have happened
    Mockito.verify(archiveService).archiveInvoice("INV-1001", objectMapper.readTree(invoiceJson));
    Mockito.verify(accountingService).addInvoiceToAccount("0815", "INV-1001");
  }
```

:::note
The complete source code for this example test is available on [GitHub](https://github.com/camunda/camunda/tree/main/testing/camunda-process-test-example/src/test/java/io/camunda/InvoiceApprovalTest.java).
:::

### Test scope and mocking

In a test case like this, you want to test the executable BPMN process definition, plus all the glue code that logically belongs to the process definition in a broader sense. Typical examples of glue code you want to include in a process test are:

- Worker code, typically connected to a service task
- Expressions (FEEL) used in your process model for gateway decisions or input/output mappings
- Other glue code, for example, your own Client API (probably exposed via REST) that performs data mapping before calling the Camunda Client.

The following illustration shows this for the invoice approval example:

![Process test scope example](testing-process-definitions-assets/process-test-scope-example.png)

Workflow engine-independent business code should _not_ be included in the tests. In the invoice approval example, the `ArchiveService` will be mocked, and the `ArchiveInvoiceWorker` will read and transform process variables and call this mock. This way, you can test the process model, the glue code, and the data flow in your process test without calling out to the real archive system.

The following code examples highlight the important aspects around mocking.

The `ArchiveInvoiceWorker` is executed as part of the test. It does input data mapping **(1)** and also translates a specific business exception into a BPMN error **(2)**:

```java
@Component
public class ArchiveInvoiceWorker {

  private final ArchiveService service;
  public ArchiveInvoiceWorker(final ArchiveService service) {
    this.service = service;
  }

  @JobWorker(type = "archive-invoice")
  public void handleJob(
      @Variable("invoiceId") final String invoiceId, // <1>
      @Variable("invoice") final JsonNode invoiceJson) {
    try {
      service.archiveInvoice(invoiceId, invoiceJson);
    } catch (WiredLegacyException e) { // <2>
      throw new BpmnError(
          "LEGACY_ERROR_ARCHIVE", "The archive system had a problem: " + e.getMessage());
    }
  }
}
```

The `ArchiveService` is considered a business service (it could, for example, wrap the archive system client SDK to make the appropriate remote calls) and should _not_ be executed during the test. This is why this interface is mocked in the test case:

```java
@MockitoBean
private ArchiveService archiveService;

@Test
public void happyPath() throws Exception {
  // ...
  // Using Mockito you can verify a business method was called with the expected parameters
  Mockito.verify(archiveService).archiveInvoice("INV-1001", objectMapper.readTree(invoiceJson));
}

@Test
void testArchiveSystemError() throws Exception {
  // Using Mockito you can define what should happen when a method is called, in this case an exception is thrown to simulate a business error
  doThrow(new WiredLegacyException()).when(archiveService).archiveInvoice(anyString(), any());
  //...
}
```

Some workers might not delegate to a proper service class, which you can easily mock. The prime example is connectors. The invoice process uses the REST connector to trigger the invoice rejection via some REST API. To avoid calling the REST endpoint, you can mock the job worker that would be provided by the connector runtime:

```java
@Test
public void testRejectionPath() throws Exception {
  processTestContext.mockJobWorker("io.camunda:http-json:1").thenComplete();
  // ...
}
```

You could also mock the REST endpoint, which we touch on later discussing integration tests. Some projects consider REST mocking part of the unit test scope, and this is generally also fine, even if we see it as integration test scope by default.

You can use the same [utilities from Camunda Process Test](../../../apis-tools/testing/utilities.md) to mock other workers, where you simply do not want to run the job worker itself. Maybe the implementation is not clean, but beyond your control. However, we advise to use a proper service interface whenever possible instead of job worker mocking.

```java
// Define the mock
final JobWorkerMock addInvoiceJobWorkerMock =
    processTestContext
        .mockJobWorker("add-invoice-to-accounting")
        .withHandler(
            (jobClient, job) -> {
                jobClient
                    .newCompleteCommand(job)
                    // .variables(null) //  We could now also simulate setting some response values
                    .send()
                    .join();
            });

// ... drive the process ...

// and assert:
assertThat(addInvoiceJobWorkerMock.getInvocations())
    .as("add-invoice-to-accounting job worker called")
    .isEqualTo(1);

assertThat(addInvoiceJobWorkerMock.getActivatedJobs().get(0).getVariablesAsMap())
    .containsEntry("invoiceId", "INV-1001");
```

### Drive the process and assert the state

For tests, you drive the process from wait state to wait state and assert that you observe the expected process and variable states. For example, you might implement a test for the scenario when an invoice gets approved and processed without errors:

```java
@Test
public void happyPath() throws Exception {
    final HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("approver", "Zee");
    variables.put("invoice", objectMapper.readTree(invoiceJson));

    // Kick off the process instance // <1>
    final var processInstance =
        client
            .newCreateInstanceCommand()
            .bpmnProcessId("Process_InvoiceApproval")
            .latestVersion()
            .variables(variables)
            .send()
            .join();

    // assert the User Task and simulate a human decision // <2>
    assertThat(byElementId("UserTask_ApproveInvoice")).isCreated().hasAssignee("Zee");
    processTestContext.completeUserTask(
        byElementId("UserTask_ApproveInvoice"), Map.of("approved", true));

    // This should make the process instance execute till the end // <3>
    assertThat(processInstance)
        .hasCompletedElementsInOrder(
            byId("StartEvent_InvoiceReceived"),
            byId("UserTask_ApproveInvoice"),
            byId("ServiceTask_ArchiveInvoice"),
            byId("ServiceTask_AddInvoiceAccounting"),
            byId("EndEvent_InvoiceApproved"))
        .isCompleted();

    // verify that side effects have happened // <4>
    verify(archiveService).archiveInvoice("INV-1001", objectMapper.readTree(invoiceJson));
    verify(accountingService).addInvoiceToAccount("0815", "INV-1001");
  }
```

1. Create a new process instance. You may want to use some glue code to start your process (e.g. the REST API facade), or also create helper methods within your test class.

2. Drive the process through its wait states, e.g. by completing a waiting user task.

3. Assert that your process is in the expected state.

4. Verify with your mocking library that your business service methods were called as expected.

Be careful not to "overspecify" your test method by asserting too much. Your process definition will likely evolve in the future and such changes should break as little test code as possible, but just as much as necessary!

As a rule of thumb _always_ assert that the expected _external effects_ of your process really took place (e.g. that business services were called as expected). Additionally, carefully choose which aspects of _internal process state_ are important enough so that you want your test method to warn about any related change later on.

### Testing your process in chunks

Divide and conquer by _testing your process in chunks_. Consider the important chunks and paths the invoice approval process consists of:

1

The _happy path_: The invoice gets approved.

2

The invoice gets rejected.

3

A timeout on waiting for approval leads to an automatic approval.

4

An approved invoice can't get archived.

#### Testing the happy path

The happy path is kind of the default scenario with a positive outcome, so no exceptions or errors or deviations are experienced.

Fully test the happy path in one (big) test method. This makes sure you have one consistent data flow in your process. Additionally, it is easy to read and to understand, making it a great starting point for new developers to understand your process and process test case.

You were already exposed to the happy path in our example, which is the scenario that the invoice gets approved:

```java
@Test
public void happyPath() throws Exception {
    final HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("approver", "Zee");
    variables.put("invoice", objectMapper.readTree(invoiceJson));

    // Kick off the process instance // <1>
    final var processInstance =
        client
            .newCreateInstanceCommand()
            .bpmnProcessId("Process_InvoiceApproval")
            .latestVersion()
            .variables(variables)
            .send()
            .join();

    // assert the User Task and simulate a human decision // <2>
    assertThat(byElementId("UserTask_ApproveInvoice")).isCreated().hasAssignee("Zee");
    processTestContext.completeUserTask(
        byElementId("UserTask_ApproveInvoice"), Map.of("approved", true));

    // This should make the process instance execute till the end // <3>
    assertThat(processInstance)
        .hasCompletedElementsInOrder(
            byId("StartEvent_InvoiceReceived"),
            byId("UserTask_ApproveInvoice"),
            byId("ServiceTask_ArchiveInvoice"),
            byId("ServiceTask_AddInvoiceAccounting"),
            byId("EndEvent_InvoiceApproved"))
        .isCompleted();

    // verify that side effects have happened // <4>
    verify(archiveService).archiveInvoice("INV-1001", objectMapper.readTree(invoiceJson));
    verify(accountingService).addInvoiceToAccount("0815", "INV-1001");
  }
```

#### Testing detours

Test _forks/detours_ from the happy path as well as _errors/exceptional_ paths as chunks in separate test methods. This allows to unit test in meaningful units.

The tests for the exceptional paths are basically very similar to the happy path in our example.

2

The invoice gets rejected:

```java
@Test
public void testRejectionPath() throws Exception {
    final HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("approver", "Zee");
    variables.put("invoice", objectMapper.readTree(invoiceJson));

    // We skip HTTP for the simple unit test - mock the http connector
    processTestContext.mockJobWorker("io.camunda:http-json:1").thenComplete();

    // Kick of the process instance
    final var processInstance =
        client
            .newCreateInstanceCommand()
            .bpmnProcessId("Process_InvoiceApproval")
            .latestVersion()
            .variables(variables)
            .send()
            .join();

    // assert the User Task and simulate a human decision
    assertThat(byElementId("UserTask_ApproveInvoice")).isCreated().hasAssignee("Zee");
    processTestContext.completeUserTask(
        byElementId("UserTask_ApproveInvoice"),
        Map.of( //
            "approved",
            false, //
            "rejectionReason",
            "it is a test case :-)"));

    // This should make the process instance execute till the end
    assertThat(processInstance)
        .hasCompletedElementsInOrder(
            byId("StartEvent_InvoiceReceived"),
            byId("UserTask_ApproveInvoice"),
            byId("Gateway_Approved"),
            byId("ServiceTask_SendRejection"),
            byId("EndEvent_InvoiceRejected"))
        .isCompleted();
  }
```

3

A timeout on waiting for approval leads to an automatic approval:

```java
@Test
public void testApprovalTimeout() throws Exception {
    final HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("approver", "Zee");
    variables.put("invoice", objectMapper.readTree(invoiceJson));

    final var processInstance =
        client
            .newCreateInstanceCommand()
            .bpmnProcessId("Process_InvoiceApproval")
            .latestVersion()
            .variables(variables)
            .send()
            .join();

    // assert the User Task and simulate the timeout
    assertThat(processInstance).hasActiveElements("UserTask_ApproveInvoice");
    processTestContext.increaseTime(Duration.ofDays(5));

    // This should make the process instance auto approve and run till the end
    assertThat(processInstance)
        .isCompleted()
        .hasCompletedElementsInOrder(
            byId("StartEvent_InvoiceReceived"),
            byId("ServiceTask_ArchiveInvoice"),
            byId("ServiceTask_AddInvoiceAccounting"),
            byId("EndEvent_InvoiceApproved"))
        .hasTerminatedElements(byId("UserTask_ApproveInvoice"));
  }
```

4

An approved invoice can't get archived:

```java
@Test
public void testArchiveSystemError() throws Exception {
    final HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("approver", "Zee");
    variables.put("invoice", objectMapper.readTree(invoiceJson));

    doThrow(new WiredLegacyException()).when(archiveService).archiveInvoice(anyString(), any());

    final var processInstance =
        client
            .newCreateInstanceCommand()
            .bpmnProcessId("Process_InvoiceApproval")
            .latestVersion()
            .variables(variables)
            .send()
            .join();

    // approve the request
    assertThat(byElementId("UserTask_ApproveInvoice")).isCreated();
    processTestContext.completeUserTask(byElementId("UserTask_ApproveInvoice"),
      Map.of("approved", true));

    // This should lead to the exception being thrown, causing the process to end up in the user task designed to handle the problem.
    assertThat(byElementId("UserTask_ManuallyArchiveInvoice"))
        .isCreated();
        // The test for .hasCandidateGroup("archive-team") is probably not worth implementing
        // as it limits flexibility in model changes.
    processTestContext.completeUserTask(byElementId("UserTask_ManuallyArchiveInvoice"));

    assertThat(processInstance)
        .isCompleted()
        .hasCompletedElementsInOrder(
            byId("StartEvent_InvoiceReceived"),
            byId("UserTask_ApproveInvoice"),
            byId("UserTask_ManuallyArchiveInvoice"),
            byId("ServiceTask_AddInvoiceAccounting"),
            byId("EndEvent_InvoiceApproved"))
        .hasTerminatedElements(byId("ServiceTask_ArchiveInvoice"));
    verify(accountingService).addInvoiceToAccount("0815", "INV-1001");
  }
```

<!--
## Writing polyglot process tests

TODO

* How to provision / cleanup engine (API to create cluster)
* Use the API / Language client to drive your process
* No assertions available at the moment (probably use history API?)
* Assert side effects / workers

* Example in Node.js?
-->

## Integration tests

Test the process in a close-to-real-life environment. This verifies that it really works before releasing a new version of your process definition, which includes _human-driven_, _exploratory_ tests.

Clearly _define your goals_ for integration tests! Goals could be:

- End user & acceptance tests
- Complete end-to-end tests
- Performance & load tests, etc.

Carefully consider _automating_ tests on scope 3. You need to look at the overall effort spent on writing test automation code and maintaining it when compared with executing human-driven tests for your software project's lifespan. The best choice depends very much on the frequency of regression test runs.

Most effort is typically invested in setting up proper test data in surrounding systems.

Configure your tests to be dedicated integration tests, and separate them from unit or process tests.

You can use typical industry standard tools for integration testing together with Camunda.

### Mocking REST calls

Especially when using the Connector framework, there might be relevant logic to test in configuration of a connector, especially the input and output data mapping. To test those, you typically want to mock the endpoint, rather than the job worker.

In the invoice approval example, the `Send invoice rejection` task leverages an outbound REST connector. The service task might look like this in the BPMN XML:

```xml
<bpmn:serviceTask id="ServiceTask_SendRejection" name="Send invoice rejection" zeebe:modelerTemplate="io.camunda.connectors.HttpJson.v2">
  <bpmn:extensionElements>
    <zeebe:taskDefinition type="io.camunda:http-json:1" retries="3" />
    <zeebe:ioMapping>
      <zeebe:input target="method" source="POST" />
      <zeebe:input target="url"    source="{{secrets.INVOICE_REJECTION_URL}}/reject" />
      <zeebe:input target="body"   source="={ &#10;  &#34;invoiceId&#34; : invoice.id, &#10;  &#34;rejectionReason&#34;: rejectionReason&#10;}" />
      <!--. .. -->
  </bpmn:extensionElements>
</bpmn:serviceTask>
```

You can mock the REST endpoint using the Spring Boot integration of [WireMock](http://wiremock.org/), allowing you to stub the endpoint in your JUnit test and make it accessible to the TestContainers runtime.

1. Add the required [WireMock Spring Boot](https://wiremock.org/docs/spring-boot/) dependency to your project (`org.wiremock.integrations:wiremock-spring-boot`).
2. Add the annotation `@EnableWireMock` to your test class to start the WireMock server.
3. Use the secrets in Camunda to configure the endpoint of the REST call, which is best practice anyway to configure the URL in the environment. In the test you need to set it to the URL containing of the hostname `host.testcontainers.internal` and the WireMock server port.
4. Make sure the connector runtime is enabled in the test case, so that the out-of-the-box REST connector is executed.
5. Expose the WireMock server port to the TestContainers runtime before running the test case.

Here is the relevant source code:

```java

@EnableWireMock
@SpringBootTest(
    properties = {
        "camunda.client.worker.defaults.enabled=false",
        "camunda.process-test.connectors-enabled=true",
        "camunda.process-test.connectors-secrets.INVOICE_REJECTION_URL="
            + "http://host.testcontainers.internal:${wiremock.server.port}"
    })
@CamundaSpringProcessTest
public class InvoiceApprovalIntegrationTest {

  @Value("${wiremock.server.port}")
  private int wireMockPort;

  @BeforeEach
  void setup() {
    Testcontainers.exposeHostPorts(wireMockPort);
  }

  @Test
  public void testRejectionPath() throws Exception {
    // configure mock behavior
    stubFor(post("/reject").willReturn(aResponse().withStatus(200).withBody("ok")));

    // Now drive the test case as in a unit test shown above ...

    // Verify the mock was called
    verify(
        postRequestedFor(urlEqualTo("/reject"))
            .withRequestBody(
                equalToJson(
                    """
                    {
                      "invoiceId": "INV-1001",
                      "rejectionReason": "it is a test case :-)"
                    }""")));
  }
```

---

## Writing good workers

[Service tasks](/components/modeler/bpmn/service-tasks/service-tasks.md) within Camunda 8 require you to set a task type and implement [job workers](/components/concepts/job-workers.md) who perform whatever needs to be performed. This describes that you might want to:

1. Write all glue code in one application, separating different classes or functions for the different task types.
2. Think about idempotency and read or write as little data as possible from/to the process.
3. If you use Java 21 or later, prefer virtual threads for parallel workers that perform blocking I/O. Use reactive or async code when your runtime already uses it, or when you need extremely high throughput or low latency.

## Organizing glue code and workers in process solutions

Assume the following order fulfillment process, that needs to invoke three synchronous REST calls to the responsible systems (payment, inventory, and shipping) via custom glue code:

![order fulfillment example](writing-good-workers-assets/order-fulfillment-process.png)

Should you create three different applications with a worker for one task type each, or would it be better to process all task types within one application?

As a rule of thumb, we recommend implementing **all glue code in one application**, which then is the so-called **process solution** (as described in [Practical Process Automation](https://processautomationbook.com/)). This process solution might also include the BPMN process model itself, deployed during startup. Thus, you create a self-contained application that is easy to version, test, integrate, and deploy.

![Process solution](writing-good-workers-assets/process-solution.png)
Figure taken from [Practical Process Automation](https://processautomationbook.com/)

Thinking of Java, the three REST invocations might live in three classes within the same package (showing only two for brevity):

```java
public class RetrieveMoneyWorker {
  @JobWorker(type = "retrieveMoney", autoComplete = false)
  public void retrieveMoney(final JobClient client, final ActivatedJob job) {
    // ... code
  }
}
```

```java
public class FetchGoodsWorker {
  @JobWorker(type = "fetchGoods", autoComplete = false)
  public void fetchGoods(final JobClient client, final ActivatedJob job) {
    // ... code
  }
}
```

You can also pull the glue code for all task types into one class. Technically, it does not make any difference and some people find that structure in their code easier. If in doubt, the default is to create one class per task type.

There are exceptions when you might not want to have all glue code within one application:

1. You need to specifically control the load for one task type, like _scaling it out_ or _throttling it_. For example, if one service task is doing PDF generation, which is compute-intensive, you might need to scale it much more than all other glue code. On the other hand, it could also mean limiting the number of parallel generation jobs due to licensing limitations of your third-party PDF generation library.
2. You want to write glue code in different programming languages, for example, because writing specific logic in a specific language is much easier (like using Python for certain AI calculations or Java for certain mainframe integrations).

In this case, you would spread your workers into different applications. Most often, you might still have a main process solution that will also still deploy the process model. Only specific workers are carved out.

## Thinking about transactions, exceptions and idempotency of workers

Visit [dealing with problems and exceptions](../dealing-with-problems-and-exceptions/) to gain a better understanding of how workers deal with transactions and exceptions to the happy path, and find more details on how to write idempotent workers.

## Data minimization in workers

If performance or efficiency matters in your scenario, there are two rules about data in your workers you should be aware of:

1. Minimize what data you read for your job. In your job client, you can define which process variables you will need in your worker, and only these will be read and transferred, saving resources on the broker as well as network bandwidth.
2. Minimize what data you write on job completion. You should explicitly not transmit the input variables of a job upon completion, which might happen easily if you simply reuse the map of variables you received as input for submitting the result.

Not transmitting all variables saves resources and bandwidth, but serves another purpose as well: upon job completion, these variables are written to the process and might overwrite existing variables. If you have parallel paths in your process (e.g. [parallel gateway](/components/modeler/bpmn/parallel-gateways/parallel-gateways.md), [multiple instance](/components/modeler/bpmn/multi-instance/multi-instance.md)) this can lead to race conditions that you need to think about. The less data you write, the smaller the problem.

While the easiest way is to avoid large variables, one option to keep things light during job activation is to use the `FetchVariables` parameter.
Remember, by default, when this parameter is omitted, the job payload will contain _all_ variables visible within the scope ([see the variables documentation for more on that](../../concepts/variables.md).
This could mean tens or more variables, of arbitrary size, and it can be difficult to estimate how much this will represent in general.

We recommend you use the `FetchVariables` parameter, and only fetch the variables which your job handler needs. This will keep the amount of data transferred to a minimum, and will greatly help performance.

## Scaling workers

If you need to process a lot of jobs, you need to think about optimizing your workers.

Workers can control the number of jobs retrieved at once. In a busy system it makes sense to not only request one job, but probably 20 or even up to 50 jobs in one remote request to the workflow engine, and then start working on them locally. In a lesser utilized system, long polling is used to avoid delays when a job comes in. Long polling means the client’s request to fetch jobs is blocked until a job is received (or some timeout hits). Therefore, the client does not constantly need to ask.

You will have jobs in your local application that need to be processed. The worst case in terms of scalability is that you process the jobs sequentially one after the other. While this sounds bad, it is still a valid approach for many use cases, as most projects do not need any parallel processing in the worker code as they simply do not care whether a job is executed a second earlier or later. Think of a business process that is executed only some hundred times per day and includes mostly human tasks — a sequential worker is totally sufficient. In this case, you can skip this paragraph section.

However, you might need to do better and process jobs in parallel. In such a case, you should read on and understand the difference between writing blocking code on platform threads, blocking code on virtual threads, and non-blocking code.

### Blocking / synchronous code and thread pools

With blocking code a thread needs to wait (is blocked) until something finishes before it can move on. In the above example, making a REST call requires the client to wait for IO — the response. The CPU cannot compute anything during this time period, however, the thread cannot do anything else.

Assume that your worker shall invoke 20 REST requests, each taking around 100ms, this will take 2s in total to process. Your throughput can’t go beyond 10 jobs per second with one thread.

A common approach to scaling throughput beyond this limit is to leverage a thread pool. This works as blocked threads are not actively consuming CPU cores, so you can run more threads than CPU cores — since they are only waiting for I/O most of the time. In the above example with 100ms latency of REST calls, having a thread pool of 10 threads increases throughput to 100 jobs/second.

The downside of using thread pools is that you need to have a good understanding of your code, thread pools in general, and the concrete libraries being used. Typically, we do not recommend configuring platform thread pools yourself. In Java 21 and later, prefer virtual threads for workers that perform blocking I/O.

### Blocking code with virtual threads

Virtual threads let you keep a straightforward blocking programming model while avoiding the cost of assigning one platform thread to every blocked operation. This makes them a good default for Java workers that spend most of their time waiting for I/O, such as REST calls or database requests.

Use virtual threads when you run on Java 21 or later and want to process many I/O-bound jobs in parallel without rewriting your worker code into a reactive style. Reactive programming can still be useful for extremely high-throughput or low-latency scenarios where the lower overhead matters enough to justify the added complexity.

### Non-blocking / reactive code

Reactive programming uses a different approach to achieve parallel work: extract the waiting part from your code.

With a reactive HTTP client you will write code to issue the REST request, but then not block for the response. Instead, you define a callback as to what happens if the request returns. Most of you know this from JavaScript programming. Thus, the runtime can optimize the utilization of threads itself, without you the developer even knowing.

### Recommendation

In Java 21 and later, prefer virtual threads for I/O-bound job workers that need parallel processing. They keep worker code easier to read while avoiding most of the scalability limits of platform threads. Use reactive programming when your client stack already uses it, or when you need extremely high throughput or low latency and have measured that the lower overhead is worth the complexity.

## Performance best-practices

Most of the business logic in your process models will likely end up being worked on as a job. As such, optimizing how jobs are handled in Zeebe can have
a big impact on the performance of your system as a whole. Here are some best practices to keep things running smoothly.

### Reduce latency by enabling job streaming

We recommend enabling [job streaming](../../concepts/job-workers.md#job-streaming) in order to reduce latency to a maximum. Essentially, when using long polling,
your job workers have to periodically poll every partition in your Zeebe cluster to check if there are new jobs available. Additionally, they have to
balance polling aggressively with minimizing their impact on the cluster, which still has to handle all requests, even when no jobs are available. In large clusters, this can add a noticeable delay in the order of seconds, which can be unacceptable for certain workloads.

> [!Note]
> You can read more about the difference between long polling and job streaming [in this blog post](https://camunda.com/blog/2024/03/reducing-job-activation-delay-zeebe/).

As such, we recommend using job streaming if possible.

## Client library examples

Let’s go through a few code examples using Java, Node.js, and C#, using the corresponding client libraries. All [code is available on GitHub](https://github.com/berndruecker/camunda-cloud-clients-parallel-job-execution) and a [walk through recording is available on YouTube](https://youtu.be/ZHKz9l5yG3Q).

### Java

Using the [Java Client](https://github.com/camunda/camunda-platform-get-started/tree/master/java) you can write worker code like this:

```java
client.newWorker().jobType("retrieveMoney")
  .handler((jobClient, job) -> {
     //...
  }).open();
```

The [Camunda Spring Boot Starter](/apis-tools/camunda-spring-boot-starter/getting-started.md) provides a more elegant way of writing this, but also uses a normal worker from the Java client underneath. In this case, your code might look like this:

```java
@JobWorker(type = "retrieveMoney", autoComplete = false)
public void retrieveMoney(final JobClient client, final ActivatedJob job) {
  //...
}
```

In the background, a worker starts a polling component and [a thread pool](https://github.com/camunda-cloud/zeebe/blob/d24b31493b8e22ad3405ee183adfd5a546b7742e/clients/java/src/main/java/io/camunda/zeebe/client/impl/ZeebeClientImpl.java#L179-L183) to [handle the polled jobs](https://github.com/camunda/camunda/blob/d24b31493b8e22ad3405ee183adfd5a546b7742e/clients/java/src/main/java/io/camunda/zeebe/client/impl/worker/JobPoller.java#L109-L111). The [**default thread pool size is one**](https://github.com/camunda-cloud/zeebe/blob/760074f59bc1bcfb483fab4645501430f362a475/clients/java/src/main/java/io/camunda/zeebe/client/impl/ZeebeClientBuilderImpl.java#L49). If you need more, you can enable a thread pool:

```java
ZeebeClient client = ZeebeClient.newClientBuilder()
  .numJobWorkerExecutionThreads(5)
  .build();
```

In the Camunda Spring Boot Starter, you can do this using a [configuration](/apis-tools/camunda-spring-boot-starter/configuration.md#execution-threads).

Now, you can **leverage blocking code** for your REST call, for example, the `RestTemplate` inside Spring:

```java
@JobWorker(type = "rest", autoComplete = false)
public void blockingRestCall(final JobClient client, final ActivatedJob job) {
  LOGGER.info("Invoke REST call...");
  String response = restTemplate.getForObject( // <-- blocking call
    PAYMENT_URL, String.class);
  LOGGER.info("...finished. Compl