Package io.camunda.client

Interface CamundaClient

All Superinterfaces:
AutoCloseable, JobClient
All Known Implementing Classes:
CamundaClientImpl
public interface CamundaClient extends AutoCloseable, JobClient
The client to communicate with a Camunda broker/cluster.

  • Method Details

    • newClient

      static CamundaClient newClient()
      Returns:
      a new Camunda client with default configuration values. In order to customize configuration, use the methods newClientBuilder() or newClient(CamundaClientConfiguration). See CamundaClientBuilder for the configuration options and default values.

    • newClient

      static CamundaClient newClient(CamundaClientConfiguration configuration)
      Returns:
      a new CamundaClient using the provided configuration.

    • newClientBuilder

      static CamundaClientBuilder newClientBuilder()
      Returns:
      a builder to configure and create a new CamundaClient.

    • newCloudClientBuilder

      static CamundaClientCloudBuilderStep1 newCloudClientBuilder()
      Returns:
      a builder with convenient methods to connect to the Camunda Cloud cluster.

    • newTopologyRequest

      TopologyRequestStep1 newTopologyRequest()
      Request the current cluster topology. Can be used to inspect which brokers are available at which endpoint and which broker is the leader of which partition. 
       List<BrokerInfo> brokers = camundaClient
  .newTopologyRequest()
  .send()
  .join()
  .getBrokers();

  InetSocketAddress address = broker.getSocketAddress();

  List<PartitionInfo> partitions = broker.getPartitions();
      Returns:
      the request where you must call send()

    • getConfiguration

      CamundaClientConfiguration getConfiguration()
      Returns:
      the client's configuration

    • close

      void close()
      Specified by:
      close in interface AutoCloseable

    • newDeployCommand

      DeployProcessCommandStep1 newDeployCommand()
      Deprecated.
      since 8 for removal with 8.1, replaced by newDeployResourceCommand()
      Command to deploy new processes. 
       camundaClient
  .newDeployCommand()
  .addResourceFile("~/wf/process1.bpmn")
  .addResourceFile("~/wf/process2.bpmn")
  .send();
      Returns:
      a builder for the command

    • newDeployResourceCommand

      DeployResourceCommandStep1 newDeployResourceCommand()
      Command to deploy new resources, i.e. BPMN process models and DMN decision models. 
       camundaClient
  .newDeployCommand()
  .addResourceFile("~/wf/process1.bpmn")
  .addResourceFile("~/wf/process2.bpmn")
  .addResourceFile("~/dmn/decision.dmn")
  .send();
      Returns:
      a builder for the command

    • newCreateInstanceCommand

      CreateProcessInstanceCommandStep1 newCreateInstanceCommand()
      Command to create/start a new instance of a process. 
       camundaClient
  .newCreateInstanceCommand()
  .bpmnProcessId("my-process")
  .latestVersion()
  .variables(json)
  .send();
      Returns:
      a builder for the command

    • newModifyProcessInstanceCommand

      ModifyProcessInstanceCommandStep1 newModifyProcessInstanceCommand(long processInstanceKey)
      Command to modify a process instance. 
         camundaClient
    .newModifyProcessInstanceCommand(processInstanceKey)
    .activateElement("element1")
    .and()
    .activateElement("element2")
    .withVariables(globalScopedVariables)
    .withVariables(localScopedVariables, "element2")
    .and()
    .terminateElement("element3")
    .send();
      Parameters:
      processInstanceKey - the key which identifies the corresponding process instance
      Returns:
      a builder for the command

    • newMigrateProcessInstanceCommand

      @ExperimentalApi("https://github.com/camunda/camunda/issues/14907") MigrateProcessInstanceCommandStep1 newMigrateProcessInstanceCommand(long processInstanceKey)
      Command to migrate a process instance to a different process definition.

      The migration command contains a migration plan. Migration plan contains targetProcessDefinitionKey to indicate which process definition to use for the migration. Mapping instructions for the migration describe how to map elements from the source process definition to the target process definition.

      For example, let's consider we want to migrate process instance with key 1, target process definition key 2, a source process definition with a service task with id "task1" and the target process definition with a service task with id "task2". The migration command could be: 

      
 {
  "processInstanceKey": 1,
  "migrationPlan": {
   "targetProcessDefinitionKey": 2,
   "mappingInstructions": [
    {
     "sourceElementId": "task1",
     "targetElementId": "task2"
    }
   ]
  }
 }
 
      
 camundaClient
  .newMigrateProcessInstanceCommand(1L)
  .migrationPlan(2L)
  .addMappingInstruction("element1", "element2")
  .addMappingInstruction("element3", "element4")
  .send();
 
       final MigrationPlan migrationPlan =
         MigrationPlan.newBuilder()
             .withTargetProcessDefinitionKey(2L)
             .addMappingInstruction("element1", "element2")
             .addMappingInstruction("element3", "element4")
             .build();
 camundaClient
  .newMigrateProcessInstanceCommand(1L)
  .migrationPlan(migrationPlan)
  .send();
      Parameters:
      processInstanceKey - the key which refers to the process instance to migrate
      Returns:
      a builder for the command

    • newCancelInstanceCommand

      CancelProcessInstanceCommandStep1 newCancelInstanceCommand(long processInstanceKey)
      Command to cancel a process instance. 
       camundaClient
  .newCancelInstanceCommand(processInstanceKey)
  .send();
      Parameters:
      processInstanceKey - the key which identifies the corresponding process instance
      Returns:
      a builder for the command

    • newSetVariablesCommand

      SetVariablesCommandStep1 newSetVariablesCommand(long elementInstanceKey)
      Command to set and/or update the variables of a given flow element (e.g. process instance, task, etc.) 
       camundaClient
  .newSetVariablesCommand(elementInstanceKey)
  .variables(json)
  .send();
      Parameters:
      elementInstanceKey - the key of the element instance to set/update the variables for
      Returns:
      a builder for the command

    • newEvaluateDecisionCommand

      EvaluateDecisionCommandStep1 newEvaluateDecisionCommand()
      Command to evaluate a decision. 
       camundaClient
  .newEvaluateDecisionCommand()
  .decisionKey("my-decision")
  .variables(json)
  .send();
      Returns:
      a builder for the command

    • newPublishMessageCommand

      PublishMessageCommandStep1 newPublishMessageCommand()
      Command to publish a message which can be correlated to a process instance. 
       camundaClient
  .newPublishMessageCommand()
  .messageName("order canceled")
  .correlationKey(orderId)
  .variables(json)
  .send();
      Returns:
      a builder for the command

    • newCorrelateMessageCommand

      CorrelateMessageCommandStep1 newCorrelateMessageCommand()
      Command to correlate a message and wait for it to be correlated against a process instance. 
       camundaClient
  .newCorrelateMessageCommand()
  .messageName("order canceled")
  .correlationKey(orderId)
  .variables(json)
  .tenantId("tenant")
  .send();
      Returns:
      a builder for the command

    • newBroadcastSignalCommand

      BroadcastSignalCommandStep1 newBroadcastSignalCommand()
      Command to broadcast a signal. 
       camundaClient
  .newBroadcastSignalCommand()
  .signalName("signal")
  .variables(json)
  .send();
      Returns:
      a builder for the command

    • newResolveIncidentCommand

      ResolveIncidentCommandStep1 newResolveIncidentCommand(long incidentKey)
      Command to resolve an existing incident. 
       camundaClient
  .newResolveIncidentCommand(incidentKey)
  .send();
      Parameters:
      incidentKey - the key of the corresponding incident
      Returns:
      the builder for the command

    • newUpdateRetriesCommand

      UpdateRetriesJobCommandStep1 newUpdateRetriesCommand(long jobKey)
      Command to update the retries of a job. 
       long jobKey = ..;

 camundaClient
  .newUpdateRetriesCommand(jobKey)
  .retries(3)
  .send();

      If the given retries are greater than zero then this job will be picked up again by a job worker. This will not close a related incident, which still has to be marked as resolved with newResolveIncidentCommand(long incidentKey) .

      Parameters:
      jobKey - the key of the job to update
      Returns:
      a builder for the command

    • newUpdateRetriesCommand

      UpdateRetriesJobCommandStep1 newUpdateRetriesCommand(ActivatedJob job)
      Command to update the retries of a job. 
       ActivatedJob job= ..;

 camundaClient
  .newUpdateRetriesCommand(job)
  .retries(3)
  .send();

      If the given retries are greater than zero then this job will be picked up again by a job worker. This will not close a related incident, which still has to be marked as resolved with newResolveIncidentCommand(long incidentKey) .

      Parameters:
      job - the activated job
      Returns:
      a builder for the command

    • newUpdateTimeoutCommand

      UpdateTimeoutJobCommandStep1 newUpdateTimeoutCommand(long jobKey)
      Command to update the timeout of a job. 
       long jobKey = ..;

 camundaClient
  .newUpdateTimeoutCommand(jobKey)
  .timeout(100)
  .send();

      Timeout value in millis is used to calculate a new job deadline. This will happen when the command to update the timeline is processed. The timeout value will be added to the current time then.

      Parameters:
      jobKey - the key of the job to update
      Returns:
      a builder for the command

    • newUpdateTimeoutCommand

      UpdateTimeoutJobCommandStep1 newUpdateTimeoutCommand(ActivatedJob job)
      Command to update the timeout of a job. 
       ActivatedJob job= ..;

 camundaClient
  .newUpdateTimeoutCommand(job)
  .timeout(100)
  .send();

      Timeout value in millis is used to calculate a new job deadline. This will happen when the command to update the timeline is processed. The timeout value will be added to the current time then.

      Parameters:
      job - the activated job
      Returns:
      a builder for the command

    • newWorker

      JobWorkerBuilderStep1 newWorker()
      Registers a new job worker for jobs of a given type.

      After registration, the broker activates available jobs and assigns them to this worker. It then publishes them to the client. The given worker is called for every received job, works on them and eventually completes them. 

       JobWorker worker = camundaClient
  .newWorker()
  .jobType("payment")
  .handler(paymentHandler)
  .open();

 ...
 worker.close();
      Example JobHandler implementation: 
       public final class PaymentHandler implements JobHandler
 {
   @Override
   public void handle(JobClient client, JobEvent jobEvent)
   {
     String json = jobEvent.getVariables();
     // modify variables

     client
      .newCompleteCommand()
      .event(jobEvent)
      .variables(json)
      .send();
   }
 };
      Returns:
      a builder for the worker registration

    • newDeleteResourceCommand

      DeleteResourceCommandStep1 newDeleteResourceCommand(long resourceKey)
      Command to delete a resource. 
       camundaClient
  .newDeleteResourceCommand(resourceKey)
  .send();
      Parameters:
      resourceKey - the key of the resource
      Returns:
      the builder for the command

    • newUserTaskCompleteCommand

      CompleteUserTaskCommandStep1 newUserTaskCompleteCommand(long userTaskKey)
      Command to complete a user task. 
       long userTaskKey = ..;

 camundaClient
  .newUserTaskCompleteCommand(userTaskKey)
  .variables(map)
  .send();

      If the user task is linked to a process instance then this command will complete the related activity and continue the flow.

      This command is only sent via REST over HTTP, not via gRPC

      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the command

    • newUserTaskAssignCommand

      AssignUserTaskCommandStep1 newUserTaskAssignCommand(long userTaskKey)
      Command to assign a user task. 
       long userTaskKey = ..;

 camundaClient
  .newUserTaskAssignCommand(userTaskKey)
  .assignee(newAssignee)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the command

    • newUserTaskUpdateCommand

      UpdateUserTaskCommandStep1 newUserTaskUpdateCommand(long userTaskKey)
      Command to update a user task. 
       long userTaskKey = ..;

 camundaClient
  .newUserTaskUpdateCommand(userTaskKey)
  .candidateGroups(newCandidateGroups)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the command

    • newUserTaskUnassignCommand

      UnassignUserTaskCommandStep1 newUserTaskUnassignCommand(long userTaskKey)
      Command to unassign a user task. 
       long userTaskKey = ..;

 camundaClient
  .newUserTaskUnassignCommand(userTaskKey)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the command

    • newUpdateJobCommand

      UpdateJobCommandStep1 newUpdateJobCommand(long jobKey)
      Command to update the retries and/or the timeout of a job. 
       JobChangeset changeset= ..;

 camundaClient
  .newUpdateCommand(jobKey)
  .update(changeset)
  .send();

      If the given retries are greater than zero then this job will be picked up again by a job worker. This will not close a related incident, which still has to be marked as resolved with newResolveIncidentCommand(long incidentKey) .

      Timeout value in millis is used to calculate a new job deadline. This will happen when the command to update the timeline is processed. The timeout value will be added to the current time then.

      Parameters:
      jobKey - the key of the job to update
      Returns:
      a builder for the command

    • newUpdateJobCommand

      UpdateJobCommandStep1 newUpdateJobCommand(ActivatedJob job)
      Command to update the retries and/or the timeout of a job. 
       ActivatedJob job= ..;
 JobChangeset changeset= ..;

 camundaClient
  .newUpdateCommand(job)
  .update(changeset)
  .send();

      If the given retries are greater than zero then this job will be picked up again by a job worker. This will not close a related incident, which still has to be marked as resolved with newResolveIncidentCommand(long incidentKey) .

      Timeout value in millis is used to calculate a new job deadline. This will happen when the command to update the timeline is processed. The timeout value will be added to the current time then.

      Parameters:
      job - the activated job
      Returns:
      a builder for the command

    • newClockPinCommand

      @ExperimentalApi("https://github.com/camunda/camunda/issues/21647") ClockPinCommandStep1 newClockPinCommand()
      Command to pin the Zeebe engine's internal clock to a specific time.

      This method initiates a command to pin the clock to a specified time. You can specify the time using either an epoch timestamp in milliseconds or an Instant object.

      Once pinned, the clock will remain at the specified time and will not advance until another pin or reset command is issued. This is useful for scenarios where you need to simulate process execution at a specific point in time.

      Example usage: 

      
 final long pinnedTime = 1742461285000L; // Thu, Mar 20, 2025 09:01:25 GMT+0000
 camundaClient
  .newClockPinCommand()
  .time(pinnedTime)
  .send();

 final Instant futureInstant = Instant.now().plus(Duration.ofDays(7));
 camundaClient
  .newClockPinCommand()
  .time(futureInstant)
  .send();

      The command is marked as experimental and may undergo changes or improvements in future releases.

      Returns:
      a builder for the command that allows setting either a timestamp or an instant

    • newClockResetCommand

      @ExperimentalApi("https://github.com/camunda/camunda/issues/21647") ClockResetCommandStep1 newClockResetCommand()
      Command to reset the Zeebe engine's internal clock to the system time.

      This command allows you to reset the clock to the current system time, effectively undoing any previous pin command that may have set the clock to a specific, static time. 

      
 camundaClient
  .newClockResetCommand()
  .send();

      The command is marked as experimental and may undergo changes or improvements in future releases.

      Returns:
      a builder for the command

    • newProcessDefinitionGetRequest

      ProcessDefinitionGetRequest newProcessDefinitionGetRequest(long processDefinitionKey)
      Gets a process definition by key. 
         long processDefinitionKey = ...;

   camundaClient
   .newProcessDefinitionGetRequest(processDefinitionKey)
   .send();
      Parameters:
      processDefinitionKey - the key of the process definition
      Returns:
      a builder for the request to get a process definition

    • newProcessDefinitionGetXmlRequest

      ProcessDefinitionGetXmlRequest newProcessDefinitionGetXmlRequest(long processDefinitionKey)

    • newProcessDefinitionGetFormRequest

      ProcessDefinitionGetFormRequest newProcessDefinitionGetFormRequest(long processDefinitionKey)

    • newProcessDefinitionQuery

      ProcessDefinitionQuery newProcessDefinitionQuery()
      Executes a search request to query process definitions. 
       long processDefinitionKey = ...;

 camundaClient
  .newProcessDefinitionQuery()
  .filter((f) -> f.processDefinitionKey(processDefinitionKey))
  .sort((s) -> s.name().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the process definition query

    • newProcessInstanceGetRequest

      ProcessInstanceGetRequest newProcessInstanceGetRequest(long processInstanceKey)
      Retrieves a process instance by key. 
       long processInstanceKey = ...;

 camundaClient
  .newProcessInstanceGetRequest(processInstanceKey)
  .send();
      Returns:
      a builder for the request to get a process instance

    • newProcessInstanceQuery

      ProcessInstanceQuery newProcessInstanceQuery()
      Executes a search request to query process instances. 
       long processInstanceKey = ...;

 camundaClient
  .newProcessInstanceQuery()
  .filter((f) -> f.processInstanceKeys(processInstanceKey))
  .sort((s) -> s.startDate().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the process instance query

    • newFlownodeInstanceQuery

      FlownodeInstanceQuery newFlownodeInstanceQuery()
      Executes a search request to query flow node instances. 
       long flownodeInstanceKey = ...;

 camundaClient
  .newFlownodeInstanceQuery()
  .filter((f) -> f.processInstanceKeys(processInstanceKey))
  .sort((s) -> s.flowNodeName().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the process instance query

    • newFlowNodeInstanceGetRequest

      FlowNodeInstanceGetRequest newFlowNodeInstanceGetRequest(long flowNodeInstanceKey)
      Gets a flow node instance by key. 
         long flowNodeInstanceKey = ...;

   camundaClient
   .newFlowNodeInstanceGetRequest(flowNodeInstanceKey)
   .send();
      Parameters:
      flowNodeInstanceKey - the key of the flow node instance
      Returns:
      a builder for the request to get a flow node instance

    • newUserTaskQuery

      UserTaskQuery newUserTaskQuery()
      Executes a search request to query user tasks. 
       camundaClient
  .newUserTaskQuery()
  .filter((f) -> f.userTaskKey(userTaskKey))
  .sort((s) -> s.creationDate().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the user task query

    • newDecisionRequirementsQuery

      DecisionRequirementsQuery newDecisionRequirementsQuery()
      Executes a search request to query Decision Requirements. 
         camundaClient
   .newDecisionRequirementsQuery()
   .filter((f) -> f.decisionRequirementsKey(decisionRequirementsKey))
   .sort((s) -> s.version().asc())
   .page((p) -> p.limit(100))
   .send();
      Returns:
      a builder for the decision requirements query

    • newDecisionDefinitionQuery

      DecisionDefinitionQuery newDecisionDefinitionQuery()

    • newDecisionDefinitionGetRequest

      DecisionDefinitionGetRequest newDecisionDefinitionGetRequest(long decisionDefinitionKey)
      Gets a decision definition by key. 
         long decisionDefinitionKey = ...;

   camundaClient
   .newDecisionDefinitionGetRequest(decisionDefinitionKey)
   .send();
      Parameters:
      decisionDefinitionKey - the key of the decision definition
      Returns:
      a builder for the request to get a decision definition

    • newDecisionDefinitionGetXmlRequest

      DecisionDefinitionGetXmlRequest newDecisionDefinitionGetXmlRequest(long decisionDefinitionKey)

    • newDecisionInstanceQuery

      DecisionInstanceQuery newDecisionInstanceQuery()
      Executes a search request to query decision instances. 
       long decisionInstanceKey = ...;

 camundaClient
  .newDecisionInstanceQuery()
  .filter((f) -> f.decisionInstanceKey(decisionInstanceKey))
  .sort((s) -> s.decisionInstanceKey().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the decision instance query

    • newDecisionInstanceGetRequest

      DecisionInstanceGetRequest newDecisionInstanceGetRequest(String decisionInstanceId)
      Retrieves a decision instance by id. 
       String decisionInstanceId = ...;

 camundaClient
 .newDecisionInstanceGetQuery(decisionInstanceId)
 .send();
      Parameters:
      decisionInstanceId - the id of the decision instance to fetch
      Returns:
      a builder for the request to get a decision instance

    • newIncidentQuery

      IncidentQuery newIncidentQuery()

    • newIncidentGetRequest

      IncidentGetRequest newIncidentGetRequest(long incidentKey)
      Gets an incident by key. 
         long incidentKey = ...;

   camundaClient
   .newIncidentGetRequest(incidentKey)
   .send();
      Parameters:
      incidentKey - the key of the incident
      Returns:
      a builder for the request to get an incident

    • newCreateRoleCommand

      CreateRoleCommandStep1 newCreateRoleCommand()
      Command to create a role. 
      

 camundaClient
  .newRoleCreateCommand()
  .name(name)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newCreateGroupCommand

      CreateGroupCommandStep1 newCreateGroupCommand()
      Command to create a group. 
      

 camundaClient
  .newCreateGroupCommand()
  .name(name)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newUpdateGroupCommand

      UpdateGroupCommandStep1 newUpdateGroupCommand(long groupKey)
      Command to update a group. 
      

 camundaClient
  .newUpdateGroupCommand(123L)
  .name(name)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newDeleteGroupCommand

      DeleteGroupCommandStep1 newDeleteGroupCommand(long groupKey)
      Command to delete a group. 
      

 camundaClient
  .newDeleteGroupCommand(123L)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newAssignUserToGroupCommand

      AssignUserToGroupCommandStep1 newAssignUserToGroupCommand(long groupKey)
      Command to assign a user to a group. 
      

 camundaClient
  .newAssignUserToGroupCommand(123L)
  .userKey(456L)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newUnassignUserFromGroupCommand

      UnassignUserFromGroupCommandStep1 newUnassignUserFromGroupCommand(long groupKey)
      Command to unassign a user from a group. 
      

 camundaClient
  .newUnassignUserFromGroupCommand(123L)
  .userKey(456L)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newUserCreateCommand

      CreateUserCommandStep1 newUserCreateCommand()
      Command to create a user. 
      

 camundaClient
  .newUserCreateCommand()
  .username(username)
  .email(email)
  .name(name)
  .password(password)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newCreateMappingCommand

      CreateMappingCommandStep1 newCreateMappingCommand()
      Command to create a mapping rule. 
       camundaClient
  .newCreateMappingCommand()
  .claimName(claimName)
  .claimValue(claimValue)
  .name(name)
  .send();

      This command is only sent via REST over HTTP, not via gRPC

      Returns:
      a builder for the command

    • newDecisionRequirementsGetXmlRequest

      DecisionRequirementsGetXmlRequest newDecisionRequirementsGetXmlRequest(long decisionRequirementsKey)

    • newDecisionRequirementsGetRequest

      DecisionRequirementsGetRequest newDecisionRequirementsGetRequest(long decisionRequirementsKey)
      Gets a decision requirements by key. 
         long decisionRequirementsKey = ...;

   camundaClient
   .newDecisionRequirementsGetRequest(decisionRequirementsKey)
   .send();
      Parameters:
      decisionRequirementsKey - the key of the decision requirements
      Returns:
      a builder for the request to get a decision requirements

    • newUserTaskGetFormRequest

      UserTaskGetFormRequest newUserTaskGetFormRequest(long userTaskKey)
      Gets a user task form by key. 
         long userTaskKey = ...;

   camundaClient
   .newUserTaskGetFormRequest(userTaskKey)
   .send();
      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the request to get a user task form

    • newUserTaskGetRequest

      UserTaskGetRequest newUserTaskGetRequest(long userTaskKey)
      Gets a User Task by key. 
         long userTaskKey = ...;

   camundaClient
   .newUserTaskGetRequest(userTaskKey)
   .send();
      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the request to get a user task

    • newVariableQuery

      VariableQuery newVariableQuery()
      Executes a search request to query variables. 
       camundaClient
  .newVariableQuery()
  .filter((f) -> f.variableKey(variableKey))
  .sort((s) -> s.value().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the variable query

    • newVariableGetRequest

      VariableGetRequest newVariableGetRequest(long variableKey)
      Gets a variable by key. 
         long variableKey = ...;

  camundaClient
 .newVariableGetRequest(variableKey)
 .send();
      Parameters:
      variableKey - the key of the variable
      Returns:
      a builder for the request to get a variable

    • newUserTaskVariableQuery

      UserTaskVariableQuery newUserTaskVariableQuery(long userTaskKey)
      Gets a variabes associated to a User Task key. 
         long variableKey = ...;

  camundaClient
 .newUserTaskVariableQuery(variableKey)
  .sort((s) -> s.value().asc())
  .page((p) -> p.limit(100))
 .send();
      Parameters:
      userTaskKey - the key of the user task
      Returns:
      a builder for the request to get the variables

    • newCreateDocumentCommand

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") CreateDocumentCommandStep1 newCreateDocumentCommand()
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to create a document. 

         camundaClient
   .newCreateDocumentCommand()
   .content(inputStream)
   .fileName("file.txt")
   .timeToLive(Duration.ofDays(1))
   .send();
      Returns:
      a builder for the command

    • newCreateDocumentBatchCommand

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") CreateDocumentBatchCommandStep1 newCreateDocumentBatchCommand()
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to create a batch of documents. Unlike newCreateDocumentCommand(), this command allows you to create multiple documents in a single request. This can be more efficient than creating each document individually, however, there are multiple limitations to consider.

      Limitations:

      • The gateway does not guarantee the atomicity of the batch operation. If the gateway receives the batch but fails to create one or more documents, it will not roll back the operation. This means that some documents may be created while others are not. The client should handle this scenario by checking the response for each document.
      • Each document in the batch must have a unique name.
      • It is not possible to assign a custom document ID to the documents in the batch. The document ID will be generated by the broker.
      • The total size of the batch must not exceed the multipart request size limit of the gateway.
      • The documents can only be created in a single store. If you need to create documents in multiple stores, you must create separate batches for each store. 

         zeebeClient
   .newCreateDocumentBatchCommand()
   .addDocument()
   .content(inputStream1)
   .fileName("file1.txt")
   .timeToLive(Duration.ofDays(1))
   .done()
   .addDocument()
   .content(inputStream2)
   .fileName("file2.txt")
   .timeToLive(Duration.ofDays(1))
   .done()
      Returns:
      a builder for the command

    • newDocumentContentGetRequest

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") DocumentContentGetRequest newDocumentContentGetRequest(String documentId)
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to get a document. 

         camundaClient
   .newDocumentContentGetRequest(documentId)
   .storeId(storeId)
   .send();
      Parameters:
      documentId - the id of the document
      Returns:
      a builder for the request

    • newDocumentContentGetRequest

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") DocumentContentGetRequest newDocumentContentGetRequest(DocumentReferenceResponse documentReferenceResponse)
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to get a document. 

         camundaClient
   .newDocumentContentGetRequest(documentReferenceResponse)
   .send();
      Parameters:
      documentReferenceResponse - the reference of the document
      Returns:
      a builder for the request

    • newCreateDocumentLinkCommand

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") CreateDocumentLinkCommandStep1 newCreateDocumentLinkCommand(String documentId)
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to update a document. 

         camundaClient
   .newCreateDocumentLinkCommand(documentId)
   .storeId(storeId)
   .timeToLive(Duration.ofHours(1))
   .send();
      Parameters:
      documentId - the id of the document
      Returns:
      a builder for the command

    • newCreateDocumentLinkCommand

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") CreateDocumentLinkCommandStep1 newCreateDocumentLinkCommand(DocumentReferenceResponse documentReferenceResponse)
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to update a document. 

         camundaClient
   .newCreateDocumentLinkCommand(documentReferenceResponse)
   .timeToLive(Duration.ofHours(1))
   .send();
      Parameters:
      documentReferenceResponse - the reference of the document
      Returns:
      a builder for the command

    • newDeleteDocumentCommand

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") DeleteDocumentCommandStep1 newDeleteDocumentCommand(String documentId)
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to update a document. 

         camundaClient
   .newDeleteDocumentCommand(documentId)
   .storeId(storeId)
   .send();
      Parameters:
      documentId - the id of the document
      Returns:
      a builder for the command

    • newDeleteDocumentCommand

      @ExperimentalApi("https://github.com/camunda/issues/issues/841") DeleteDocumentCommandStep1 newDeleteDocumentCommand(DocumentReferenceResponse documentReferenceResponse)
      Experimental: This method is under development. The respective API on compatible clusters cannot be considered production-ready. Thus, this method doesn't work out of the box with all clusters. Until this warning is removed, anything described below may not yet have taken effect, and the interface and its description are subject to change.

      Command to update a document. 

         camundaClient
   .newDeleteDocumentCommand(documentReferenceResponse)
   .send();
      Parameters:
      documentReferenceResponse - the reference of the document
      Returns:
      a builder for the command

    • newCreateTenantCommand

      CreateTenantCommandStep1 newCreateTenantCommand()
      Command to create a tenant. 
       camundaClient
  .newCreateTenantCommand()
  .tenantId("tenant-id")
  .name("Tenant Name")
  .send();
      Returns:
      a builder for the command

    • newUpdateTenantCommand

      UpdateTenantCommandStep1 newUpdateTenantCommand(String tenantId)
      Creates a command to update the name of an existing tenant.

      Example usage: 

       camundaClient
   .newUpdateTenantCommand("my-tenant-id") // Specify the tenant id
   .name("Updated Tenant Name")   // Set the new tenant name
   .send();                       // Send the command to the broker
      Parameters:
      tenantId - the unique identifier of the tenant to be updated
      Returns:
      a builder to configure and send the update tenant command

    • newDeleteTenantCommand

      DeleteTenantCommandStep1 newDeleteTenantCommand(String tenantId)
      Command to delete a tenant. 
       camundaClient
  .newDeleteTenantCommand(tenantKey)
  .send();
      Parameters:
      tenantId - the id of the tenant to delete
      Returns:
      a builder for the delete tenant command

    • newAssignMappingToTenantCommand

      AssignMappingToTenantCommandStep1 newAssignMappingToTenantCommand(long tenantKey)
      Command to assign a mapping rule to a tenant.

      Example usage: 

       camundaClient
   .newAssignMappingToTenantCommand(tenantKey)
   .mappingKey(mappingKey)
   .send();

      This command sends an HTTP PUT request to assign the specified mapping rule to the given tenant.

      Parameters:
      tenantKey - the unique identifier of the tenant
      Returns:
      a builder for the assign mapping rule to tenant command

    • newAssignUserToTenantCommand

      AssignUserToTenantCommandStep1 newAssignUserToTenantCommand(String tenantId)
      Command to assign a user to a tenant.

      Example usage: 

       camundaClient
   .newAssignUserToTenantCommand(tenantId)
   .username(username)
   .send();

      This command sends an HTTP PUT request to assign the specified user to the given tenant.

      Parameters:
      tenantId - the unique identifier of the tenant
      Returns:
      a builder for the assign user to tenant command

    • newRemoveUserFromTenantCommand

      RemoveUserFromTenantCommandStep1 newRemoveUserFromTenantCommand(String tenantId)
      Command to remove a user from a tenant.

      Example usage: 

       camundaClient
   .newRemoveUserFromTenantCommand(tenantId)
   .username(username)
   .send();

      This command sends an HTTP DELETE request to remove the specified user from the given tenant.

      Parameters:
      tenantId - the unique identifier of the tenant
      Returns:
      a builder for the remove user from tenant command

    • newAssignGroupToTenantCommand

      AssignGroupToTenantCommandStep1 newAssignGroupToTenantCommand(long tenantKey)
      Command to assign a group to a tenant.

      Example usage: 

       camundaClient
   .newAssignGroupToTenantCommand(tenantKey)
   .groupKey(groupKey)
   .send();
      Parameters:
      tenantKey - the unique identifier of the tenant
      Returns:
      a builder to configure and send the assign group to tenant command

    • newUnassignGroupFromTenantCommand

      UnassignGroupFromTenantCommandStep1 newUnassignGroupFromTenantCommand(long tenantKey)
      Command to unassign a group from a tenant.

      Example usage: 

       camundaClient
   .newUnassignGroupFromTenantCommand(tenantKey)
   .groupKey(groupKey)
   .send();
      Parameters:
      tenantKey - the unique identifier of the tenant
      Returns:
      a builder to configure and send the unassign group from tenant command

    • newCreateAuthorizationCommand

      CreateAuthorizationCommandStep1 newCreateAuthorizationCommand()
      Command to create an authorization

      Example usage: 

       camundaClient
   .newCreateAuthorizationCommand(tenantKey)
   .ownerId(ownerId)
   .ownerType(ownerType)
   .resourceId(resourceId)
   .resourceType(resourceType)
   .permission(PermissionType.READ)
   .send();
      Returns:
      a builder to configure and send the create authorization command

    • newDeleteAuthorizationCommand

      DeleteAuthorizationCommandStep1 newDeleteAuthorizationCommand(long authorizationKey)
      Command to delete an authorization

      Example usage: 

       camundaClient
   .newDeleteAuthorizationCommand(authorizationKey)
   .send();
      Parameters:
      authorizationKey - the key of the authorization to delete
      Returns:
      a builder to configure and send the delete authorization command

    • newUpdateAuthorizationCommand

      UpdateAuthorizationCommandStep1 newUpdateAuthorizationCommand(long authorizationKey)
      Command to update an authorization

      Example usage: 

       camundaClient
   .newUpdateAuthorizationCommand(authorizationKey)
   .ownerId(ownerId)
   .ownerType(ownerType)
   .resourceId(resourceId)
   .resourceType(resourceType)
   .permissionTypes(Set.of(PermissionType.READ))
   .send();
      Parameters:
      authorizationKey - the key of the authorization to update
      Returns:
      a builder to configure and send the update authorization command