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

    • newStatusRequest

      StatusRequestStep1 newStatusRequest()
      Request the current cluster status. Can be used to check if the cluster is healthy (has at least one partition with a healthy leader). 
       boolean isHealthy = camundaClient
  .newStatusRequest()
  .send()
  .join()
  .isHealthy();
      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

    • newCompleteUserTaskCommand

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

 camundaClient
  .newCompleteUserTaskCommand(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

    • newAssignUserTaskCommand

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

 camundaClient
  .newAssignUserTaskCommand(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

    • newUpdateUserTaskCommand

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

 camundaClient
  .newUpdateUserTaskCommand(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

    • newUnassignUserTaskCommand

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

 camundaClient
  .newUnassignUserTaskCommand(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

    • newPinClockCommand

      @ExperimentalApi("https://github.com/camunda/camunda/issues/21647") PinClockCommandStep1 newPinClockCommand()
      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
  .newPinClockCommand()
  .time(pinnedTime)
  .send();

 final Instant futureInstant = Instant.now().plus(Duration.ofDays(7));
 camundaClient
  .newPinClockCommand()
  .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

    • newResetClockCommand

      @ExperimentalApi("https://github.com/camunda/camunda/issues/21647") ResetClockCommandStep1 newResetClockCommand()
      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
  .newResetClockCommand()
  .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)

    • newProcessDefinitionSearchRequest

      ProcessDefinitionSearchRequest newProcessDefinitionSearchRequest()
      Executes a search request to query process definitions. 
       long processDefinitionKey = ...;

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

    • newProcessDefinitionElementStatisticsRequest

      ProcessDefinitionElementStatisticsRequest newProcessDefinitionElementStatisticsRequest(long processDefinitionKey)
      Executes a search request to query process definition element statistics. 
       long processDefinitionKey = ...;

 camundaClient
  .newProcessDefinitionElementStatisticsRequest(processDefinitionKey)
  .filter((f) -> f.processInstanceKey(processInstanceKey))
  .send();
      Returns:
      a builder for the process definition statistics request

    • newProcessInstanceElementStatisticsRequest

      ProcessInstanceElementStatisticsRequest newProcessInstanceElementStatisticsRequest(long processInstanceKey)
      Executes a search request to query process instance element statistics. 
       long processInstanceKey = ...;

 camundaClient
  .newProcessInstanceElementStatisticsRequest(processInstanceKey)
  .send();
      Returns:
      a builder for the process instance statistics request

    • newUsageMetricsRequest

      UsageMetricsStatisticsRequest newUsageMetricsRequest(OffsetDateTime startTime, OffsetDateTime endTime)
      Executes a search request to query usage metrics statistics. 
       camundaClient
  .newUsageMetricsRequest(OffsetDateTime.now().minusYears(1), OffsetDateTime.now())
  .withTenants(true)
  .send();
      Returns:
      a builder for the usage metrics statistics request

    • newProcessInstanceSequenceFlowsRequest

      ProcessInstanceSequenceFlowsRequest newProcessInstanceSequenceFlowsRequest(long processInstanceKey)
      Executes a search request to query process instance sequence flows. 
       long processInstanceKey = ...;

 camundaClient
  .newProcessInstanceSequenceFlowsRequest(processInstanceKey)
  .send();
      Returns:
      a builder for the process instance sequence flows request

    • 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

    • newProcessInstanceSearchRequest

      ProcessInstanceSearchRequest newProcessInstanceSearchRequest()
      Executes a search request to query process instances. 
       long processInstanceKey = ...;

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

    • newElementInstanceSearchRequest

      ElementInstanceSearchRequest newElementInstanceSearchRequest()
      Executes a search request to query element instances. 
       long elementInstanceKey = ...;

 camundaClient
  .newElementInstanceSearchRequest()
  .filter((f) -> f.processInstanceKeys(processInstanceKey))
  .sort((s) -> s.elementName().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the process instance search request

    • newElementInstanceGetRequest

      ElementInstanceGetRequest newElementInstanceGetRequest(long elementInstanceKey)
      Gets a element instance by key. 
         long elementInstanceKey = ...;

   camundaClient
   .newElementInstanceGetRequest(elementInstanceKey)
   .send();
      Parameters:
      elementInstanceKey - the key of the element instance
      Returns:
      a builder for the request to get a element instance

    • newActivateAdHocSubProcessActivitiesCommand

      ActivateAdHocSubProcessActivitiesCommandStep1 newActivateAdHocSubProcessActivitiesCommand(String adHocSubProcessInstanceKey)
      Command to activate activities within an activated ad-hoc sub-process. 
         camundaClient
    .newActivateAdHocSubProcessActivitiesCommand(adHocSubProcessInstanceKey)
    .activateElement("A")
    .activateElements("B", "C")
    .activateElements(Arrays.asList("D", "E"))
    .send();
      Parameters:
      adHocSubProcessInstanceKey - the key which identifies the corresponding ad-hoc sub-process instance
      Returns:
      a builder for the command

    • newUserTaskSearchRequest

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

    • newDecisionRequirementsSearchRequest

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

    • newDecisionDefinitionSearchRequest

      DecisionDefinitionSearchRequest newDecisionDefinitionSearchRequest()

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

    • newDecisionInstanceSearchRequest

      DecisionInstanceSearchRequest newDecisionInstanceSearchRequest()
      Executes a search request to query decision instances. 
       long decisionInstanceKey = ...;

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

    • 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

    • newIncidentSearchRequest

      IncidentSearchRequest newIncidentSearchRequest()

    • 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()
  .roleId("roleId")
  .name(name)
  .description("description")
  .send();

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

      Returns:
      a builder for the command

    • newRoleGetRequest

      RoleGetRequest newRoleGetRequest(String roleId)
      Request to get a role by role ID. 
      
 camundaClient
  .newRoleGetRequest("roleId")
  .send();
      Parameters:
      roleId - the ID of the role
      Returns:
      a builder for the request to get a role

    • newRolesSearchRequest

      RolesSearchRequest newRolesSearchRequest()
      Executes a search request to query roles. 
      
 camundaClient
  .newRolesSearchRequest()
  .filter((f) -> f.name("roleName"))
  .sort((s) -> s.name().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the roles search request

    • newUpdateRoleCommand

      UpdateRoleCommandStep1 newUpdateRoleCommand(String roleId)
      Command to update a role. 
       camundaClient
  .newUpdateRoleCommand("roleId")
  .name("name")
  .description("description")
  .send();

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

      Returns:
      a builder for the command

    • newAssignRoleToMappingRuleCommand

      AssignRoleToMappingRuleCommandStep1 newAssignRoleToMappingRuleCommand()
      Command to assign a role to a mapping rule. 
      
 camundaClient
  .newAssignRoleToMappingRuleCommand()
  .roleId("roleId")
  .mappingRuleId("mappingRuleId")
  .send();

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

      Returns:
      a builder to configure and send the assign role to mapping rule command

    • newDeleteRoleCommand

      DeleteRoleCommandStep1 newDeleteRoleCommand(String roleId)
      Command to delete a role by role ID. 
      
 camundaClient
  .newDeleteRoleCommand("roleId")
  .send();

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

      Returns:
      a builder for the command

    • newAssignRoleToGroupCommand

      AssignRoleToGroupCommandStep1 newAssignRoleToGroupCommand()
      Command to assign a role to a group. 
      
 camundaClient
  .newAssignRoleToGroupCommand()
  .roleId("roleId")
  .groupId("groupId")
  .send();

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

      Returns:
      a builder to configure and send the assign role to group command

    • newAssignRoleToClientCommand

      AssignRoleToClientCommandStep1 newAssignRoleToClientCommand()
      Command to assign a role to a client. 
      
 camundaClient
  .newAssignRoleToClientCommand()
  .roleId("roleId")
  .clientId("clientId")
  .send();

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

      Returns:
      a builder to configure and send the assign role to client command

    • newClientsByRoleSearchRequest

      ClientsByRoleSearchRequest newClientsByRoleSearchRequest(String roleId)
      Executes a search request to query clients by role. 
       camundaClient
   .newClientsByRoleSearchRequest("roleId")
   .sort((s) -> s.clientId().asc())
   .page((p) -> p.limit(100))
   .send();
      Parameters:
      roleId - the ID of the role
      Returns:
      a builder for the clients by role search request

    • newClientsByGroupSearchRequest

      ClientsByGroupSearchRequest newClientsByGroupSearchRequest(String groupId)
      Executes a search request to query clients by group. 
       camundaClient
   .newClientsByGroupSearchRequest("groupId")
   .sort((s) -> s.clientId().asc())
   .page((p) -> p.limit(100))
   .send();
      Parameters:
      groupId - the ID of the group
      Returns:
      a builder for the clients by group search request

    • newClientsByTenantSearchRequest

      ClientsByTenantSearchRequest newClientsByTenantSearchRequest(String tenantId)
      Executes a search request to query clients by tenant. 
       camundaClient
   .newClientsByTenantSearchRequest("tenantId")
   .sort((s) -> s.clientId().asc())
   .page((p) -> p.limit(100))
   .send();
      Parameters:
      tenantId - the ID of the tenant
      Returns:
      a builder for the clients by tenant search request

    • newAssignRoleToTenantCommand

      AssignRoleToTenantCommandStep1 newAssignRoleToTenantCommand()
      Command to assign a role to a tenant. 
       camundaClient
  .newAssignRoleToTenantCommand()
  .roleId("roleId")
  .tenantId("tenantId")
  .send();

      This command is only sent via REST over HTTP.

      Returns:
      a builder for the assign role to tenant command

    • newUnassignRoleFromTenantCommand

      UnassignRoleFromTenantCommandStep1 newUnassignRoleFromTenantCommand()
      Command to unassign a role from a tenant. 
       camundaClient
  .newUnassignRoleFromTenantCommand()
  .roleId("roleId")
  .tenantId("tenantId")
  .send();

      This command is only sent via REST over HTTP.

      Returns:
      a builder for the unassign role from tenant command

    • newRolesByTenantSearchRequest

      RolesByTenantSearchRequest newRolesByTenantSearchRequest(String tenantId)
      Executes a search request to query roles assigned to a specific tenant. 
       camundaClient
  .newRolesByTenantSearchRequest("tenantId")
  .filter((f) -> f.name("admin"))
  .sort((s) -> s.name().asc())
  .page((p) -> p.limit(50))
  .send();
      Parameters:
      tenantId - the ID of the tenant
      Returns:
      a builder for the roles by tenant search request

    • newUnassignRoleFromGroupCommand

      UnassignRoleFromGroupCommandStep1 newUnassignRoleFromGroupCommand()
      Command to unassign a role from a group.

      Example usage: 

       camundaClient
   .newUnassignRoleFromGroupCommand()
   .roleId("roleId")
   .groupId("groupId")
   .send();

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

      Returns:
      a builder for the unassign role from group command

    • newUnassignRoleFromMappingRuleCommand

      UnassignRoleFromMappingRuleCommandStep1 newUnassignRoleFromMappingRuleCommand()
      Command to unassign a role from a mapping rule.

      Example usage: 

       camundaClient
   .newUnassignRoleFromMappingRuleCommand()
   .roleId("roleId")
   .mappingRuleId("mappingRuleId")
   .send();

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

      Returns:
      a builder for the unassign role from mapping rule command

    • newUnassignRoleFromClientCommand

      UnassignRoleFromClientCommandStep1 newUnassignRoleFromClientCommand()
      Command to unassign a role from a client.

      Example usage: 

       camundaClient
   .newUnassignRoleFromClientCommand()
   .roleId("roleId")
   .clientId("clientId")
   .send();

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

      Returns:
      a builder for the unassign role from client command

    • newAssignRoleToUserCommand

      AssignRoleToUserCommandStep1 newAssignRoleToUserCommand()
      Command to assign a role to a user.

      Example usage: 

       camundaClient
   .newAssignRoleToUserCommand()
   .roleId("roleId")
   .username("username")
   .send();
      Returns:
      a builder for the assign role to user command

    • newUnassignRoleFromUserCommand

      UnassignRoleFromUserCommandStep1 newUnassignRoleFromUserCommand()
      Command to unassign a role from a user. 
       camundaClient
   .newUnassignRoleFromUserCommand()
   .roleId("roleId")
   .username("username")
   .send();

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

      Returns:
      a builder for the unassign role from user command

    • newUsersByRoleSearchRequest

      UsersByRoleSearchRequest newUsersByRoleSearchRequest(String roleId)
      Executes a search request to query users by role. 
       camundaClient
  .newUsersByRoleSearchRequest("roleId")
  .sort((s) -> s.username().asc())
  .page((p) -> p.limit(100))
  .send();
      Parameters:
      roleId - the ID of the role
      Returns:
      a builder for the users by role search request

    • newUsersByTenantSearchRequest

      UsersByTenantSearchRequest newUsersByTenantSearchRequest(String tenantId)
      Executes a search request to query users assigned to a tenant. 
       camundaClient
  .newUsersByTenantSearchRequest("tenantId")
  .sort((s) -> s.username().asc())
  .page((p) -> p.limit(100))
  .send();
      Parameters:
      tenantId - the ID of the tenant
      Returns:
      a builder for the users by tenant search request

    • newUsersSearchRequest

      UsersSearchRequest newUsersSearchRequest()
      Executes a search request to query users. 
      
 camundaClient
  .newUsersSearchRequest()
  .filter((f) -> f.username("userName"))
  .sort((s) -> s.username().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the users search request

    • newCreateGroupCommand

      CreateGroupCommandStep1 newCreateGroupCommand()
      Command to create a group. 
      

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

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

      Returns:
      a builder for the command

    • newUpdateGroupCommand

      UpdateGroupCommandStep1 newUpdateGroupCommand(String groupId)
      Command to update a group. 
      

 camundaClient
  .newUpdateGroupCommand("groupId")
  .name("name")
  .send();

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

      Returns:
      a builder for the command

    • newDeleteGroupCommand

      DeleteGroupCommandStep1 newDeleteGroupCommand(String groupId)
      Command to delete a group. 
      

 camundaClient
  .newDeleteGroupCommand("groupId")
  .send();

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

      Returns:
      a builder for the command

    • newAssignUserToGroupCommand

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

 camundaClient
  .newAssignUserToGroupCommand()
  .username("username")
  .groupId("groupId")
  .send();

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

      Returns:
      a builder for the command

    • newUnassignUserFromGroupCommand

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

 camundaClient
  .newUnassignUserFromGroupCommand()
  .username("username")
  .groupId("groupId")
  .send();

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

      Returns:
      a builder for the command

    • newCreateUserCommand

      CreateUserCommandStep1 newCreateUserCommand()
      Command to create a user. 
      

 camundaClient
  .newCreateUserCommand()
  .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

    • newDeleteUserCommand

      DeleteUserCommandStep1 newDeleteUserCommand(String username)
      Command to delete a user by username 
      
 camundaClient
  .newDeleteUserCommand("username")
  .send();

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

      Returns:
      a builder for the command

    • newUpdateUserCommand

      UpdateUserCommandStep1 newUpdateUserCommand(String username)
      Command to update a user. 
       camundaClient
  .newUpdateUserCommand("username")
  .name("name")
  .email("email@email.com")
  .send();

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

      Returns:
      a builder for the command

    • newUserGetRequest

      UserGetRequest newUserGetRequest(String username)
      Request to get a user by username. 
      
 camundaClient
  .newUserGetRequest("username")
  .send();
      Parameters:
      username - the username of the user
      Returns:
      a builder for the request to get a user

    • newCreateMappingRuleCommand

      CreateMappingRuleCommandStep1 newCreateMappingRuleCommand()
      Command to create a mapping rule. 
       camundaClient
  .newCreateMappingRuleCommand()
  .claimName(claimName)
  .claimValue(claimValue)
  .mappingRuleId(mappingRuleId)
  .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

    • newVariableSearchRequest

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

    • 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

    • newUserTaskVariableSearchRequest

      UserTaskVariableSearchRequest newUserTaskVariableSearchRequest(long userTaskKey)
      Executes a search request to query variables related to a user task. 
         long variableKey = ...;

  camundaClient
   .newUserTaskVariableSearchRequest(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 user task variable search request

    • 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

    • newTenantGetRequest

      TenantGetRequest newTenantGetRequest(String tenantId)
      Request to get a tenant by tenant ID. 
      
 camundaClient
  .newTenantGetRequest("tenantId")
  .send();
      Parameters:
      tenantId - the ID of the tenant
      Returns:
      a builder for the request to get a tenant by ID

    • newTenantsSearchRequest

      TenantsSearchRequest newTenantsSearchRequest()
      Executes a search request to query tenants. 
      
 camundaClient
  .newTenantsSearchRequest()
  .filter((f) -> f.name("tenantName"))
  .sort((s) -> s.name().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the tenants search request

    • newDeleteTenantCommand

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

    • newAssignMappingRuleToTenantCommand

      AssignMappingRuleToTenantCommandStep1 newAssignMappingRuleToTenantCommand()
      Command to assign a mapping rule to a tenant.

      Example usage: 

       camundaClient
   .newAssignMappingRuleToTenantCommand()
   .mappingRuleId("mappingRuleId")
   .tenantId("tenantId")
   .send();

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

      Returns:
      a builder for the assign mapping rule to tenant command

    • newAssignUserToTenantCommand

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

      Example usage: 

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

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

      Returns:
      a builder for the assign user to tenant command

    • newUnassignUserFromTenantCommand

      UnassignUserFromTenantCommandStep1 newUnassignUserFromTenantCommand()
      Command to unassign a user from a tenant.

      Example usage: 

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

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

      Returns:
      a builder for the unassign user from tenant command

    • newAssignGroupToTenantCommand

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

      Example usage: 

       camundaClient
   .newAssignGroupToTenantCommand()
   .groupId("groupId")
   .tenantId("tenantId")
   .send();
      Returns:
      a builder to configure and send the assign group to tenant command

    • newUnassignGroupFromTenantCommand

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

      Example usage: 

       camundaClient
   .newUnassignGroupFromTenantCommand()
   .groupId("groupId")
   .tenantId("tenantId")
   .send();
      Returns:
      a builder to configure and send the unassign group from tenant command

    • newAssignClientToGroupCommand

      AssignClientToGroupCommandStep1 newAssignClientToGroupCommand()
      Command to assign a client to a group. 
      
 camundaClient
  .newAssignClientToGroupCommand()
  .clientId("clientId")
  .groupId("groupId")
  .send();

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

      Returns:
      a builder to configure and send the assign client to group command

    • newUnassignClientFromGroupCommand

      UnassignClientFromGroupCommandStep1 newUnassignClientFromGroupCommand()
      Command to unassign a client from a group.

      Example usage: 

       camundaClient
   .newUnassignClientFromGroupCommand()
   .clientId("clientId")
   .groupId("groupId")
   .send();

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

      Returns:
      a builder for the unassign client from group command

    • newAssignClientToTenantCommand

      AssignClientToTenantCommandStep1 newAssignClientToTenantCommand()
      Command to assign a client to a tenant. 
      
 camundaClient
  .newAssignClientToTenantCommand()
  .clientId("clientId")
  .tenantId("tenantId")
  .send();

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

      Returns:
      a builder to configure and send the assign client to tenant command

    • newCreateAuthorizationCommand

      CreateAuthorizationCommandStep1 newCreateAuthorizationCommand()
      Command to create an authorization

      Example usage: 

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

    • newAuthorizationGetRequest

      AuthorizationGetRequest newAuthorizationGetRequest(long authorizationKey)
      Request to get an authorization by authorization key. 
      
 camundaClient
  .newAuthorizationGetRequest(authorizationKey)
  .send();
      Parameters:
      authorizationKey - the authorizationKey of the authorization
      Returns:
      a builder for the request to get an authorization

    • newAuthorizationSearchRequest

      AuthorizationsSearchRequest newAuthorizationSearchRequest()
      Executes a search request to query authorizations. 
      
 camundaClient
  .newAuthorizationSearchRequest()
  .filter((f) -> f.ownerType("ownerType"))
  .sort((s) -> s.ownerId().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the authorizations search request

    • 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

    • newCreateBatchOperationCommand

      CreateBatchOperationCommandStep1 newCreateBatchOperationCommand()
      Command to create a batch operation

      Example usage: 

       camundaClient
   .newCreateBatchOperationCommand()
   .processInstanceCancel()
   .filter(filter)
   .send();
      Returns:
      a builder to configure and send the create batch operation command

    • newBatchOperationGetRequest

      BatchOperationGetRequest newBatchOperationGetRequest(String batchOperationKey)
      Request to get a single batch operation by batch operation key. 
       camundaClient
  .newBatchOperationGetRequest(batchOperationKey)
  .send();
      Parameters:
      batchOperationKey - the key which identifies the corresponding batch operation
      Returns:
      a builder for the request

    • newBatchOperationSearchRequest

      BatchOperationSearchRequest newBatchOperationSearchRequest()
      Executes a search request to query batch operations. 
      
 camundaClient
  .newBatchOperationSearchRequest()
  .filter((f) -> f.state(state))
  .sort((s) -> s.startDate().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the groups search request

    • newCancelBatchOperationCommand

      CancelBatchOperationStep1 newCancelBatchOperationCommand(String batchOperationKey)
      Command to cancel a batch operation

      Example usage: 

       camundaClient
   .newCancelBatchOperationCommand("123")
   .send();
      Returns:
      a builder to configure and send the cancel batch operation command

    • newSuspendBatchOperationCommand

      SuspendBatchOperationStep1 newSuspendBatchOperationCommand(String batchOperationKey)
      Command to suspend a batch operation

      Example usage: 

       camundaClient
   .newSuspendBatchOperationCommand("123L")
   .send();
      Returns:
      a builder to configure and send the suspend batch operation command

    • newResumeBatchOperationCommand

      ResumeBatchOperationStep1 newResumeBatchOperationCommand(String batchOperationKey)
      Command to resume a batch operation

      Example usage: 

       camundaClient
   .newResumeBatchOperationCommand("123L")
   .send();
      Returns:
      a builder to configure and send the resume batch operation command

    • newBatchOperationItemsSearchRequest

      BatchOperationItemSearchRequest newBatchOperationItemsSearchRequest()
      Executes a search request to query batch operation items. 
      
 camundaClient
  .newBatchOperationItemSearchRequest()
  .filter((f) -> f.state(state))
  .sort((s) -> s.itemKey().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the groups search request

    • newAssignMappingRuleToGroupCommand

      AssignMappingRuleToGroupStep1 newAssignMappingRuleToGroupCommand()
      Command to assign a mapping rule to a group. 
      

 camundaClient
  .newAssignMappingRuleToGroupCommand()
  .mappingRuleId(mappingRuleId)
  .groupId(groupId)
  .send();

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

      Returns:
      a builder for the command

    • newUnassignMappingRuleFromGroupCommand

      UnassignMappingRuleFromGroupStep1 newUnassignMappingRuleFromGroupCommand()
      Command to unassign a mapping rule from a group. 
      

 camundaClient
  .newUnassignMappingRuleFromGroupCommand()
  .mappingRuleId(mappingRuleId)
  .groupId(groupId)
  .send();

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

      Returns:
      a builder for the command

    • newGroupGetRequest

      GroupGetRequest newGroupGetRequest(String groupId)
      Request to get a group by group ID. 
      
 camundaClient
  .newGroupGetRequest(groupId)
  .send();
      Parameters:
      groupId - the ID of the group
      Returns:
      a builder for the request to get a group

    • newGroupsSearchRequest

      GroupsSearchRequest newGroupsSearchRequest()
      Executes a search request to query groups. 
      
 camundaClient
  .newGroupsSearchRequest()
  .filter((f) -> f.name(name))
  .sort((s) -> s.name().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the groups search request

    • newUsersByGroupSearchRequest

      UsersByGroupSearchRequest newUsersByGroupSearchRequest(String groupId)
      Executes a search request to query users by group. 
      
 camundaClient
  .newUsersByGroupSearchRequest(groupId)
  .sort((s) -> s.username().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the users by group search request

    • newProcessInstanceGetCallHierarchyRequest

      ProcessInstanceGetCallHierarchyRequest newProcessInstanceGetCallHierarchyRequest(Long processInstanceKey)
      Retrieves the call hierarchy for a given process instance by its key. 
       camundaClient
   .newProcessInstanceGetCallHierarchyRequest(processInstanceKey)
   .send();

      The returned hierarchical structure represents the relationship of the given process instance to its parent and child process instances, if any.

      Parameters:
      processInstanceKey - the key of the process instance
      Returns:
      a builder for the request

    • newMappingRulesByGroupSearchRequest

      MappingRulesByGroupSearchRequest newMappingRulesByGroupSearchRequest(String groupId)
      Executes a search request to query mapping rules by group. 
         camundaClient
    .newMappingRulesByGroupSearchRequest(groupId)
    .filter((f) -> f.mappingRuleId(mappingRuleId))
    .sort((s) -> s.mappingRuleId().asc())
    .page((p) -> p.limit(100))
    .send();
      Parameters:
      groupId - the ID of the group
      Returns:
      a builder for the mapping rules by group search request

    • newMappingRulesByRoleSearchRequest

      MappingRulesByRoleSearchRequest newMappingRulesByRoleSearchRequest(String roleId)
      Executes a search request to query mapping rules by role. 
       camundaClient
  .newMappingRulesByRoleSearchRequest("roleId")
  .filter((f) -> f.mappingRuleId("mapping-rule-123"))
  .sort((s) -> s.mappingRuleId().asc())
  .page((p) -> p.limit(100))
  .send();
      Parameters:
      roleId - the ID of the role
      Returns:
      a builder for the mapping rules by role search request

    • newRolesByGroupSearchRequest

      RolesByGroupSearchRequest newRolesByGroupSearchRequest(String groupId)
      Executes a search request to query roles by group. 
         camundaClient
    .newRolesByGroupSearchRequest(groupId)
    .filter((f) -> f.roleName(roleName))
    .sort((s) -> s.roleName().asc())
    .page((p) -> p.limit(100))
    .send();
      Parameters:
      groupId - the ID of the group
      Returns:
      a builder for the roles by group search request

    • newIncidentsByProcessInstanceSearchRequest

      IncidentsByProcessInstanceSearchRequest newIncidentsByProcessInstanceSearchRequest(long processInstanceKey)
      Executes a search request to query incidents by process instance key. 
         camundaClient
    .newIncidentSearchByProcessInstanceKey(processInstanceKey)
    .sort((s) -> s.incidentKey().desc())
    .page((p) -> p.limit(100))
    .send();

    • newGroupsByRoleSearchRequest

      GroupsByRoleSearchRequest newGroupsByRoleSearchRequest(String roleId)
      Executes a search request to query groups by role. 
       camundaClient
  .newGroupsByRoleSearchRequest("roleId")
  .sort((s) -> s.groupdId().asc())
  .page((p) -> p.limit(100))
  .send();
      Parameters:
      roleId - the ID of the role
      Returns:
      a builder for the groups by role search request

    • newGroupsByTenantSearchRequest

      GroupsByTenantSearchRequest newGroupsByTenantSearchRequest(String tenantId)
      Executes a search request to query groups by tenant. 
       camundaClient
  .newGroupsByTenantSearchRequest("tenantId")
  .sort((s) -> s.groupId().desc())
  .page((p) -> p.limit(100))
  .send();
      Parameters:
      tenantId - the ID of the tenant
      Returns:
      a builder for the groups by tenant search request

    • newJobSearchRequest

      JobSearchRequest newJobSearchRequest()
      Executes a search request to query jobs. 
       camundaClient
  .newJobSearchRequest()
  .filter((f) -> f.jobKey(userTaskKey))
  .sort((s) -> s.endTime.asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the job search request

    • newMessageSubscriptionSearchRequest

      MessageSubscriptionSearchRequest newMessageSubscriptionSearchRequest()
      Executes a search request to query message subscriptions. 
       camundaClient
  .newMessageSubscriptionSearchRequest()
  .filter((f) -> f.messageSubscriptionKey(messageSubscriptionKey))
  .sort((s) -> s.messageName().asc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the message subscription search request

    • newCorrelatedMessageSubscriptionSearchRequest

      CorrelatedMessageSubscriptionSearchRequest newCorrelatedMessageSubscriptionSearchRequest()
      Executes a search request to query correlated message subscriptions. 
       camundaClient
  .newCorrelatedMessageSubscriptionSearchRequest()
  .filter((f) -> f.messageName("myMessage"))
  .sort((s) -> s.correlationTime().desc())
  .page((p) -> p.limit(100))
  .send();
      Returns:
      a builder for the correlated message subscription search request