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)

    • 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

    • 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

    • newAdHocSubProcessActivitySearchRequest

      @ExperimentalApi("https://github.com/camunda/camunda/issues/27930") AdHocSubProcessActivitySearchRequest newAdHocSubProcessActivitySearchRequest()
      Executes a search request to query activities within ad-hoc sub-processes.

      Note that this API currently requires filters for both process definition key and ad-hoc sub-process ID and does not support paging or sorting. 

       long processDefinitionKey = ...;
 String adHocSubProcessId = ...;

 camundaClient
  .newAdHocSubProcessActivitySearchRequest()
  .filter((f) -> f
     .processDefinitionKey(processDefinitionKey)
     .adHocSubProcessId(adHocSubProcessId)
  )
  .send();
      Returns:
      a builder for the ad-hoc sub-process activity search request

    • newAdHocSubProcessActivitySearchRequest

      @ExperimentalApi("https://github.com/camunda/camunda/issues/27930") AdHocSubProcessActivitySearchRequest newAdHocSubProcessActivitySearchRequest(long processDefinitionKey, String adHocSubProcessId)
      Executes a search request to query activities within ad-hoc sub-processes.

      Note that this API currently requires filters for both process definition key and ad-hoc sub-process ID and does not support paging or sorting. 

       long processDefinitionKey = ...;
 String adHocSubProcessId = ...;

 camundaClient
  .newAdHocSubProcessActivitySearchRequest(
    processDefinitionKey,
    adHocSubProcessId
  )
  .send();
      Returns:
      a builder for the ad-hoc sub-process activity search request

    • 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

    • newAssignRoleToMappingCommand

      AssignRoleToMappingCommandStep1 newAssignRoleToMappingCommand()
      Command to assign a role to a mapping. 
      
 camundaClient
  .newAssignRoleToMappingCommand()
  .roleId("roleId")
  .mappingId("mappingId")
  .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 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

    • newAssignRoleToTenantCommand

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

      This command is only sent via REST over HTTP.

      Parameters:
      tenantId - the ID of the tenant
      Returns:
      a builder for the assign role to tenant command

    • newUnassignRoleFromTenantCommand

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

      This command is only sent via REST over HTTP.

      Parameters:
      tenantId - the ID of the tenant
      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

    • newUnassignRoleFromMappingCommand

      UnassignRoleFromMappingCommandStep1 newUnassignRoleFromMappingCommand()
      Command to unassign a role from a mapping.

      Example usage: 

       camundaClient
   .newUnassignRoleFromMappingCommand()
   .roleId("roleId")
   .mappingId("mappingId")
   .send();

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

      Returns:
      a builder for the unassign role from mapping 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

    • 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(String groupId)
      Command to assign a user to a group. 
      

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

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

      Returns:
      a builder for the command

    • newUnassignUserFromGroupCommand

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

 camundaClient
  .newUnassignUserFromGroupCommand("groupId")
  .username("username")
  .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)
  .mappingId(mappingId)
  .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

    • 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

    • newAssignMappingToTenantCommand

      AssignMappingToTenantCommandStep1 newAssignMappingToTenantCommand(String tenantId)
      Command to assign a mapping rule to a tenant.

      Example usage: 

       camundaClient
   .newAssignMappingToTenantCommand(tenantId)
   .mappingId(mappingId)
   .send();

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

      Parameters:
      tenantId - 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

    • newUnassignUserFromTenantCommand

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

      Example usage: 

       camundaClient
   .newUnassignUserFromTenantCommand(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(String tenantId)
      Command to assign a group to a tenant.

      Example usage: 

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

    • newUnassignGroupFromTenantCommand

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

      Example usage: 

       camundaClient
   .newUnassignGroupFromTenantCommand(tenantId)
   .groupId(groupId)
   .send();
      Parameters:
      tenantId - 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

    • 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(Long 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

    • 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

    • newAssignMappingToGroupCommand

      AssignMappingToGroupStep1 newAssignMappingToGroupCommand(String groupId)
      Command to assign a mapping rule to a group. 
      

 camundaClient
  .newAssignMappingToGroupCommand(groupId)
  .mappingId(mappingId)
  .send();

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

      Returns:
      a builder for the command

    • newUnassignMappingFromGroupCommand

      UnassignMappingFromGroupStep1 newUnassignMappingFromGroupCommand(String groupId)
      Command to unassign a mapping rule from a group. 
      

 camundaClient
  .newUnassignMappingFromGroupCommand(groupId)
  .mappingId(mappingId)
  .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

    • newMappingsByGroupSearchRequest

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

    • newMappingsByRoleSearchRequest

      MappingsByRoleSearchRequest newMappingsByRoleSearchRequest(String roleId)
      Executes a search request to query mappings by role. 
       camundaClient
  .newMappingsByRoleSearchRequest("roleId")
  .filter((f) -> f.mappingId("mapping-123"))
  .sort((s) -> s.mappingId().asc())
  .page((p) -> p.limit(100))
  .send();
      Parameters:
      roleId - the ID of the role
      Returns:
      a builder for the mappings 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