Skip to main content
Version: 8.9 (unreleased)

Class: CamundaClient

Defined in: gen/CamundaClient.ts:1186

Constructors​

Constructor​

new CamundaClient(opts): CamundaClient;

Defined in: gen/CamundaClient.ts:1212

Parameters​

opts​

CamundaOptions = {}

Returns​

CamundaClient

Accessors​

config​

Get Signature​

get config(): Readonly<CamundaConfig>;

Defined in: gen/CamundaClient.ts:1330

Returns​

Readonly<CamundaConfig>

Methods​

_getSupportLogger()​

_getSupportLogger(): SupportLogger;

Defined in: gen/CamundaClient.ts:1459

Internal accessor for support logger (no public API commitment yet).

Returns​

SupportLogger

_invokeWithRetry()​

_invokeWithRetry<T>(op, opts): Promise<T>;

Defined in: gen/CamundaClient.ts:1492

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

Returns​

Promise<T>

activateAdHocSubProcessActivities()​

activateAdHocSubProcessActivities(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1578

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

Returns​

CancelablePromise<void>

Operation Id​

activateAdHocSubProcessActivities

Tags​

Ad-hoc sub-process

activateJobs()​

activateJobs(input): CancelablePromise<{
  jobs: EnrichedActivatedJob[];
}>;

Defined in: gen/CamundaClient.ts:1641

Activate jobs

Iterate through all known partitions and activate jobs up to the requested maximum.

Parameters​

input​

JobActivationRequest

Returns​

CancelablePromise<{ jobs: EnrichedActivatedJob[]; }>

Example​

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()​

assignClientToGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1702

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

Returns​

CancelablePromise<void>

Operation Id​

assignClientToGroup

Tags​

Group

assignClientToTenant()​

assignClientToTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1762

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

Returns​

CancelablePromise<void>

Operation Id​

assignClientToTenant

Tags​

Tenant

assignGroupToTenant()​

assignGroupToTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1822

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

Returns​

CancelablePromise<void>

Operation Id​

assignGroupToTenant

Tags​

Tenant

assignMappingRuleToGroup()​

assignMappingRuleToGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1880

Assign a mapping rule to a group

Assigns a mapping rule to a group.

Parameters​

input​

assignMappingRuleToGroupInput

Returns​

CancelablePromise<void>

Operation Id​

assignMappingRuleToGroup

Tags​

Group

assignMappingRuleToTenant()​

assignMappingRuleToTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1938

Assign a mapping rule to a tenant

Assign a single mapping rule to a specified tenant.

Parameters​

input​

assignMappingRuleToTenantInput

Returns​

CancelablePromise<void>

Operation Id​

assignMappingRuleToTenant

Tags​

Tenant

assignRoleToClient()​

assignRoleToClient(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:1996

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

Returns​

CancelablePromise<void>

Operation Id​

assignRoleToClient

Tags​

Role

assignRoleToGroup()​

assignRoleToGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2054

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

Returns​

CancelablePromise<void>

Operation Id​

assignRoleToGroup

Tags​

Role

assignRoleToMappingRule()​

assignRoleToMappingRule(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2112

Assign a role to a mapping rule

Assigns a role to a mapping rule.

Parameters​

input​

assignRoleToMappingRuleInput

Returns​

CancelablePromise<void>

Operation Id​

assignRoleToMappingRule

Tags​

Role

assignRoleToTenant()​

assignRoleToTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2172

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

Returns​

CancelablePromise<void>

Operation Id​

assignRoleToTenant

Tags​

Tenant

assignRoleToUser()​

assignRoleToUser(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2230

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

Returns​

CancelablePromise<void>

Operation Id​

assignRoleToUser

Tags​

Role

assignUserTask()​

assignUserTask(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2290

Assign user task

Assigns a user task with the given key to the given assignee.

Parameters​

input​

assignUserTaskInput

Returns​

CancelablePromise<void>

Example​

async function assignUserTaskExample() {
  const camunda = createCamundaClient();

  const userTaskKey = UserTaskKey.assumeExists("2251799813685249");

  await camunda.assignUserTask({
    userTaskKey,
    assignee: "alice",
    allowOverride: true,
  });
}

Operation Id​

assignUserTask

Tags​

User task

assignUserToGroup()​

assignUserToGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2352

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

Returns​

CancelablePromise<void>

Operation Id​

assignUserToGroup

Tags​

Group

assignUserToTenant()​

assignUserToTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2410

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

Returns​

CancelablePromise<void>

Operation Id​

assignUserToTenant

Tags​

Tenant

broadcastSignal()​

broadcastSignal(input): CancelablePromise<SignalBroadcastResult>;

Defined in: gen/CamundaClient.ts:2470

Broadcast signal

Broadcasts a signal.

Parameters​

input​

SignalBroadcastRequest

Returns​

CancelablePromise<SignalBroadcastResult>

Example​

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()​

cancelBatchOperation(input, consistencyManagement): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2535

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

consistencyManagement​

cancelBatchOperationConsistency

Returns​

CancelablePromise<void>

Operation Id​

cancelBatchOperation

Tags​

Batch operation

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

cancelProcessInstance()​

cancelProcessInstance(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2601

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.

Parameters​

input​

object & object

Returns​

CancelablePromise<void>

Example​

async function cancelProcessInstanceExample() {
  const camunda = createCamundaClient();

  // Create a process instance and get its key from the response
  const created = await camunda.createProcessInstance({
    processDefinitionId: ProcessDefinitionId.assumeExists("order-process"),
  });

  // Cancel the process instance using the key from the creation response
  await camunda.cancelProcessInstance({
    processInstanceKey: created.processInstanceKey,
  });
}

Operation Id​

cancelProcessInstance

Tags​

Process instance

cancelProcessInstancesBatchOperation()​

cancelProcessInstancesBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:2666

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​
filter​

ProcessInstanceFilter

The process instance filter.

operationReference?​

number

consistencyManagement​

cancelProcessInstancesBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

cancelProcessInstancesBatchOperation

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

clearAuthCache()​

clearAuthCache(opts?): void;

Defined in: gen/CamundaClient.ts:1438

Parameters​

opts?​
disk?​

boolean

memory?​

boolean

Returns​

void

completeJob()​

completeJob(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2731

Complete job

Complete a job with the given payload, which allows completing the associated service task.

Parameters​

input​

completeJobInput

Returns​

CancelablePromise<void>

Example​

async function completeJobExample() {
  const camunda = createCamundaClient();

  const jobKey = JobKey.assumeExists("2251799813685249");

  await camunda.completeJob({
    jobKey,
    variables: {
      paymentId: "PAY-123",
      status: "completed",
    },
  });
}

Operation Id​

completeJob

Tags​

Job

completeUserTask()​

completeUserTask(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:2793

Complete user task

Completes a user task with the given key.

Parameters​

input​

completeUserTaskInput

Returns​

CancelablePromise<void>

Example​

async function completeUserTaskExample() {
  const camunda = createCamundaClient();

  const userTaskKey = UserTaskKey.assumeExists("2251799813685249");

  await camunda.completeUserTask({
    userTaskKey,
    variables: {
      approved: true,
      comment: "Looks good",
    },
  });
}

Operation Id​

completeUserTask

Tags​

User task

configure()​

configure(next): void;

Defined in: gen/CamundaClient.ts:1342

Parameters​

next​

CamundaOptions

Returns​

void

correlateMessage()​

correlateMessage(input): CancelablePromise<MessageCorrelationResult>;

Defined in: gen/CamundaClient.ts:2859

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

Returns​

CancelablePromise<MessageCorrelationResult>

Example​

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()​

createAdminUser(input, consistencyManagement): CancelablePromise<UserCreateResult>;

Defined in: gen/CamundaClient.ts:2922

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

consistencyManagement​

createAdminUserConsistency

Returns​

CancelablePromise<UserCreateResult>

Operation Id​

createAdminUser

Tags​

Setup

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

createAuthorization()​

createAuthorization(input): CancelablePromise<AuthorizationCreateResult>;

Defined in: gen/CamundaClient.ts:2984

Create authorization

Create the authorization.

Parameters​

input​

AuthorizationIdBasedRequest | AuthorizationPropertyBasedRequest

Returns​

CancelablePromise<AuthorizationCreateResult>

Operation Id​

createAuthorization

Tags​

Authorization

createDeployment()​

createDeployment(input): CancelablePromise<ExtendedDeploymentResult>;

Defined in: gen/CamundaClient.ts:3047

Deploy resources

Deploys one or more resources (e.g. processes, decision models, or forms). This is an atomic call, i.e. either all resources are deployed or none of them are.

Parameters​

input​

createDeploymentInput

Returns​

CancelablePromise<ExtendedDeploymentResult>

Enriched deployment result with typed arrays (processes, decisions, decisionRequirements, forms, resources).

Example​

async function createDeploymentExample() {
  const camunda = createCamundaClient();

  const file = new File(["<xml/>"], "order-process.bpmn", {
    type: "application/xml",
  });

  const result = await camunda.createDeployment({
    resources: [file],
  });

  console.log(`Deployment key: ${result.deploymentKey}`);
  for (const process of result.processes ?? []) {
    console.log(
      `  Process: ${process.processDefinitionId} v${process.processDefinitionVersion}`
    );
  }
}

Operation Id​

createDeployment

Tags​

Resource

createDocument()​

createDocument(input): CancelablePromise<DocumentReference>;

Defined in: gen/CamundaClient.ts:3127

Upload document

Upload a document to the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)

Parameters​

input​

createDocumentInput

Returns​

CancelablePromise<DocumentReference>

Operation Id​

createDocument

Tags​

Document

createDocumentLink(input): CancelablePromise<DocumentLink>;

Defined in: gen/CamundaClient.ts:3190

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, GCP

Parameters​

input​

createDocumentLinkInput

Returns​

CancelablePromise<DocumentLink>

Operation Id​

createDocumentLink

Tags​

Document

createDocuments()​

createDocuments(input): CancelablePromise<DocumentCreationBatchResponse>;

Defined in: gen/CamundaClient.ts:3267

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, GCP, in-memory (non-production), local (non-production)

Parameters​

input​

createDocumentsInput

Returns​

CancelablePromise<DocumentCreationBatchResponse>

Operation Id​

createDocuments

Tags​

Document

createElementInstanceVariables()​

createElementInstanceVariables(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:3329

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.

Parameters​

input​

createElementInstanceVariablesInput

Returns​

CancelablePromise<void>

Operation Id​

createElementInstanceVariables

Tags​

Element instance

createGlobalClusterVariable()​

createGlobalClusterVariable(input): CancelablePromise<ClusterVariableResult>;

Defined in: gen/CamundaClient.ts:3389

Create a global-scoped cluster variable

Create a global-scoped cluster variable.

Parameters​

input​

CreateClusterVariableRequest

Returns​

CancelablePromise<ClusterVariableResult>

Operation Id​

createGlobalClusterVariable

Tags​

Cluster Variable

createGroup()​

createGroup(input): CancelablePromise<GroupCreateResult>;

Defined in: gen/CamundaClient.ts:3447

Create group

Create a new group.

Parameters​

input​

GroupCreateRequest

Returns​

CancelablePromise<GroupCreateResult>

Operation Id​

createGroup

Tags​

Group

createJobWorker()​

createJobWorker<In, Out, Headers>(cfg): JobWorker;

Defined in: gen/CamundaClient.ts:12362

Create a job worker that activates and processes jobs of the given type.

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<In, Out, Headers>

Worker configuration

Returns​

JobWorker

Examples​

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();
}
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()​

createMappingRule(input): CancelablePromise<MappingRuleCreateUpdateResult>;

Defined in: gen/CamundaClient.ts:3506

Create mapping rule

Create a new mapping rule

Parameters​

input​

MappingRuleCreateRequest

Returns​

CancelablePromise<MappingRuleCreateUpdateResult>

Operation Id​

createMappingRule

Tags​

Mapping rule

createProcessInstance()​

createProcessInstance(input): CancelablePromise<CreateProcessInstanceResult>;

Defined in: gen/CamundaClient.ts:3574

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​

{ awaitCompletion?: boolean; fetchVariables?: string[]; operationReference?: number; processDefinitionId: ProcessDefinitionId; processDefinitionVersion?: number; requestTimeout?: number; runtimeInstructions?: ProcessInstanceCreationRuntimeInstruction[]; startInstructions?: ProcessInstanceCreationStartInstruction[]; tags?: TagSet; tenantId?: TenantId; variables?: { [key: string]: unknown; }; }

awaitCompletion?​

boolean

Wait for the process instance to complete. If the process instance completion does not occur within the requestTimeout, the request will be closed. This can lead to a 504 response status. Disabled by default.

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?​

number

processDefinitionId​

ProcessDefinitionId

The BPMN process id of the process definition to start an instance of.

processDefinitionVersion?​

number

The version of the process. By default, the latest version of the process is used.

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?​

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?​

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?​

TagSet

tenantId?​

TenantId

The tenant id of the process definition.

variables?​

{ [key: string]: unknown; }

JSON object that will instantiate the variables for the root variable scope of the process instance.

|

{ awaitCompletion?: boolean; fetchVariables?: string[]; operationReference?: number; processDefinitionKey: ProcessDefinitionKey; processDefinitionVersion?: number; requestTimeout?: number; runtimeInstructions?: ProcessInstanceCreationRuntimeInstruction[]; startInstructions?: ProcessInstanceCreationStartInstruction[]; tags?: TagSet; tenantId?: TenantId; variables?: { [key: string]: unknown; }; }

awaitCompletion?​

boolean

Wait for the process instance to complete. If the process instance completion does not occur within the requestTimeout, the request will be closed. This can lead to a 504 response status. Disabled by default.

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?​

number

processDefinitionKey​

ProcessDefinitionKey

The unique key identifying the process definition, for example, returned for a process in the deploy resources endpoint.

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?​

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?​

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?​

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?​

TagSet

tenantId?​

TenantId

The tenant id of the process definition.

variables?​

{ [key: string]: unknown; }

JSON object that will instantiate the variables for the root variable scope of the process instance.

Returns​

CancelablePromise<CreateProcessInstanceResult>

Examples​

async function createProcessInstanceByIdExample() {
  const camunda = createCamundaClient();

  const result = await camunda.createProcessInstance({
    processDefinitionId: ProcessDefinitionId.assumeExists("order-process"),
    variables: {
      orderId: "ORD-12345",
      amount: 99.95,
    },
  });

  console.log(`Started process instance: ${result.processInstanceKey}`);
}
async function createProcessInstanceByKeyExample() {
  const camunda = createCamundaClient();

  // Key from a previous API response (e.g. deployment)
  const processDefinitionKey =
    ProcessDefinitionKey.assumeExists("2251799813685249");

  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()​

createRole(input): CancelablePromise<RoleCreateResult>;

Defined in: gen/CamundaClient.ts:3636

Create role

Create a new role.

Parameters​

input​

RoleCreateRequest

Returns​

CancelablePromise<RoleCreateResult>

Operation Id​

createRole

Tags​

Role

createTenant()​

createTenant(input): CancelablePromise<TenantCreateResult>;

Defined in: gen/CamundaClient.ts:3694

Create tenant

Creates a new tenant.

Parameters​

input​

TenantCreateRequest

Returns​

CancelablePromise<TenantCreateResult>

Operation Id​

createTenant

Tags​

Tenant

createTenantClusterVariable()​

createTenantClusterVariable(input): CancelablePromise<ClusterVariableResult>;

Defined in: gen/CamundaClient.ts:3752

Create a tenant-scoped cluster variable

Create a new cluster variable for the given tenant.

Parameters​

input​

createTenantClusterVariableInput

Returns​

CancelablePromise<ClusterVariableResult>

Operation Id​

createTenantClusterVariable

Tags​

Cluster Variable

createUser()​

createUser(input, consistencyManagement): CancelablePromise<UserCreateResult>;

Defined in: gen/CamundaClient.ts:3813

Create user

Create a new user.

Parameters​

input​

UserRequest

consistencyManagement​

createUserConsistency

Returns​

CancelablePromise<UserCreateResult>

Operation Id​

createUser

Tags​

User

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

deleteAuthorization()​

deleteAuthorization(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:3875

Delete authorization

Deletes the authorization with the given key.

Parameters​

input​

deleteAuthorizationInput

Returns​

CancelablePromise<void>

Operation Id​

deleteAuthorization

Tags​

Authorization

deleteDecisionInstance()​

deleteDecisionInstance(input, consistencyManagement): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:3934

Delete decision instance

Delete all associated decision evaluations based on provided key.

Parameters​

input​

object & object

consistencyManagement​

deleteDecisionInstanceConsistency

Returns​

CancelablePromise<void>

Operation Id​

deleteDecisionInstance

Tags​

Decision instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

deleteDecisionInstancesBatchOperation()​

deleteDecisionInstancesBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:4001

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​
filter​

{ decisionDefinitionId?: DecisionDefinitionId; decisionDefinitionKey?: DecisionDefinitionKeyFilterProperty; decisionDefinitionName?: string; decisionDefinitionType?: DecisionDefinitionTypeEnum; decisionDefinitionVersion?: number; decisionEvaluationInstanceKey?: DecisionEvaluationInstanceKeyFilterProperty; decisionEvaluationKey?: DecisionEvaluationKey; decisionRequirementsKey?: DecisionRequirementsKeyFilterProperty; elementInstanceKey?: ElementInstanceKeyFilterProperty; evaluationDate?: DateTimeFilterProperty; evaluationFailure?: string; processDefinitionKey?: ProcessDefinitionKey; processInstanceKey?: ProcessInstanceKey; rootDecisionDefinitionKey?: DecisionDefinitionKeyFilterProperty; state?: DecisionInstanceStateFilterProperty; tenantId?: TenantId; }

Decision instance search filter.

filter.decisionDefinitionId?​

DecisionDefinitionId

The ID of the DMN decision.

filter.decisionDefinitionKey?​

DecisionDefinitionKeyFilterProperty

The key of the decision.

filter.decisionDefinitionName?​

string

The name of the DMN decision.

filter.decisionDefinitionType?​

DecisionDefinitionTypeEnum

filter.decisionDefinitionVersion?​

number

The version of the decision.

filter.decisionEvaluationInstanceKey?​

DecisionEvaluationInstanceKeyFilterProperty

The key of the decision evaluation instance.

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

filter.decisionRequirementsKey?​

DecisionRequirementsKeyFilterProperty

The key of the decision requirements definition.

filter.elementInstanceKey?​

ElementInstanceKeyFilterProperty

The key of the element instance this decision instance is linked to.

filter.evaluationDate?​

DateTimeFilterProperty

The evaluation date of the decision instance.

filter.evaluationFailure?​

string

The evaluation failure of the decision instance.

filter.processDefinitionKey?​

ProcessDefinitionKey

The key of the process definition.

filter.processInstanceKey?​

ProcessInstanceKey

The key of the process instance.

filter.rootDecisionDefinitionKey?​

DecisionDefinitionKeyFilterProperty

The key of the root decision definition.

filter.state?​

DecisionInstanceStateFilterProperty

The state of the decision instance.

filter.tenantId?​

TenantId

The tenant ID of the decision instance.

operationReference?​

number

consistencyManagement​

deleteDecisionInstancesBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

deleteDecisionInstancesBatchOperation

Tags​

Decision instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

deleteDocument()​

deleteDocument(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4066

Delete document

Delete a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)

Parameters​

input​

deleteDocumentInput

Returns​

CancelablePromise<void>

Operation Id​

deleteDocument

Tags​

Document

deleteGlobalClusterVariable()​

deleteGlobalClusterVariable(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4126

Delete a global-scoped cluster variable

Delete a global-scoped cluster variable.

Parameters​

input​

deleteGlobalClusterVariableInput

Returns​

CancelablePromise<void>

Operation Id​

deleteGlobalClusterVariable

Tags​

Cluster Variable

deleteGroup()​

deleteGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4184

Delete group

Deletes the group with the given ID.

Parameters​

input​

deleteGroupInput

Returns​

CancelablePromise<void>

Operation Id​

deleteGroup

Tags​

Group

deleteMappingRule()​

deleteMappingRule(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4243

Delete a mapping rule

Deletes the mapping rule with the given ID.

Parameters​

input​

deleteMappingRuleInput

Returns​

CancelablePromise<void>

Operation Id​

deleteMappingRule

Tags​

Mapping rule

deleteProcessInstance()​

deleteProcessInstance(input, consistencyManagement): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4302

Delete process instance

Deletes a process instance. Only instances that are completed or terminated can be deleted.

Parameters​

input​

object & object

consistencyManagement​

deleteProcessInstanceConsistency

Returns​

CancelablePromise<void>

Operation Id​

deleteProcessInstance

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

deleteProcessInstancesBatchOperation()​

deleteProcessInstancesBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:4370

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​
filter​

ProcessInstanceFilter

The process instance filter.

operationReference?​

number

consistencyManagement​

deleteProcessInstancesBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

deleteProcessInstancesBatchOperation

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

deleteResource()​

deleteResource(input): CancelablePromise<DeleteResourceResponse>;

Defined in: gen/CamundaClient.ts:4446

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

Returns​

CancelablePromise<DeleteResourceResponse>

Example​

async function deleteResourceExample() {
  const camunda = createCamundaClient();

  // Use a process definition key as a resource key for deletion
  const resourceKey = ProcessDefinitionKey.assumeExists("2251799813685249");

  await camunda.deleteResource({
    resourceKey,
  });
}

Operation Id​

deleteResource

Tags​

Resource

deleteRole()​

deleteRole(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4506

Delete role

Deletes the role with the given ID.

Parameters​

input​

deleteRoleInput

Returns​

CancelablePromise<void>

Operation Id​

deleteRole

Tags​

Role

deleteTenant()​

deleteTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4564

Delete tenant

Deletes an existing tenant.

Parameters​

input​

deleteTenantInput

Returns​

CancelablePromise<void>

Operation Id​

deleteTenant

Tags​

Tenant

deleteTenantClusterVariable()​

deleteTenantClusterVariable(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4622

Delete a tenant-scoped cluster variable

Delete a tenant-scoped cluster variable.

Parameters​

input​

deleteTenantClusterVariableInput

Returns​

CancelablePromise<void>

Operation Id​

deleteTenantClusterVariable

Tags​

Cluster Variable

deleteUser()​

deleteUser(input, consistencyManagement): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4681

Delete user

Deletes a user.

Parameters​

input​

deleteUserInput

consistencyManagement​

deleteUserConsistency

Returns​

CancelablePromise<void>

Operation Id​

deleteUser

Tags​

User

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

deployResourcesFromFiles()​

deployResourcesFromFiles(resourceFilenames, options?): CancelablePromise<ExtendedDeploymentResult>;

Defined in: gen/CamundaClient.ts:12378

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<ExtendedDeploymentResult>

ExtendedDeploymentResult

emitSupportLogPreamble()​

emitSupportLogPreamble(): void;

Defined in: gen/CamundaClient.ts:1468

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()​

evaluateConditionals(input): CancelablePromise<EvaluateConditionalResult>;

Defined in: gen/CamundaClient.ts:4746

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

Returns​

CancelablePromise<EvaluateConditionalResult>

Operation Id​

evaluateConditionals

Tags​

Conditional

evaluateDecision()​

evaluateDecision(input): CancelablePromise<EvaluateDecisionResult>;

Defined in: gen/CamundaClient.ts:4816

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 | DecisionEvaluationByKey

Returns​

CancelablePromise<EvaluateDecisionResult>

Examples​

async function evaluateDecisionByIdExample() {
  const camunda = createCamundaClient();

  const result = await camunda.evaluateDecision({
    decisionDefinitionId: DecisionDefinitionId.assumeExists(
      "invoice-classification"
    ),
    variables: {
      amount: 1000,
      invoiceCategory: "Misc",
    },
  });

  console.log(`Decision: ${result.decisionDefinitionId}`);
  console.log(`Output: ${result.output}`);
}
async function evaluateDecisionByKeyExample() {
  const camunda = createCamundaClient();

  const decisionDefinitionKey =
    DecisionDefinitionKey.assumeExists("2251799813685249");

  const result = await camunda.evaluateDecision({
    decisionDefinitionKey,
    variables: {
      amount: 1000,
      invoiceCategory: "Misc",
    },
  });

  console.log(`Decision output: ${result.output}`);
}

Operation Id​

evaluateDecision

Tags​

Decision definition

evaluateExpression()​

evaluateExpression(input): CancelablePromise<ExpressionEvaluationResult>;

Defined in: gen/CamundaClient.ts:4878

Evaluate an expression

Evaluates a FEEL expression and returns the result. Supports references to tenant scoped cluster variables when a tenant ID is provided.

Parameters​

input​

ExpressionEvaluationRequest

Returns​

CancelablePromise<ExpressionEvaluationResult>

Operation Id​

evaluateExpression

Tags​

Expression

failJob()​

failJob(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:4943

Fail job

Mark the job as failed.

Parameters​

input​

failJobInput

Returns​

CancelablePromise<void>

Example​

async function failJobExample() {
  const camunda = createCamundaClient();

  const jobKey = JobKey.assumeExists("2251799813685249");

  await camunda.failJob({
    jobKey,
    retries: 2,
    errorMessage: "Payment gateway timeout",
    retryBackOff: 5000,
  });
}

Operation Id​

failJob

Tags​

Job

forceAuthRefresh()​

forceAuthRefresh(): Promise<string | undefined>;

Defined in: gen/CamundaClient.ts:1435

Returns​

Promise<string | undefined>

getAuditLog()​

getAuditLog(input, consistencyManagement): CancelablePromise<{
  actorId?: string;
  actorType?: AuditLogActorTypeEnum;
  annotation?: string;
  auditLogKey?: AuditLogKey;
  batchOperationKey?: BatchOperationKey;
  batchOperationType?: BatchOperationTypeEnum;
  category?: AuditLogCategoryEnum;
  decisionDefinitionId?: DecisionDefinitionId;
  decisionDefinitionKey?: DecisionDefinitionKey;
  decisionEvaluationKey?: DecisionEvaluationKey;
  decisionRequirementsId?: string;
  decisionRequirementsKey?: DecisionRequirementsKey;
  deploymentKey?: DeploymentKey;
  elementInstanceKey?: ElementInstanceKey;
  entityDescription?: string;
  entityKey?: AuditLogEntityKey;
  entityType?: AuditLogEntityTypeEnum;
  formKey?: FormKey;
  jobKey?: JobKey;
  operationType?: AuditLogOperationTypeEnum;
  processDefinitionId?: ProcessDefinitionId;
  processDefinitionKey?: ProcessDefinitionKey;
  processInstanceKey?: ProcessInstanceKey;
  relatedEntityKey?: AuditLogEntityKey;
  relatedEntityType?: AuditLogEntityTypeEnum;
  resourceKey?: ResourceKey;
  result?: AuditLogResultEnum;
  rootProcessInstanceKey?: ProcessInstanceKey;
  tenantId?: TenantId;
  timestamp?: string;
  userTaskKey?: UserTaskKey;
}>;

Defined in: gen/CamundaClient.ts:5004

Get audit log

Get an audit log entry by auditLogKey.

Parameters​

input​

getAuditLogInput

consistencyManagement​

getAuditLogConsistency

Returns​

CancelablePromise<{ actorId?: string; actorType?: AuditLogActorTypeEnum; annotation?: string; auditLogKey?: AuditLogKey; batchOperationKey?: BatchOperationKey; batchOperationType?: BatchOperationTypeEnum; category?: AuditLogCategoryEnum; decisionDefinitionId?: DecisionDefinitionId; decisionDefinitionKey?: DecisionDefinitionKey; decisionEvaluationKey?: DecisionEvaluationKey; decisionRequirementsId?: string; decisionRequirementsKey?: DecisionRequirementsKey; deploymentKey?: DeploymentKey; elementInstanceKey?: ElementInstanceKey; entityDescription?: string; entityKey?: AuditLogEntityKey; entityType?: AuditLogEntityTypeEnum; formKey?: FormKey; jobKey?: JobKey; operationType?: AuditLogOperationTypeEnum; processDefinitionId?: ProcessDefinitionId; processDefinitionKey?: ProcessDefinitionKey; processInstanceKey?: ProcessInstanceKey; relatedEntityKey?: AuditLogEntityKey; relatedEntityType?: AuditLogEntityTypeEnum; resourceKey?: ResourceKey; result?: AuditLogResultEnum; rootProcessInstanceKey?: ProcessInstanceKey; tenantId?: TenantId; timestamp?: string; userTaskKey?: UserTaskKey; }>

Operation Id​

getAuditLog

Tags​

Audit Log

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getAuthentication()​

getAuthentication(): CancelablePromise<CamundaUserResult>;

Defined in: gen/CamundaClient.ts:5066

Get current user

Retrieves the current authenticated user.

Returns​

CancelablePromise<CamundaUserResult>

Operation Id​

getAuthentication

Tags​

Authentication

getAuthHeaders()​

getAuthHeaders(): Promise<Record<string, string>>;

Defined in: gen/CamundaClient.ts:1432

Returns​

Promise<Record<string, string>>

getAuthorization()​

getAuthorization(input, consistencyManagement): CancelablePromise<AuthorizationResult>;

Defined in: gen/CamundaClient.ts:5116

Get authorization

Get authorization by the given key.

Parameters​

input​

getAuthorizationInput

consistencyManagement​

getAuthorizationConsistency

Returns​

CancelablePromise<AuthorizationResult>

Operation Id​

getAuthorization

Tags​

Authorization

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getBackpressureState()​

getBackpressureState():
  | {
  consecutive: number;
  permitsCurrent: number;
  permitsMax: number | null;
  severity: BackpressureSeverity;
  waiters: number;
}
  | {
  consecutive: number;
  permitsCurrent: number;
  permitsMax: null;
  severity: string;
  waiters: number;
};

Defined in: gen/CamundaClient.ts:1537

Public accessor for current backpressure adaptive limiter state (stable)

Returns​

| { consecutive: number; permitsCurrent: number; permitsMax: number | null; severity: BackpressureSeverity; waiters: number; } | { consecutive: number; permitsCurrent: number; permitsMax: null; severity: string; waiters: number; }

getBatchOperation()​

getBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationResponse>;

Defined in: gen/CamundaClient.ts:5179

Get batch operation

Get batch operation by key.

Parameters​

input​

getBatchOperationInput

consistencyManagement​

getBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationResponse>

Operation Id​

getBatchOperation

Tags​

Batch operation

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getConfig()​

getConfig(): Readonly<CamundaConfig>;

Defined in: gen/CamundaClient.ts:1337

Read-only snapshot of current hydrated configuration (do not mutate directly). Use configure(...) to apply changes.

Returns​

Readonly<CamundaConfig>

getDecisionDefinition()​

getDecisionDefinition(input, consistencyManagement): CancelablePromise<DecisionDefinitionResult>;

Defined in: gen/CamundaClient.ts:5244

Get decision definition

Returns a decision definition by key.

Parameters​

input​

getDecisionDefinitionInput

consistencyManagement​

getDecisionDefinitionConsistency

Returns​

CancelablePromise<DecisionDefinitionResult>

Example​

async function getDecisionDefinitionExample() {
  const camunda = createCamundaClient();

  const decisionDefinitionKey =
    DecisionDefinitionKey.assumeExists("2251799813685249");

  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()​

getDecisionDefinitionXml(input, consistencyManagement): CancelablePromise<string>;

Defined in: gen/CamundaClient.ts:5307

Get decision definition XML

Returns decision definition as XML.

Parameters​

input​

getDecisionDefinitionXmlInput

consistencyManagement​

getDecisionDefinitionXmlConsistency

Returns​

CancelablePromise<string>

Operation Id​

getDecisionDefinitionXML

Tags​

Decision definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getDecisionInstance()​

getDecisionInstance(input, consistencyManagement): CancelablePromise<object & object>;

Defined in: gen/CamundaClient.ts:5370

Get decision instance

Returns a decision instance.

Parameters​

input​

getDecisionInstanceInput

consistencyManagement​

getDecisionInstanceConsistency

Returns​

CancelablePromise<object & object>

Operation Id​

getDecisionInstance

Tags​

Decision instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getDecisionRequirements()​

getDecisionRequirements(input, consistencyManagement): CancelablePromise<DecisionRequirementsResult>;

Defined in: gen/CamundaClient.ts:5433

Get decision requirements

Returns Decision Requirements as JSON.

Parameters​

input​

getDecisionRequirementsInput

consistencyManagement​

getDecisionRequirementsConsistency

Returns​

CancelablePromise<DecisionRequirementsResult>

Operation Id​

getDecisionRequirements

Tags​

Decision requirements

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getDecisionRequirementsXml()​

getDecisionRequirementsXml(input, consistencyManagement): CancelablePromise<string>;

Defined in: gen/CamundaClient.ts:5496

Get decision requirements XML

Returns decision requirements as XML.

Parameters​

input​

getDecisionRequirementsXmlInput

consistencyManagement​

getDecisionRequirementsXmlConsistency

Returns​

CancelablePromise<string>

Operation Id​

getDecisionRequirementsXML

Tags​

Decision requirements

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getDocument()​

getDocument(input): CancelablePromise<Blob>;

Defined in: gen/CamundaClient.ts:5561

Download document

Download a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)

Parameters​

input​

getDocumentInput

Returns​

CancelablePromise<Blob>

Operation Id​

getDocument

Tags​

Document

getElementInstance()​

getElementInstance(input, consistencyManagement): CancelablePromise<{
  elementId: ElementId;
  elementInstanceKey: ElementInstanceKey;
  elementName: string;
  endDate?: string;
  hasIncident: boolean;
  incidentKey?: IncidentKey;
  processDefinitionId: ProcessDefinitionId;
  processDefinitionKey: ProcessDefinitionKey;
  processInstanceKey: ProcessInstanceKey;
  rootProcessInstanceKey?: ProcessInstanceKey;
  startDate: string;
  state: ElementInstanceStateEnum;
  tenantId: TenantId;
  type:   | "USER_TASK"
     | "UNKNOWN"
     | "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";
}>;

Defined in: gen/CamundaClient.ts:5622

Get element instance

Returns element instance as JSON.

Parameters​

input​

getElementInstanceInput

consistencyManagement​

getElementInstanceConsistency

Returns​

CancelablePromise<{ elementId: ElementId; elementInstanceKey: ElementInstanceKey; elementName: string; endDate?: string; hasIncident: boolean; incidentKey?: IncidentKey; processDefinitionId: ProcessDefinitionId; processDefinitionKey: ProcessDefinitionKey; processInstanceKey: ProcessInstanceKey; rootProcessInstanceKey?: ProcessInstanceKey; startDate: string; state: ElementInstanceStateEnum; tenantId: TenantId; type: | "USER_TASK" | "UNKNOWN" | "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"; }>

Operation Id​

getElementInstance

Tags​

Element instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getErrorMode()​

getErrorMode(): "result" | "throw";

Defined in: gen/CamundaClient.ts:1454

Internal accessor (read-only) for eventual consistency error mode.

Returns​

"result" | "throw"

getGlobalClusterVariable()​

getGlobalClusterVariable(input, consistencyManagement): CancelablePromise<ClusterVariableResult>;

Defined in: gen/CamundaClient.ts:5685

Get a global-scoped cluster variable

Get a global-scoped cluster variable.

Parameters​

input​

getGlobalClusterVariableInput

consistencyManagement​

getGlobalClusterVariableConsistency

Returns​

CancelablePromise<ClusterVariableResult>

Operation Id​

getGlobalClusterVariable

Tags​

Cluster Variable

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getGlobalJobStatistics()​

getGlobalJobStatistics(input, consistencyManagement): CancelablePromise<GlobalJobStatisticsQueryResult>;

Defined in: gen/CamundaClient.ts:5749

Global job statistics

Returns global aggregated counts for jobs. Optionally filter by the creation time window and/or jobType.

Parameters​

input​

getGlobalJobStatisticsInput

consistencyManagement​

getGlobalJobStatisticsConsistency

Returns​

CancelablePromise<GlobalJobStatisticsQueryResult>

Operation Id​

getGlobalJobStatistics

Tags​

Job

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getGroup()​

getGroup(input, consistencyManagement): CancelablePromise<GroupResult>;

Defined in: gen/CamundaClient.ts:5812

Get group

Get a group by its ID.

Parameters​

input​

getGroupInput

consistencyManagement​

getGroupConsistency

Returns​

CancelablePromise<GroupResult>

Operation Id​

getGroup

Tags​

Group

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getIncident()​

getIncident(input, consistencyManagement): CancelablePromise<{
  creationTime?: string;
  elementId?: ElementId;
  elementInstanceKey?: ElementInstanceKey;
  errorMessage?: string;
  errorType?: IncidentErrorTypeEnum;
  incidentKey?: IncidentKey;
  jobKey?: JobKey;
  processDefinitionId?: ProcessDefinitionId;
  processDefinitionKey?: ProcessDefinitionKey;
  processInstanceKey?: ProcessInstanceKey;
  rootProcessInstanceKey?: ProcessInstanceKey;
  state?: IncidentStateEnum;
  tenantId?: TenantId;
}>;

Defined in: gen/CamundaClient.ts:5878

Get incident

Returns incident as JSON.

Parameters​

input​

getIncidentInput

consistencyManagement​

getIncidentConsistency

Returns​

CancelablePromise<{ creationTime?: string; elementId?: ElementId; elementInstanceKey?: ElementInstanceKey; errorMessage?: string; errorType?: IncidentErrorTypeEnum; incidentKey?: IncidentKey; jobKey?: JobKey; processDefinitionId?: ProcessDefinitionId; processDefinitionKey?: ProcessDefinitionKey; processInstanceKey?: ProcessInstanceKey; rootProcessInstanceKey?: ProcessInstanceKey; state?: IncidentStateEnum; tenantId?: TenantId; }>

Example​

async function getIncidentExample() {
  const camunda = createCamundaClient();

  const incidentKey = IncidentKey.assumeExists("2251799813685249");

  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.

getLicense()​

getLicense(): CancelablePromise<LicenseResponse>;

Defined in: gen/CamundaClient.ts:5940

Get license status

Obtains the status of the current Camunda license.

Returns​

CancelablePromise<LicenseResponse>

Operation Id​

getLicense

Tags​

License

getMappingRule()​

getMappingRule(input, consistencyManagement): CancelablePromise<MappingRuleResult>;

Defined in: gen/CamundaClient.ts:5991

Get a mapping rule

Gets the mapping rule with the given ID.

Parameters​

input​

getMappingRuleInput

consistencyManagement​

getMappingRuleConsistency

Returns​

CancelablePromise<MappingRuleResult>

Operation Id​

getMappingRule

Tags​

Mapping rule

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessDefinition()​

getProcessDefinition(input, consistencyManagement): CancelablePromise<ProcessDefinitionResult>;

Defined in: gen/CamundaClient.ts:6054

Get process definition

Returns process definition as JSON.

Parameters​

input​

getProcessDefinitionInput

consistencyManagement​

getProcessDefinitionConsistency

Returns​

CancelablePromise<ProcessDefinitionResult>

Operation Id​

getProcessDefinition

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessDefinitionInstanceStatistics()​

getProcessDefinitionInstanceStatistics(input, consistencyManagement): CancelablePromise<ProcessDefinitionInstanceStatisticsQueryResult>;

Defined in: gen/CamundaClient.ts:6118

Get process instance statistics

Get statistics about process instances, grouped by process definition and tenant.

Parameters​

input​
page?​

OffsetPagination

sort?​

object[]

Sort field criteria.

consistencyManagement​

getProcessDefinitionInstanceStatisticsConsistency

Returns​

CancelablePromise<ProcessDefinitionInstanceStatisticsQueryResult>

Operation Id​

getProcessDefinitionInstanceStatistics

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessDefinitionInstanceVersionStatistics()​

getProcessDefinitionInstanceVersionStatistics(input, consistencyManagement): CancelablePromise<ProcessDefinitionInstanceVersionStatisticsQueryResult>;

Defined in: gen/CamundaClient.ts:6183

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​
filter​

ProcessDefinitionInstanceVersionStatisticsFilter

The process definition instance version statistics search filters.

page?​

OffsetPagination

Pagination criteria.

sort?​

object[]

Sort field criteria.

consistencyManagement​

getProcessDefinitionInstanceVersionStatisticsConsistency

Returns​

CancelablePromise<ProcessDefinitionInstanceVersionStatisticsQueryResult>

Operation Id​

getProcessDefinitionInstanceVersionStatistics

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessDefinitionMessageSubscriptionStatistics()​

getProcessDefinitionMessageSubscriptionStatistics(input, consistencyManagement): CancelablePromise<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>;

Defined in: gen/CamundaClient.ts:6247

Get message subscription statistics

Get message subscription statistics, grouped by process definition.

Parameters​

input​
filter?​

{ correlationKey?: StringFilterProperty; elementId?: StringFilterProperty; elementInstanceKey?: ElementInstanceKeyFilterProperty; lastUpdatedDate?: DateTimeFilterProperty; messageName?: StringFilterProperty; messageSubscriptionKey?: MessageSubscriptionKeyFilterProperty; messageSubscriptionState?: MessageSubscriptionStateFilterProperty; processDefinitionId?: StringFilterProperty; processDefinitionKey?: ProcessDefinitionKeyFilterProperty; processInstanceKey?: ProcessInstanceKeyFilterProperty; tenantId?: StringFilterProperty; }

Message subscription search filter.

filter.correlationKey?​

StringFilterProperty

The correlation key of the message subscription.

filter.elementId?​

StringFilterProperty

The element ID associated with this message subscription.

filter.elementInstanceKey?​

ElementInstanceKeyFilterProperty

The element instance key associated with this message subscription.

filter.lastUpdatedDate?​

DateTimeFilterProperty

The last updated date of the message subscription.

filter.messageName?​

StringFilterProperty

The name of the message associated with the message subscription.

filter.messageSubscriptionKey?​

MessageSubscriptionKeyFilterProperty

The message subscription key associated with this message subscription.

filter.messageSubscriptionState?​

MessageSubscriptionStateFilterProperty

The message subscription state.

filter.processDefinitionId?​

StringFilterProperty

The process definition ID associated with this message subscription.

filter.processDefinitionKey?​

ProcessDefinitionKeyFilterProperty

The process definition key associated with this correlated message subscription. This only works for data created with 8.9 and later.

filter.processInstanceKey?​

ProcessInstanceKeyFilterProperty

The process instance key associated with this message subscription.

filter.tenantId?​

StringFilterProperty

The unique external tenant ID.

page?​

CursorForwardPagination

consistencyManagement​

getProcessDefinitionMessageSubscriptionStatisticsConsistency

Returns​

CancelablePromise<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>

Operation Id​

getProcessDefinitionMessageSubscriptionStatistics

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessDefinitionStatistics()​

getProcessDefinitionStatistics(input, consistencyManagement): CancelablePromise<ProcessDefinitionElementStatisticsQueryResult>;

Defined in: gen/CamundaClient.ts:6310

Get process definition statistics

Get statistics about elements in currently running process instances by process definition key and search filter.

Parameters​

input​

getProcessDefinitionStatisticsInput

consistencyManagement​

getProcessDefinitionStatisticsConsistency

Returns​

CancelablePromise<ProcessDefinitionElementStatisticsQueryResult>

Operation Id​

getProcessDefinitionStatistics

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessDefinitionXml()​

getProcessDefinitionXml(input, consistencyManagement): CancelablePromise<string>;

Defined in: gen/CamundaClient.ts:6375

Get process definition XML

Returns process definition as XML.

Parameters​

input​

getProcessDefinitionXmlInput

consistencyManagement​

getProcessDefinitionXmlConsistency

Returns​

CancelablePromise<string>

Operation Id​

getProcessDefinitionXML

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessInstance()​

getProcessInstance(input, consistencyManagement): CancelablePromise<{
  endDate?: string;
  hasIncident: boolean;
  parentElementInstanceKey?: ElementInstanceKey;
  parentProcessInstanceKey?: ProcessInstanceKey;
  processDefinitionId: ProcessDefinitionId;
  processDefinitionKey: ProcessDefinitionKey;
  processDefinitionName: string;
  processDefinitionVersion: number;
  processDefinitionVersionTag?: string;
  processInstanceKey: ProcessInstanceKey;
  rootProcessInstanceKey?: ProcessInstanceKey;
  startDate: string;
  state: ProcessInstanceStateEnum;
  tags?: TagSet;
  tenantId: TenantId;
}>;

Defined in: gen/CamundaClient.ts:6440

Get process instance

Get the process instance by the process instance key.

Parameters​

input​

getProcessInstanceInput

consistencyManagement​

getProcessInstanceConsistency

Returns​

CancelablePromise<{ endDate?: string; hasIncident: boolean; parentElementInstanceKey?: ElementInstanceKey; parentProcessInstanceKey?: ProcessInstanceKey; processDefinitionId: ProcessDefinitionId; processDefinitionKey: ProcessDefinitionKey; processDefinitionName: string; processDefinitionVersion: number; processDefinitionVersionTag?: string; processInstanceKey: ProcessInstanceKey; rootProcessInstanceKey?: ProcessInstanceKey; startDate: string; state: ProcessInstanceStateEnum; tags?: TagSet; tenantId: TenantId; }>

Example​

async function getProcessInstanceExample() {
  const camunda = createCamundaClient();

  const processInstanceKey =
    ProcessInstanceKey.assumeExists("2251799813685249");

  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()​

getProcessInstanceCallHierarchy(input, consistencyManagement): CancelablePromise<ProcessInstanceCallHierarchyEntry[]>;

Defined in: gen/CamundaClient.ts:6503

Get call hierarchy

Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance.

Parameters​

input​

getProcessInstanceCallHierarchyInput

consistencyManagement​

getProcessInstanceCallHierarchyConsistency

Returns​

CancelablePromise<ProcessInstanceCallHierarchyEntry[]>

Operation Id​

getProcessInstanceCallHierarchy

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessInstanceSequenceFlows()​

getProcessInstanceSequenceFlows(input, consistencyManagement): CancelablePromise<{
  items?: object[];
}>;

Defined in: gen/CamundaClient.ts:6566

Get sequence flows

Get sequence flows taken by the process instance.

Parameters​

input​

getProcessInstanceSequenceFlowsInput

consistencyManagement​

getProcessInstanceSequenceFlowsConsistency

Returns​

CancelablePromise<{ items?: object[]; }>

Operation Id​

getProcessInstanceSequenceFlows

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessInstanceStatistics()​

getProcessInstanceStatistics(input, consistencyManagement): CancelablePromise<ProcessInstanceElementStatisticsQueryResult>;

Defined in: gen/CamundaClient.ts:6629

Get element instance statistics

Get statistics about elements by the process instance key.

Parameters​

input​

getProcessInstanceStatisticsInput

consistencyManagement​

getProcessInstanceStatisticsConsistency

Returns​

CancelablePromise<ProcessInstanceElementStatisticsQueryResult>

Operation Id​

getProcessInstanceStatistics

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessInstanceStatisticsByDefinition()​

getProcessInstanceStatisticsByDefinition(input, consistencyManagement): CancelablePromise<IncidentProcessInstanceStatisticsByDefinitionQueryResult>;

Defined in: gen/CamundaClient.ts:6695

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

consistencyManagement​

getProcessInstanceStatisticsByDefinitionConsistency

Returns​

CancelablePromise<IncidentProcessInstanceStatisticsByDefinitionQueryResult>

Operation Id​

getProcessInstanceStatisticsByDefinition

Tags​

Incident

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getProcessInstanceStatisticsByError()​

getProcessInstanceStatisticsByError(input, consistencyManagement): CancelablePromise<IncidentProcessInstanceStatisticsByErrorQueryResult>;

Defined in: gen/CamundaClient.ts:6760

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

consistencyManagement​

getProcessInstanceStatisticsByErrorConsistency

Returns​

CancelablePromise<IncidentProcessInstanceStatisticsByErrorQueryResult>

Operation Id​

getProcessInstanceStatisticsByError

Tags​

Incident

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getResource()​

getResource(input): CancelablePromise<ResourceResult>;

Defined in: gen/CamundaClient.ts:6826

Get resource

Returns a deployed resource.

info

Currently, this endpoint only supports RPA resources.

Parameters​

input​

getResourceInput

Returns​

CancelablePromise<ResourceResult>

Operation Id​

getResource

Tags​

Resource

getResourceContent()​

getResourceContent(input): CancelablePromise<Blob>;

Defined in: gen/CamundaClient.ts:6888

Get resource content

Returns the content of a deployed resource.

info

Currently, this endpoint only supports RPA resources.

Parameters​

input​

getResourceContentInput

Returns​

CancelablePromise<Blob>

Operation Id​

getResourceContent

Tags​

Resource

getRole()​

getRole(input, consistencyManagement): CancelablePromise<RoleResult>;

Defined in: gen/CamundaClient.ts:6947

Get role

Get a role by its ID.

Parameters​

input​

getRoleInput

consistencyManagement​

getRoleConsistency

Returns​

CancelablePromise<RoleResult>

Operation Id​

getRole

Tags​

Role

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getStartProcessForm()​

getStartProcessForm(input, consistencyManagement): CancelablePromise<
  | void
  | {
  formId?: FormId;
  formKey?: FormKey;
  schema?: {
   [key: string]: unknown;
  };
  tenantId?: TenantId;
  version?: number;
}>;

Defined in: gen/CamundaClient.ts:7012

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

consistencyManagement​

getStartProcessFormConsistency

Returns​

CancelablePromise< | void | { formId?: FormId; formKey?: FormKey; schema?: { [key: string]: unknown; }; tenantId?: TenantId; version?: number; }>

Operation Id​

getStartProcessForm

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getStatus()​

getStatus(): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:7074

Get cluster status

Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader.

Returns​

CancelablePromise<void>

Operation Id​

getStatus

Tags​

Cluster

getTenant()​

getTenant(input, consistencyManagement): CancelablePromise<TenantResult>;

Defined in: gen/CamundaClient.ts:7124

Get tenant

Retrieves a single tenant by tenant ID.

Parameters​

input​

getTenantInput

consistencyManagement​

getTenantConsistency

Returns​

CancelablePromise<TenantResult>

Operation Id​

getTenant

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getTenantClusterVariable()​

getTenantClusterVariable(input, consistencyManagement): CancelablePromise<ClusterVariableResult>;

Defined in: gen/CamundaClient.ts:7187

Get a tenant-scoped cluster variable

Get a tenant-scoped cluster variable.

Parameters​

input​

getTenantClusterVariableInput

consistencyManagement​

getTenantClusterVariableConsistency

Returns​

CancelablePromise<ClusterVariableResult>

Operation Id​

getTenantClusterVariable

Tags​

Cluster Variable

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getTopology()​

getTopology(): CancelablePromise<TopologyResponse>;

Defined in: gen/CamundaClient.ts:7251

Get cluster topology

Obtains the current topology of the cluster the gateway is part of.

Returns​

CancelablePromise<TopologyResponse>

Example​

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()​

getUsageMetrics(input, consistencyManagement): CancelablePromise<UsageMetricsResponse>;

Defined in: gen/CamundaClient.ts:7301

Get usage metrics

Retrieve the usage metrics based on given criteria.

Parameters​

input​

getUsageMetricsInput

consistencyManagement​

getUsageMetricsConsistency

Returns​

CancelablePromise<UsageMetricsResponse>

Operation Id​

getUsageMetrics

Tags​

System

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getUser()​

getUser(input, consistencyManagement): CancelablePromise<UserResult>;

Defined in: gen/CamundaClient.ts:7364

Get user

Get a user by its username.

Parameters​

input​

getUserInput

consistencyManagement​

getUserConsistency

Returns​

CancelablePromise<UserResult>

Operation Id​

getUser

Tags​

User

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getUserTask()​

getUserTask(input, consistencyManagement): CancelablePromise<{
  assignee?: string;
  candidateGroups?: string[];
  candidateUsers?: string[];
  completionDate?: string;
  creationDate?: string;
  customHeaders?: {
   [key: string]: string;
  };
  dueDate?: string;
  elementId?: ElementId;
  elementInstanceKey?: ElementInstanceKey;
  externalFormReference?: string;
  followUpDate?: string;
  formKey?: FormKey;
  name?: string;
  priority?: number;
  processDefinitionId?: ProcessDefinitionId;
  processDefinitionKey?: ProcessDefinitionKey;
  processDefinitionVersion?: number;
  processInstanceKey?: ProcessInstanceKey;
  processName?: string;
  rootProcessInstanceKey?: ProcessInstanceKey;
  state?: UserTaskStateEnum;
  tags?: TagSet;
  tenantId?: TenantId;
  userTaskKey?: UserTaskKey;
}>;

Defined in: gen/CamundaClient.ts:7427

Get user task

Get the user task by the user task key.

Parameters​

input​

getUserTaskInput

consistencyManagement​

getUserTaskConsistency

Returns​

CancelablePromise<{ assignee?: string; candidateGroups?: string[]; candidateUsers?: string[]; completionDate?: string; creationDate?: string; customHeaders?: { [key: string]: string; }; dueDate?: string; elementId?: ElementId; elementInstanceKey?: ElementInstanceKey; externalFormReference?: string; followUpDate?: string; formKey?: FormKey; name?: string; priority?: number; processDefinitionId?: ProcessDefinitionId; processDefinitionKey?: ProcessDefinitionKey; processDefinitionVersion?: number; processInstanceKey?: ProcessInstanceKey; processName?: string; rootProcessInstanceKey?: ProcessInstanceKey; state?: UserTaskStateEnum; tags?: TagSet; tenantId?: TenantId; userTaskKey?: UserTaskKey; }>

Operation Id​

getUserTask

Tags​

User task

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getUserTaskForm()​

getUserTaskForm(input, consistencyManagement): CancelablePromise<
  | void
  | {
  formId?: FormId;
  formKey?: FormKey;
  schema?: {
   [key: string]: unknown;
  };
  tenantId?: TenantId;
  version?: number;
}>;

Defined in: gen/CamundaClient.ts:7492

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

consistencyManagement​

getUserTaskFormConsistency

Returns​

CancelablePromise< | void | { formId?: FormId; formKey?: FormKey; schema?: { [key: string]: unknown; }; tenantId?: TenantId; version?: number; }>

Operation Id​

getUserTaskForm

Tags​

User task

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getVariable()​

getVariable(input, consistencyManagement): CancelablePromise<object & object>;

Defined in: gen/CamundaClient.ts:7555

Get variable

Get the variable by the variable key.

Parameters​

input​

getVariableInput

consistencyManagement​

getVariableConsistency

Returns​

CancelablePromise<object & object>

Operation Id​

getVariable

Tags​

Variable

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

getWorkers()​

getWorkers(): any[];

Defined in: gen/CamundaClient.ts:1552

Return a read-only snapshot of currently registered job workers.

Returns​

any[]

logger()​

logger(scope?): Logger;

Defined in: gen/CamundaClient.ts:1449

Access a scoped logger (internal & future user emission).

Parameters​

scope?​

string

Returns​

Logger

migrateProcessInstance()​

migrateProcessInstance(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:7624

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

Returns​

CancelablePromise<void>

Operation Id​

migrateProcessInstance

Tags​

Process instance

migrateProcessInstancesBatchOperation()​

migrateProcessInstancesBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:7689

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​
filter​

ProcessInstanceFilter

The process instance filter.

migrationPlan​

ProcessInstanceMigrationBatchOperationPlan

The migration plan.

operationReference?​

number

consistencyManagement​

migrateProcessInstancesBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

migrateProcessInstancesBatchOperation

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

modifyProcessInstance()​

modifyProcessInstance(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:7757

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

Returns​

CancelablePromise<void>

Operation Id​

modifyProcessInstance

Tags​

Process instance

modifyProcessInstancesBatchOperation()​

modifyProcessInstancesBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:7824

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​
filter​

ProcessInstanceFilter

The process instance filter.

moveInstructions​

ProcessInstanceModificationMoveBatchOperationInstruction[]

Instructions for moving tokens between elements.

operationReference?​

number

consistencyManagement​

modifyProcessInstancesBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

modifyProcessInstancesBatchOperation

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

onAuthHeaders()​

onAuthHeaders(h): void;

Defined in: gen/CamundaClient.ts:1441

Parameters​

h​

(headers) => | Record<string, string> | Promise<Record<string, string>>

Returns​

void

pinClock()​

pinClock(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:7892

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

Returns​

CancelablePromise<void>

Operation Id​

pinClock

Tags​

Clock

publishMessage()​

publishMessage(input): CancelablePromise<{
  messageKey?: MessageKey;
  tenantId?: TenantId;
}>;

Defined in: gen/CamundaClient.ts:7957

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

Returns​

CancelablePromise<{ messageKey?: MessageKey; tenantId?: TenantId; }>

Example​

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()​

resetClock(): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:8025

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.

Returns​

CancelablePromise<void>

Operation Id​

resetClock

Tags​

Clock

resolveIncident()​

resolveIncident(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:8078

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

Returns​

CancelablePromise<void>

Example​

async function resolveIncidentExample() {
  const camunda = createCamundaClient();

  const incidentKey = IncidentKey.assumeExists("2251799813685249");

  await camunda.resolveIncident({ incidentKey });
}

Operation Id​

resolveIncident

Tags​

Incident

resolveIncidentsBatchOperation()​

resolveIncidentsBatchOperation(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:8143

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​
filter​

ProcessInstanceFilter

The process instance filter.

operationReference?​

number

consistencyManagement​

resolveIncidentsBatchOperationConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

resolveIncidentsBatchOperation

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

resolveProcessInstanceIncidents()​

resolveProcessInstanceIncidents(input, consistencyManagement): CancelablePromise<BatchOperationCreatedResult>;

Defined in: gen/CamundaClient.ts:8206

Resolve related incidents

Creates a batch operation to resolve multiple incidents of a process instance.

Parameters​

input​

resolveProcessInstanceIncidentsInput

consistencyManagement​

resolveProcessInstanceIncidentsConsistency

Returns​

CancelablePromise<BatchOperationCreatedResult>

Operation Id​

resolveProcessInstanceIncidents

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

resumeBatchOperation()​

resumeBatchOperation(input, consistencyManagement): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:8271

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

consistencyManagement​

resumeBatchOperationConsistency

Returns​

CancelablePromise<void>

Operation Id​

resumeBatchOperation

Tags​

Batch operation

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchAuditLogs()​

searchAuditLogs(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:8336

Search audit logs

Search for audit logs based on given criteria.

Parameters​

input​

AuditLogSearchQueryRequest

consistencyManagement​

searchAuditLogsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchAuditLogs

Tags​

Audit Log

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchAuthorizations()​

searchAuthorizations(input, consistencyManagement): CancelablePromise<AuthorizationSearchResult>;

Defined in: gen/CamundaClient.ts:8399

Search authorizations

Search for authorizations based on given criteria.

Parameters​

input​

AuthorizationSearchQuery

consistencyManagement​

searchAuthorizationsConsistency

Returns​

CancelablePromise<AuthorizationSearchResult>

Operation Id​

searchAuthorizations

Tags​

Authorization

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchBatchOperationItems()​

searchBatchOperationItems(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:8462

Search batch operation items

Search for batch operation items based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchBatchOperationItemsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchBatchOperationItems

Tags​

Batch operation

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchBatchOperations()​

searchBatchOperations(input, consistencyManagement): CancelablePromise<BatchOperationSearchQueryResult>;

Defined in: gen/CamundaClient.ts:8525

Search batch operations

Search for batch operations based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchBatchOperationsConsistency

Returns​

CancelablePromise<BatchOperationSearchQueryResult>

Operation Id​

searchBatchOperations

Tags​

Batch operation

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchClientsForGroup()​

searchClientsForGroup(input, consistencyManagement): CancelablePromise<TenantClientSearchResult>;

Defined in: gen/CamundaClient.ts:8588

Search group clients

Search clients assigned to a group.

Parameters​

input​

searchClientsForGroupInput

consistencyManagement​

searchClientsForGroupConsistency

Returns​

CancelablePromise<TenantClientSearchResult>

Operation Id​

searchClientsForGroup

Tags​

Group

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchClientsForRole()​

searchClientsForRole(input, consistencyManagement): CancelablePromise<TenantClientSearchResult>;

Defined in: gen/CamundaClient.ts:8653

Search role clients

Search clients with assigned role.

Parameters​

input​

searchClientsForRoleInput

consistencyManagement​

searchClientsForRoleConsistency

Returns​

CancelablePromise<TenantClientSearchResult>

Operation Id​

searchClientsForRole

Tags​

Role

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchClientsForTenant()​

searchClientsForTenant(input, consistencyManagement): CancelablePromise<TenantClientSearchResult>;

Defined in: gen/CamundaClient.ts:8718

Search clients for tenant

Retrieves a filtered and sorted list of clients for a specified tenant.

Parameters​

input​

searchClientsForTenantInput

consistencyManagement​

searchClientsForTenantConsistency

Returns​

CancelablePromise<TenantClientSearchResult>

Operation Id​

searchClientsForTenant

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchClusterVariables()​

searchClusterVariables(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:8781

Search for cluster variables based on given criteria. By default, long variable values in the response are truncated.

Parameters​

input​

searchClusterVariablesInput

consistencyManagement​

searchClusterVariablesConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchClusterVariables

Tags​

Cluster Variable

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchCorrelatedMessageSubscriptions()​

searchCorrelatedMessageSubscriptions(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:8846

Search correlated message subscriptions

Search correlated message subscriptions based on given criteria.

Parameters​

input​

CorrelatedMessageSubscriptionSearchQuery

consistencyManagement​

searchCorrelatedMessageSubscriptionsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchCorrelatedMessageSubscriptions

Tags​

Message subscription

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchDecisionDefinitions()​

searchDecisionDefinitions(input, consistencyManagement): CancelablePromise<DecisionDefinitionSearchQueryResult>;

Defined in: gen/CamundaClient.ts:8911

Search decision definitions

Search for decision definitions based on given criteria.

Parameters​

input​

DecisionDefinitionSearchQuery

consistencyManagement​

searchDecisionDefinitionsConsistency

Returns​

CancelablePromise<DecisionDefinitionSearchQueryResult>

Example​

async function searchDecisionDefinitionsExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchDecisionDefinitions(
    {
      filter: {
        decisionDefinitionId: DecisionDefinitionId.assumeExists(
          "invoice-classification"
        ),
      },
    },
    { 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()​

searchDecisionInstances(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:8974

Search decision instances

Search for decision instances based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchDecisionInstancesConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchDecisionInstances

Tags​

Decision instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchDecisionRequirements()​

searchDecisionRequirements(input, consistencyManagement): CancelablePromise<DecisionRequirementsSearchQueryResult>;

Defined in: gen/CamundaClient.ts:9037

Search decision requirements

Search for decision requirements based on given criteria.

Parameters​

input​

DecisionRequirementsSearchQuery

consistencyManagement​

searchDecisionRequirementsConsistency

Returns​

CancelablePromise<DecisionRequirementsSearchQueryResult>

Operation Id​

searchDecisionRequirements

Tags​

Decision requirements

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchElementInstanceIncidents()​

searchElementInstanceIncidents(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:9107

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

consistencyManagement​

searchElementInstanceIncidentsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchElementInstanceIncidents

Tags​

Element instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchElementInstances()​

searchElementInstances(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:9172

Search element instances

Search for element instances based on given criteria.

Parameters​

input​

ElementInstanceSearchQuery

consistencyManagement​

searchElementInstancesConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchElementInstances

Tags​

Element instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchGroupIdsForTenant()​

searchGroupIdsForTenant(input, consistencyManagement): CancelablePromise<TenantGroupSearchResult>;

Defined in: gen/CamundaClient.ts:9235

Search groups for tenant

Retrieves a filtered and sorted list of groups for a specified tenant.

Parameters​

input​

searchGroupIdsForTenantInput

consistencyManagement​

searchGroupIdsForTenantConsistency

Returns​

CancelablePromise<TenantGroupSearchResult>

Operation Id​

searchGroupIdsForTenant

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchGroups()​

searchGroups(input, consistencyManagement): CancelablePromise<GroupSearchQueryResult>;

Defined in: gen/CamundaClient.ts:9300

Search groups

Search for groups based on given criteria.

Parameters​

input​

GroupSearchQueryRequest

consistencyManagement​

searchGroupsConsistency

Returns​

CancelablePromise<GroupSearchQueryResult>

Operation Id​

searchGroups

Tags​

Group

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchGroupsForRole()​

searchGroupsForRole(input, consistencyManagement): CancelablePromise<RoleGroupSearchResult>;

Defined in: gen/CamundaClient.ts:9363

Search role groups

Search groups with assigned role.

Parameters​

input​

searchGroupsForRoleInput

consistencyManagement​

searchGroupsForRoleConsistency

Returns​

CancelablePromise<RoleGroupSearchResult>

Operation Id​

searchGroupsForRole

Tags​

Role

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchIncidents()​

searchIncidents(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:9431

Search incidents

Search for incidents based on given criteria.

Parameters​

input​

IncidentSearchQuery

consistencyManagement​

searchIncidentsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Example​

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()​

searchJobs(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:9494

Search jobs

Search for jobs based on given criteria.

Parameters​

input​

JobSearchQuery

consistencyManagement​

searchJobsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchJobs

Tags​

Job

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchMappingRule()​

searchMappingRule(input, consistencyManagement): CancelablePromise<MappingRuleSearchQueryResult>;

Defined in: gen/CamundaClient.ts:9558

Search mapping rules

Search for mapping rules based on given criteria.

Parameters​

input​

MappingRuleSearchQueryRequest

consistencyManagement​

searchMappingRuleConsistency

Returns​

CancelablePromise<MappingRuleSearchQueryResult>

Operation Id​

searchMappingRule

Tags​

Mapping rule

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchMappingRulesForGroup()​

searchMappingRulesForGroup(input, consistencyManagement): CancelablePromise<SearchQueryResponse>;

Defined in: gen/CamundaClient.ts:9621

Search group mapping rules

Search mapping rules assigned to a group.

Parameters​

input​

searchMappingRulesForGroupInput

consistencyManagement​

searchMappingRulesForGroupConsistency

Returns​

CancelablePromise<SearchQueryResponse>

Operation Id​

searchMappingRulesForGroup

Tags​

Group

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchMappingRulesForRole()​

searchMappingRulesForRole(input, consistencyManagement): CancelablePromise<SearchQueryResponse>;

Defined in: gen/CamundaClient.ts:9686

Search role mapping rules

Search mapping rules with assigned role.

Parameters​

input​

searchMappingRulesForRoleInput

consistencyManagement​

searchMappingRulesForRoleConsistency

Returns​

CancelablePromise<SearchQueryResponse>

Operation Id​

searchMappingRulesForRole

Tags​

Role

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchMappingRulesForTenant()​

searchMappingRulesForTenant(input, consistencyManagement): CancelablePromise<SearchQueryResponse>;

Defined in: gen/CamundaClient.ts:9751

Search mapping rules for tenant

Retrieves a filtered and sorted list of MappingRules for a specified tenant.

Parameters​

input​

searchMappingRulesForTenantInput

consistencyManagement​

searchMappingRulesForTenantConsistency

Returns​

CancelablePromise<SearchQueryResponse>

Operation Id​

searchMappingRulesForTenant

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchMessageSubscriptions()​

searchMessageSubscriptions(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:9816

Search message subscriptions

Search for message subscriptions based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchMessageSubscriptionsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchMessageSubscriptions

Tags​

Message subscription

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchProcessDefinitions()​

searchProcessDefinitions(input, consistencyManagement): CancelablePromise<ProcessDefinitionSearchQueryResult>;

Defined in: gen/CamundaClient.ts:9879

Search process definitions

Search for process definitions based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchProcessDefinitionsConsistency

Returns​

CancelablePromise<ProcessDefinitionSearchQueryResult>

Operation Id​

searchProcessDefinitions

Tags​

Process definition

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchProcessInstanceIncidents()​

searchProcessInstanceIncidents(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:9948

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

consistencyManagement​

searchProcessInstanceIncidentsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchProcessInstanceIncidents

Tags​

Process instance

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchProcessInstances()​

searchProcessInstances(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:10015

Search process instances

Search for process instances based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchProcessInstancesConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Example​

async function searchProcessInstancesExample() {
  const camunda = createCamundaClient();

  const result = await camunda.searchProcessInstances(
    {
      filter: {
        processDefinitionId: ProcessDefinitionId.assumeExists("order-process"),
      },
      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.

searchRoles()​

searchRoles(input, consistencyManagement): CancelablePromise<RoleSearchQueryResult>;

Defined in: gen/CamundaClient.ts:10078

Search roles

Search for roles based on given criteria.

Parameters​

input​

RoleSearchQueryRequest

consistencyManagement​

searchRolesConsistency

Returns​

CancelablePromise<RoleSearchQueryResult>

Operation Id​

searchRoles

Tags​

Role

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchRolesForGroup()​

searchRolesForGroup(input, consistencyManagement): CancelablePromise<SearchQueryResponse>;

Defined in: gen/CamundaClient.ts:10141

Search group roles

Search roles assigned to a group.

Parameters​

input​

searchRolesForGroupInput

consistencyManagement​

searchRolesForGroupConsistency

Returns​

CancelablePromise<SearchQueryResponse>

Operation Id​

searchRolesForGroup

Tags​

Group

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchRolesForTenant()​

searchRolesForTenant(input, consistencyManagement): CancelablePromise<SearchQueryResponse>;

Defined in: gen/CamundaClient.ts:10206

Search roles for tenant

Retrieves a filtered and sorted list of roles for a specified tenant.

Parameters​

input​

searchRolesForTenantInput

consistencyManagement​

searchRolesForTenantConsistency

Returns​

CancelablePromise<SearchQueryResponse>

Operation Id​

searchRolesForTenant

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchTenants()​

searchTenants(input, consistencyManagement): CancelablePromise<TenantSearchQueryResult>;

Defined in: gen/CamundaClient.ts:10271

Search tenants

Retrieves a filtered and sorted list of tenants.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchTenantsConsistency

Returns​

CancelablePromise<TenantSearchQueryResult>

Operation Id​

searchTenants

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchUsers()​

searchUsers(input, consistencyManagement): CancelablePromise<UserSearchResult>;

Defined in: gen/CamundaClient.ts:10334

Search users

Search for users based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchUsersConsistency

Returns​

CancelablePromise<UserSearchResult>

Operation Id​

searchUsers

Tags​

User

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchUsersForGroup()​

searchUsersForGroup(input, consistencyManagement): CancelablePromise<TenantUserSearchResult>;

Defined in: gen/CamundaClient.ts:10397

Search group users

Search users assigned to a group.

Parameters​

input​

searchUsersForGroupInput

consistencyManagement​

searchUsersForGroupConsistency

Returns​

CancelablePromise<TenantUserSearchResult>

Operation Id​

searchUsersForGroup

Tags​

Group

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchUsersForRole()​

searchUsersForRole(input, consistencyManagement): CancelablePromise<TenantUserSearchResult>;

Defined in: gen/CamundaClient.ts:10462

Search role users

Search users with assigned role.

Parameters​

input​

searchUsersForRoleInput

consistencyManagement​

searchUsersForRoleConsistency

Returns​

CancelablePromise<TenantUserSearchResult>

Operation Id​

searchUsersForRole

Tags​

Role

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchUsersForTenant()​

searchUsersForTenant(input, consistencyManagement): CancelablePromise<TenantUserSearchResult>;

Defined in: gen/CamundaClient.ts:10527

Search users for tenant

Retrieves a filtered and sorted list of users for a specified tenant.

Parameters​

input​

searchUsersForTenantInput

consistencyManagement​

searchUsersForTenantConsistency

Returns​

CancelablePromise<TenantUserSearchResult>

Operation Id​

searchUsersForTenant

Tags​

Tenant

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchUserTaskAuditLogs()​

searchUserTaskAuditLogs(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:10592

Search user task audit logs

Search for user task audit logs based on given criteria.

Parameters​

input​

searchUserTaskAuditLogsInput

consistencyManagement​

searchUserTaskAuditLogsConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchUserTaskAuditLogs

Tags​

User task

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchUserTasks()​

searchUserTasks(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:10659

Search user tasks

Search for user tasks based on given criteria.

Parameters​

input​

SearchQueryRequest & object

consistencyManagement​

searchUserTasksConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Example​

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()​

searchUserTaskVariables(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:10722

Search user task variables

Search for user task variables based on given criteria. By default, long variable values in the response are truncated.

Parameters​

input​

searchUserTaskVariablesInput

consistencyManagement​

searchUserTaskVariablesConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchUserTaskVariables

Tags​

User task

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

searchVariables()​

searchVariables(input, consistencyManagement): CancelablePromise<SearchQueryResponse & object>;

Defined in: gen/CamundaClient.ts:10789

Search variables

Search for process and local variables based on given criteria. By default, long variable values in the response are truncated.

Parameters​

input​

searchVariablesInput

consistencyManagement​

searchVariablesConsistency

Returns​

CancelablePromise<SearchQueryResponse & object>

Operation Id​

searchVariables

Tags​

Variable

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

stopAllWorkers()​

stopAllWorkers(): void;

Defined in: gen/CamundaClient.ts:1556

Stop all registered job workers (best-effort).

Returns​

void

suspendBatchOperation()​

suspendBatchOperation(input, consistencyManagement): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:10856

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

consistencyManagement​

suspendBatchOperationConsistency

Returns​

CancelablePromise<void>

Operation Id​

suspendBatchOperation

Tags​

Batch operation

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

throwJobError()​

throwJobError(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:10921

Throw error for job

Reports a business error (i.e. non-technical) that occurs while processing a job.

Parameters​

input​

throwJobErrorInput

Returns​

CancelablePromise<void>

Operation Id​

throwJobError

Tags​

Job

unassignClientFromGroup()​

unassignClientFromGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:10983

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

Returns​

CancelablePromise<void>

Operation Id​

unassignClientFromGroup

Tags​

Group

unassignClientFromTenant()​

unassignClientFromTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11043

Unassign a client from a tenant

Unassigns the client from the specified tenant. The client can no longer access tenant data.

Parameters​

input​

unassignClientFromTenantInput

Returns​

CancelablePromise<void>

Operation Id​

unassignClientFromTenant

Tags​

Tenant

unassignGroupFromTenant()​

unassignGroupFromTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11103

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

Returns​

CancelablePromise<void>

Operation Id​

unassignGroupFromTenant

Tags​

Tenant

unassignMappingRuleFromGroup()​

unassignMappingRuleFromGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11161

Unassign a mapping rule from a group

Unassigns a mapping rule from a group.

Parameters​

input​

unassignMappingRuleFromGroupInput

Returns​

CancelablePromise<void>

Operation Id​

unassignMappingRuleFromGroup

Tags​

Group

unassignMappingRuleFromTenant()​

unassignMappingRuleFromTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11219

Unassign a mapping rule from a tenant

Unassigns a single mapping rule from a specified tenant without deleting the rule.

Parameters​

input​

unassignMappingRuleFromTenantInput

Returns​

CancelablePromise<void>

Operation Id​

unassignMappingRuleFromTenant

Tags​

Tenant

unassignRoleFromClient()​

unassignRoleFromClient(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11277

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

Returns​

CancelablePromise<void>

Operation Id​

unassignRoleFromClient

Tags​

Role

unassignRoleFromGroup()​

unassignRoleFromGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11335

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

Returns​

CancelablePromise<void>

Operation Id​

unassignRoleFromGroup

Tags​

Role

unassignRoleFromMappingRule()​

unassignRoleFromMappingRule(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11393

Unassign a role from a mapping rule

Unassigns a role from a mapping rule.

Parameters​

input​

unassignRoleFromMappingRuleInput

Returns​

CancelablePromise<void>

Operation Id​

unassignRoleFromMappingRule

Tags​

Role

unassignRoleFromTenant()​

unassignRoleFromTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11454

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

Returns​

CancelablePromise<void>

Operation Id​

unassignRoleFromTenant

Tags​

Tenant

unassignRoleFromUser()​

unassignRoleFromUser(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11512

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

Returns​

CancelablePromise<void>

Operation Id​

unassignRoleFromUser

Tags​

Role

unassignUserFromGroup()​

unassignUserFromGroup(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11572

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

Returns​

CancelablePromise<void>

Operation Id​

unassignUserFromGroup

Tags​

Group

unassignUserFromTenant()​

unassignUserFromTenant(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11632

Unassign a user from a tenant

Unassigns the user from the specified tenant. The user can no longer access tenant data.

Parameters​

input​

unassignUserFromTenantInput

Returns​

CancelablePromise<void>

Operation Id​

unassignUserFromTenant

Tags​

Tenant

unassignUserTask()​

unassignUserTask(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11692

Unassign user task

Removes the assignee of a task with the given key.

Parameters​

input​

unassignUserTaskInput

Returns​

CancelablePromise<void>

Example​

async function unassignUserTaskExample() {
  const camunda = createCamundaClient();

  const userTaskKey = UserTaskKey.assumeExists("2251799813685249");

  await camunda.unassignUserTask({ userTaskKey });
}

Operation Id​

unassignUserTask

Tags​

User task

updateAuthorization()​

updateAuthorization(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11750

Update authorization

Update the authorization with the given key.

Parameters​

input​

updateAuthorizationInput

Returns​

CancelablePromise<void>

Operation Id​

updateAuthorization

Tags​

Authorization

updateGlobalClusterVariable()​

updateGlobalClusterVariable(input): CancelablePromise<ClusterVariableResult>;

Defined in: gen/CamundaClient.ts:11812

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

Returns​

CancelablePromise<ClusterVariableResult>

Operation Id​

updateGlobalClusterVariable

Tags​

Cluster Variable

updateGroup()​

updateGroup(input): CancelablePromise<GroupUpdateResult>;

Defined in: gen/CamundaClient.ts:11872

Update group

Update a group with the given ID.

Parameters​

input​

updateGroupInput

Returns​

CancelablePromise<GroupUpdateResult>

Operation Id​

updateGroup

Tags​

Group

updateJob()​

updateJob(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:11932

Update job

Update a job with the given key.

Parameters​

input​

updateJobInput

Returns​

CancelablePromise<void>

Operation Id​

updateJob

Tags​

Job

updateMappingRule()​

updateMappingRule(input): CancelablePromise<MappingRuleCreateUpdateResult>;

Defined in: gen/CamundaClient.ts:11993

Update mapping rule

Update a mapping rule.

Parameters​

input​

updateMappingRuleInput

Returns​

CancelablePromise<MappingRuleCreateUpdateResult>

Operation Id​

updateMappingRule

Tags​

Mapping rule

updateRole()​

updateRole(input): CancelablePromise<RoleUpdateResult>;

Defined in: gen/CamundaClient.ts:12053

Update role

Update a role with the given ID.

Parameters​

input​

updateRoleInput

Returns​

CancelablePromise<RoleUpdateResult>

Operation Id​

updateRole

Tags​

Role

updateTenant()​

updateTenant(input): CancelablePromise<TenantUpdateResult>;

Defined in: gen/CamundaClient.ts:12113

Update tenant

Updates an existing tenant.

Parameters​

input​

updateTenantInput

Returns​

CancelablePromise<TenantUpdateResult>

Operation Id​

updateTenant

Tags​

Tenant

updateTenantClusterVariable()​

updateTenantClusterVariable(input): CancelablePromise<ClusterVariableResult>;

Defined in: gen/CamundaClient.ts:12175

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

Returns​

CancelablePromise<ClusterVariableResult>

Operation Id​

updateTenantClusterVariable

Tags​

Cluster Variable

updateUser()​

updateUser(input, consistencyManagement): CancelablePromise<UserResult>;

Defined in: gen/CamundaClient.ts:12236

Update user

Updates a user.

Parameters​

input​

updateUserInput

consistencyManagement​

updateUserConsistency

Returns​

CancelablePromise<UserResult>

Operation Id​

updateUser

Tags​

User

Consistency​

eventual - this endpoint is backed by data that is eventually consistent with the system state.

updateUserTask()​

updateUserTask(input): CancelablePromise<void>;

Defined in: gen/CamundaClient.ts:12300

Update user task

Update a user task with the given key.

Parameters​

input​

updateUserTaskInput

Returns​

CancelablePromise<void>

Operation Id​

updateUserTask

Tags​

User task

withCorrelation()​

withCorrelation<T>(id, fn): Promise<T>;

Defined in: gen/CamundaClient.ts:1477

Type Parameters​

T​

T

Parameters​

id​

string

fn​

() => T | Promise<T>

Returns​

Promise<T>