Camunda.ts

/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
  "/batch": {
    /**
     * Queries for batches that fulfill given parameters. Parameters may be the properties of batches, such as the id or type.
     * The size of the result set can be retrieved by using the
     * [Get Batch Count](https://docs.camunda.org/manual/latest/reference/rest/batch/get-query-count/) method.
     */
    get: operations["getBatches"];
  };
  "/batch/count": {
    /**
     * Requests the number of batches that fulfill the query criteria.
     * Takes the same filtering parameters as the [Get Batches](https://docs.camunda.org/manual/latest/reference/rest/batch/get-query/) method.
     */
    get: operations["getBatchesCount"];
  };
  "/batch/statistics": {
    /**
     * Queries for batch statistics that fulfill given parameters.
     * Parameters may be the properties of batches, such as the id or type.
     * The size of the result set can be retrieved by using the
     * [Get Batch Statistics Count](https://docs.camunda.org/manual/latest/reference/rest/batch/get-statistics-query-count/) method.
     */
    get: operations["getBatchStatistics"];
  };
  "/batch/statistics/count": {
    /**
     * Requests the number of batch statistics that fulfill the query criteria.
     * Takes the same filtering parameters as the
     * [Get Batch Statistics](https://docs.camunda.org/manual/latest/reference/rest/batch/get-statistics-query/) method.
     */
    get: operations["getBatchStatisticsCount"];
  };
  "/batch/{id}": {
    /** Retrieves a batch by id, according to the Batch interface in the engine. */
    get: operations["getBatch"];
    /**
     * Deletes a batch by id, including all related jobs and job definitions.
     * Optionally also deletes the batch history.
     */
    delete: operations["deleteBatch"];
  };
  "/batch/{id}/suspended": {
    /** Activates or suspends a batch by id. */
    put: operations["updateBatchSuspensionState"];
  };
  "/condition": {
    /**
     * Triggers evaluation of conditions for conditional start event(s).
     * Internally this maps to the engines condition evaluation builder method ConditionEvaluationBuilder#evaluateStartConditions().
     * For more information see the [Conditional Start Events](https://docs.camunda.org/manual/latest/reference/bpmn20/events/conditional-events/#conditional-start-event)
     * section of the [BPMN 2.0 Implementation Reference](https://docs.camunda.org/manual/latest/reference/bpmn20/).
     */
    post: operations["evaluateCondition"];
  };
  "/decision-definition": {
    /**
     * Queries for decision definitions that fulfill given parameters.
     * Parameters may be the properties of decision definitions, such as the name, key or version.
     * The size of the result set can be retrieved by using
     * the [Get Decision Definition Count](https://docs.camunda.org/manual/latest/reference/rest/decision-definition/get-query-count/) method.
     */
    get: operations["getDecisionDefinitions"];
  };
  "/decision-definition/count": {
    /**
     * Requests the number of decision definitions that fulfill the query criteria.
     * Takes the same filtering parameters as the
     * [Get Decision Definition](https://docs.camunda.org/manual/latest/reference/rest/decision-definition/get-query/) method.
     */
    get: operations["getDecisionDefinitionsCount"];
  };
  "/decision-definition/key/{key}": {
    /** Retrieves the latest version of the decision definition which belongs to no tenant. */
    get: operations["getDecisionDefinitionByKey"];
  };
  "/decision-definition/key/{key}/diagram": {
    /** Returns the diagram for the latest version of the decision definition which belongs to no tenant */
    get: operations["getDecisionDefinitionDiagramByKey"];
  };
  "/decision-definition/key/{key}/evaluate": {
    /**
     * Evaluates the latest version of the decision definition which belongs to no tenant.
     * The input values of the decision have to be supplied in the request body.
     */
    post: operations["evaluateDecisionByKey"];
  };
  "/decision-definition/key/{key}/history-time-to-live": {
    /**
     * Updates the latest version of the decision definition which belongs to no tenant.
     * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
     */
    put: operations["updateHistoryTimeToLiveByDecisionDefinitionKey"];
  };
  "/decision-definition/key/{key}/tenant-id/{tenant-id}": {
    /** Retrieves the latest version of the decision definition for tenant */
    get: operations["getDecisionDefinitionByKeyAndTenantId"];
  };
  "/decision-definition/key/{key}/tenant-id/{tenant-id}/diagram": {
    /** Returns the XML of the latest version of the decision definition for tenant. */
    get: operations["getDecisionDefinitionDiagramByKeyAndTenant"];
  };
  "/decision-definition/key/{key}/tenant-id/{tenant-id}/evaluate": {
    /**
     * Evaluates the latest version of the decision definition for tenant.
     * The input values of the decision have to be supplied in the request body.
     */
    post: operations["evaluateDecisionByKeyAndTenant"];
  };
  "/decision-definition/key/{key}/tenant-id/{tenant-id}/history-time-to-live": {
    /**
     * Updates the latest version of the decision definition for tenant.
     * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
     */
    put: operations["updateHistoryTimeToLiveByDecisionDefinitionKeyAndTenant"];
  };
  "/decision-definition/key/{key}/tenant-id/{tenant-id}/xml": {
    /** Retrieves the XML of the latest version of the decision definition for tenant */
    get: operations["getDecisionDefinitionDmnXmlByKeyAndTenant"];
  };
  "/decision-definition/key/{key}/xml": {
    /** Retrieves the XML for the latest version of the decision definition which belongs to no tenant. */
    get: operations["getDecisionDefinitionDmnXmlByKey"];
  };
  "/decision-definition/{id}": {
    /** Retrieves a decision definition by id, according to the `DecisionDefinition` interface in the engine. */
    get: operations["getDecisionDefinitionById"];
  };
  "/decision-definition/{id}/diagram": {
    /** Retrieves the diagram of a decision definition. */
    get: operations["getDecisionDefinitionDiagram"];
  };
  "/decision-definition/{id}/evaluate": {
    /**
     * Evaluates a given decision and returns the result.
     * The input values of the decision have to be supplied in the request body.
     */
    post: operations["evaluateDecisionById"];
  };
  "/decision-definition/{id}/history-time-to-live": {
    /**
     * Updates history time to live for decision definition.
     * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
     */
    put: operations["updateHistoryTimeToLiveByDecisionDefinitionId"];
  };
  "/decision-definition/{id}/xml": {
    /** Retrieves the DMN XML of a decision definition. */
    get: operations["getDecisionDefinitionDmnXmlById"];
  };
  "/deployment": {
    /**
     * Queries for deployments that fulfill given parameters. Parameters may be the properties of deployments,
     * such as the id or name or a range of the deployment time. The size of the result set can be retrieved by
     * using the [Get Deployment count](https://docs.camunda.org/manual/latest/reference/rest/deployment/get-query-count/) method.
     */
    get: operations["getDeployments"];
  };
  "/deployment/count": {
    /**
     * Queries for the number of deployments that fulfill given parameters. Takes the same parameters as the
     * [Get Deployments](https://docs.camunda.org/manual/latest/reference/rest/deployment/get-query/) method.
     */
    get: operations["getDeploymentsCount"];
  };
  "/deployment/create": {
    /**
     * Creates a deployment.
     *
     * **Security Consideration**
     *
     * Deployments can contain custom code in form of scripts or EL expressions to customize process behavior.
     * This may be abused for remote execution of arbitrary code.
     */
    post: operations["createDeployment"];
  };
  "/deployment/{id}": {
    /** Retrieves a deployment by id, according to the `Deployment` interface of the engine. */
    get: operations["getDeployment"];
    /** Deletes a deployment by id. */
    delete: operations["deleteDeployment"];
  };
  "/deployment/{id}/redeploy": {
    /**
     * Re-deploys an existing deployment.
     *
     * The deployment resources to re-deploy can be restricted by using the properties `resourceIds` or
     * `resourceNames`. If no deployment resources to re-deploy are passed then all existing resources of the
     * given deployment are re-deployed.
     *
     * **Warning**: Deployments can contain custom code in form of scripts or EL expressions to customize
     * process behavior. This may be abused for remote execution of arbitrary code. See the section on
     * [security considerations for custom code](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/) in
     * the user guide for details.
     */
    post: operations["redeploy"];
  };
  "/deployment/{id}/resources": {
    /** Retrieves all deployment resources of a given deployment. */
    get: operations["getDeploymentResources"];
  };
  "/deployment/{id}/resources/{resourceId}": {
    /** Retrieves a deployment resource by resource id for the given deployment. */
    get: operations["getDeploymentResource"];
  };
  "/deployment/{id}/resources/{resourceId}/data": {
    /** Retrieves the binary content of a deployment resource for the given deployment by id. */
    get: operations["getDeploymentResourceData"];
  };
  "/engine": {
    /**
     * Retrieves the names of all process engines available on your platform.
     * **Note**: You cannot prepend `/engine/{name}` to this method.
     */
    get: operations["getProcessEngineNames"];
  };
  "/event-subscription": {
    /**
     * Queries for event subscriptions that fulfill given parameters.
     * The size of the result set can be retrieved by using the
     * [Get Event Subscriptions count](https://docs.camunda.org/manual/latest/reference/rest/event-subscription/get-query-count/) method.
     */
    get: operations["getEventSubscriptions"];
  };
  "/event-subscription/count": {
    /**
     * Queries for the number of event subscriptions that fulfill given parameters.
     * Takes the same parameters as the
     * [Get Event Subscriptions](https://docs.camunda.org/manual/latest/reference/rest/event-subscription/get-query/) method.
     */
    get: operations["getEventSubscriptionsCount"];
  };
  "/execution": {
    /**
     * Queries for the executions that fulfill given parameters.
     * Parameters may be static as well as dynamic runtime properties of
     * executions.
     * The size of the result set can be retrieved by using the [Get
     * Execution Count](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query-count/)
     * method.
     */
    get: operations["getExecutions"];
    /**
     * Queries for executions that fulfill given parameters through a JSON object.
     * This method is slightly more powerful than the [Get
     * Executions](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query/) method
     * because it allows
     * to filter by multiple instance and execution variables of types
     * `String`, `Number` or `Boolean`.
     */
    post: operations["queryExecutions"];
  };
  "/execution/count": {
    /**
     * Queries for the number of executions that fulfill given parameters.
     * Takes the same parameters as the [Get
     * Executions](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query/) method.
     */
    get: operations["getExecutionsCount"];
    /**
     * Queries for the number of executions that fulfill given parameters. This method
     * takes the same message body as the [Get Executions
     * POST](https://docs.camunda.org/manual/latest/reference/rest/execution/post-query/) method and
     * therefore it is slightly more powerful than the [Get Execution
     * Count](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query-count/) method.
     */
    post: operations["queryExecutionsCount"];
  };
  "/execution/{id}": {
    /**
     * Retrieves an execution by id, according to the `Execution` interface in the
     * engine.
     */
    get: operations["getExecution"];
  };
  "/execution/{id}/create-incident": {
    /** Creates a custom incident with given properties. */
    post: operations["createIncident"];
  };
  "/execution/{id}/localVariables": {
    /** Retrieves all variables of a given execution by id. */
    get: operations["getLocalExecutionVariables"];
    /**
     * Updates or deletes the variables in the context of an execution by id. The updates
     * do not propagate upwards in the execution hierarchy.
     * Updates precede deletions. So, if a variable is updated AND deleted,
     * the deletion overrides the update.
     */
    post: operations["modifyLocalExecutionVariables"];
  };
  "/execution/{id}/localVariables/{varName}": {
    /**
     * Retrieves a variable from the context of a given execution by id. Does not traverse
     * the parent execution hierarchy.
     */
    get: operations["getLocalExecutionVariable"];
    /**
     * Sets a variable in the context of a given execution by id. Update does not
     * propagate upwards in the execution hierarchy.
     */
    put: operations["putLocalExecutionVariable"];
    /**
     * Deletes a variable in the context of a given execution by id. Deletion does not
     * propagate upwards in the execution hierarchy.
     */
    delete: operations["deleteLocalExecutionVariable"];
  };
  "/execution/{id}/localVariables/{varName}/data": {
    /**
     * Retrieves a binary variable from the context of a given execution by id. Does not
     * traverse the parent execution hierarchy. Applicable for byte array and
     * file variables.
     */
    get: operations["getLocalExecutionVariableBinary"];
    /**
     * Sets the serialized value for a binary variable or the binary value for a file
     * variable in the context of a given execution by id.
     */
    post: operations["setLocalExecutionVariableBinary"];
  };
  "/execution/{id}/messageSubscriptions/{messageName}": {
    /**
     * Retrieves a message event subscription for a given execution by id and a message
     * name.
     */
    get: operations["getMessageEventSubscription"];
  };
  "/execution/{id}/messageSubscriptions/{messageName}/trigger": {
    /**
     * Delivers a message to a specific execution by id, to trigger an existing message
     * event subscription. Inject process variables as the message's
     * payload.
     */
    post: operations["triggerEvent"];
  };
  "/execution/{id}/signal": {
    /**
     * Signals an execution by id. Can for example be used to explicitly skip user tasks
     * or signal asynchronous continuations.
     */
    post: operations["signalExecution"];
  };
  "/external-task": {
    /**
     * Queries for the external tasks that fulfill given parameters. Parameters may be static as well as dynamic
     * runtime properties of executions. The size of the result set can be retrieved by using the
     * [Get External Task Count](https://docs.camunda.org/manual/latest/reference/rest/external-task/get-query-count/) method.
     */
    get: operations["getExternalTasks"];
    /**
     * Queries for external tasks that fulfill given parameters in the form of a JSON object.
     *
     * This method is slightly more powerful than the
     * [Get External Tasks](https://docs.camunda.org/manual/latest/reference/rest/external-task/get-query/) method because it allows to
     * specify a hierarchical result sorting.
     */
    post: operations["queryExternalTasks"];
  };
  "/external-task/count": {
    /**
     * Queries for the number of external tasks that fulfill given parameters. Takes the same parameters as the
     * [Get External Tasks](https://docs.camunda.org/manual/latest/reference/rest/external-task/get-query/) method.
     */
    get: operations["getExternalTasksCount"];
    /**
     * Queries for the number of external tasks that fulfill given parameters. This method takes the same message
     * body as the [Get External Tasks (POST)](https://docs.camunda.org/manual/latest/reference/rest/external-task/post-query/) method.
     */
    post: operations["queryExternalTasksCount"];
  };
  "/external-task/fetchAndLock": {
    /**
     * Fetches and locks a specific number of external tasks for execution by a worker. Query can be restricted
     * to specific task topics and for each task topic an individual lock time can be provided.
     */
    post: operations["fetchAndLock"];
  };
  "/external-task/retries": {
    /**
     * Sets the number of retries left to execute external tasks by id synchronously. If retries are set to 0,
     * an incident is created.
     */
    put: operations["setExternalTaskRetries"];
  };
  "/external-task/retries-async": {
    /**
     * Sets the number of retries left to execute external tasks by id asynchronously. If retries are set to 0,
     * an incident is created.
     */
    post: operations["setExternalTaskRetriesAsyncOperation"];
  };
  "/external-task/topic-names": {
    /**
     * Queries for distinct topic names of external tasks that fulfill given parameters.
     * Query can be restricted to only tasks with retries left, tasks that are locked, or tasks
     * that are unlocked. The parameters withLockedTasks and withUnlockedTasks are
     * exclusive. Setting them both to true will return an empty list.
     * Providing no parameters will return a list of all distinct topic names with external tasks.
     */
    get: operations["getTopicNames"];
  };
  "/external-task/{id}": {
    /** Retrieves an external task by id, corresponding to the `ExternalTask` interface in the engine. */
    get: operations["getExternalTask"];
  };
  "/external-task/{id}/bpmnError": {
    /**
     * Reports a business error in the context of a running external task by id. The error code must be specified
     * to identify the BPMN error handler.
     */
    post: operations["handleExternalTaskBpmnError"];
  };
  "/external-task/{id}/complete": {
    /** Completes an external task by id and updates process variables. */
    post: operations["completeExternalTaskResource"];
  };
  "/external-task/{id}/errorDetails": {
    /** Retrieves the error details in the context of a running external task by id. */
    get: operations["getExternalTaskErrorDetails"];
  };
  "/external-task/{id}/extendLock": {
    /** Extends the timeout of the lock by a given amount of time. */
    post: operations["extendLock"];
  };
  "/external-task/{id}/failure": {
    /**
     * Reports a failure to execute an external task by id. A number of retries and a timeout until the task can
     * be retried can be specified. If retries are set to 0, an incident for this task is created.
     */
    post: operations["handleFailure"];
  };
  "/external-task/{id}/lock": {
    /** Lock an external task by a given id for a specified worker and amount of time. */
    post: operations["lock"];
  };
  "/external-task/{id}/priority": {
    /** Sets the priority of an existing external task by id. The default value of a priority is 0. */
    put: operations["setExternalTaskResourcePriority"];
  };
  "/external-task/{id}/retries": {
    /**
     * Sets the number of retries left to execute an external task by id. If retries are set to 0, an
     * incident is created.
     */
    put: operations["setExternalTaskResourceRetries"];
  };
  "/external-task/{id}/unlock": {
    /** Unlocks an external task by id. Clears the task's lock expiration time and worker id. */
    post: operations["unlock"];
  };
  "/group": {
    /**
     * Queries for a list of groups using a list of parameters. The size of the result set can be retrieved
     * by using the [Get Group Count](https://docs.camunda.org/manual/latest/reference/rest/group/get-query-count) method.
     */
    get: operations["getQueryGroups"];
    /**
     * Queries for a list of groups using a list of parameters.
     * The size of the result set can be retrieved by using the
     * [Get Group Count (POST)](https://docs.camunda.org/manual/latest/reference/rest/group/post-query-count/) method.
     */
    post: operations["postQueryGroups"];
    /**
     * The `/group` resource supports two custom OPTIONS requests, this one for the resource as such and one for
     * individual group instances. The OPTIONS request allows checking for the set of available operations that
     * the currently authenticated user can perform on the `/group` resource. If the user can perform an operation
     * or not may depend on various things, including the users authorizations to interact with this resource and
     * the internal configuration of the process engine.
     */
    options: operations["availableGroupOperations"];
  };
  "/group/count": {
    /** Queries for groups using a list of parameters and retrieves the count. */
    get: operations["getGroupCount"];
    /** Queries for groups using a list of parameters and retrieves the count. */
    post: operations["queryGroupCount"];
  };
  "/group/create": {
    /** Creates a new group. */
    post: operations["createGroup"];
  };
  "/group/{id}": {
    /** Retrieves a group by id. */
    get: operations["getGroup"];
    /** Updates a given group by id. */
    put: operations["updateGroup"];
    /** Deletes a group by id. */
    delete: operations["deleteGroup"];
    /**
     * The `/group` resource supports two custom OPTIONS requests, one for the resource as such and this one for individual group instances.
     * The OPTIONS request allows checking for the set of available operations that the currently authenticated user can perform on the
     * `/group/{id}` resource instance. If the user can perform an operation or not may depend on various things, including the users authorizations
     * to interact with this resource and the internal configuration of the process engine.
     */
    options: operations["availableGroupInstanceOperations"];
  };
  "/group/{id}/members": {
    /**
     * The OPTIONS request allows checking for the set of available operations that the currently authenticated
     * user can perform on the resource. If the user can perform an operation or not may depend on various
     * things, including the users authorizations to interact with this resource and the internal configuration
     * of the process engine.
     */
    options: operations["availableGroupMembersOperations"];
  };
  "/group/{id}/members/{userId}": {
    /** Adds a member to a group. */
    put: operations["createGroupMember"];
    /** Removes a member from a group. */
    delete: operations["deleteGroupMember"];
  };
  "/history/activity-instance": {
    /**
     * Queries for historic activity instances that fulfill the given parameters.
     * The size of the result set can be retrieved by using the
     * [Get Historic Activity Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/activity-instance/get-activity-instance-query-count/) method.
     */
    get: operations["getHistoricActivityInstances"];
    /**
     * Queries for historic activity instances that fulfill the given parameters.
     * The size of the result set can be retrieved by using the
     * [Get Historic Activity Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/activity-instance/get-activity-instance-query-count/) method.
     */
    post: operations["queryHistoricActivityInstances"];
  };
  "/history/activity-instance/count": {
    /**
     * Queries for the number of historic activity instances that fulfill the given parameters.
     * Takes the same parameters as the [Get Historic Activity Instance](https://docs.camunda.org/manual/latest/reference/rest/history/activity-instance/get-activity-instance-query/)  method.
     */
    get: operations["getHistoricActivityInstancesCount"];
    /** Queries for the number of historic activity instances that fulfill the given parameters. */
    post: operations["queryHistoricActivityInstancesCount"];
  };
  "/history/activity-instance/{id}": {
    /** Retrieves a historic activity instance by id, according to the `HistoricActivityInstance` interface in the engine. */
    get: operations["getHistoricActivityInstance"];
  };
  "/history/process-instance": {
    /**
     * Queries for historic process instances that fulfill the given parameters.
     * The size of the result set can be retrieved by using the
     * [Get Process Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query-count/) method.
     */
    get: operations["getHistoricProcessInstances"];
    /**
     * Queries for historic process instances that fulfill the given parameters.
     * This method is slightly more powerful than the
     * [Get Process Instance](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query/)
     * because it allows filtering by multiple process variables of types `String`, `Number` or `Boolean`.
     */
    post: operations["queryHistoricProcessInstances"];
  };
  "/history/process-instance/count": {
    /**
     * Queries for the number of historic process instances that fulfill the given parameters.
     * Takes the same parameters as the [Get Process Instances](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query/) method.
     */
    get: operations["getHistoricProcessInstancesCount"];
    /**
     * Queries for the number of historic process instances that fulfill the given parameters.
     * This method takes the same message body as the [Get Process Instances (POST)](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query/) method and
     * therefore it is slightly more powerful than the [Get Process Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/post-process-instance-query-count/) method.
     */
    post: operations["queryHistoricProcessInstancesCount"];
  };
  "/history/process-instance/delete": {
    /**
     * Delete multiple historic process instances asynchronously (batch).
     * At least `historicProcessInstanceIds` or `historicProcessInstanceQuery` has to be provided.
     * If both are provided then all instances matching query criterion and instances from the list will be deleted.
     */
    post: operations["deleteHistoricProcessInstancesAsync"];
  };
  "/history/process-instance/report": {
    /**
     * Retrieves a report about the duration of completed process instances, grouped by a period.
     * These reports include the maximum, minimum and average duration of all completed process instances which were started in a given period.
     *
     * **Note:** This only includes historic data.
     */
    get: operations["getHistoricProcessInstanceDurationReport"];
  };
  "/history/process-instance/set-removal-time": {
    /**
     * Sets the removal time to multiple historic process instances asynchronously (batch).
     *
     * At least `historicProcessInstanceIds` or `historicProcessInstanceQuery` has to be provided.
     * If both are provided, all instances matching query criterion and instances from the list will be updated with a removal time.
     */
    post: operations["setRemovalTimeAsync"];
  };
  "/history/process-instance/{id}": {
    /** Retrieves a historic process instance by id, according to the `HistoricProcessInstance` interface in the engine. */
    get: operations["getHistoricProcessInstance"];
    /** Deletes a process instance from the history by id. */
    delete: operations["deleteHistoricProcessInstance"];
  };
  "/history/process-instance/{id}/variable-instances": {
    /** Deletes all variables of a process instance from the history by id. */
    delete: operations["deleteHistoricVariableInstancesOfHistoricProcessInstance"];
  };
  "/identity/groups": {
    /**
     * Gets the groups of a user by id and includes all users that share a group with the
     * given user.
     */
    get: operations["getGroupInfo"];
  };
  "/identity/password-policy": {
    /**
     * A password policy consists of a list of rules that new passwords must follow to be
     * policy compliant. This end point returns a JSON representation of the
     * list of policy rules. More information on password policies in Camunda can be found in the password policy
     * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/password-policy/) and in
     * the [security instructions](https://docs.camunda.org/manual/latest/user-guide/security/).
     */
    get: operations["getPasswordPolicy"];
    /**
     * A password policy consists of a list of rules that new passwords must follow to be
     * policy compliant. A password can be checked for compliancy via this
     * end point. More information on password policies in Camunda can be found in the password policy
     * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/password-policy/) and in
     * the [security instructions](https://docs.camunda.org/manual/latest/user-guide/security/).
     */
    post: operations["checkPassword"];
  };
  "/identity/verify": {
    /** Verifies that user credentials are valid. */
    post: operations["verifyUser"];
  };
  "/incident": {
    /**
     * Queries for incidents that fulfill given parameters. The size of the result set can be retrieved by using
     * the [Get Incident Count](https://docs.camunda.org/manual/latest/reference/rest/incident/get-query-count/) method.
     */
    get: operations["getIncidents"];
  };
  "/incident/count": {
    /**
     * Queries for the number of incidents that fulfill given parameters. Takes the same parameters as the
     * [Get Incidents](https://docs.camunda.org/manual/latest/reference/rest/incident/get-query/) method.
     */
    get: operations["getIncidentsCount"];
  };
  "/incident/{id}": {
    /** Retrieves an incident by ID. */
    get: operations["getIncident"];
    /** Resolves an incident with given id. */
    delete: operations["resolveIncident"];
  };
  "/incident/{id}/annotation": {
    /** Sets the annotation of an incident with given id. */
    put: operations["setIncidentAnnotation"];
    /** Clears the annotation of an incident with given id. */
    delete: operations["clearIncidentAnnotation"];
  };
  "/job": {
    /**
     * Queries for jobs that fulfill given parameters.
     * The size of the result set can be retrieved by using the [Get Job
     * Count](https://docs.camunda.org/manual/latest/reference/rest/job/get-query-count/) method.
     */
    get: operations["getJobs"];
    /**
     * Queries for jobs that fulfill given parameters. This method is slightly more
     * powerful than the [Get Jobs](https://docs.camunda.org/manual/latest/reference/rest/job/get-query/)
     * method because it allows filtering by multiple jobs of types `String`,
     * `Number` or `Boolean`.
     */
    post: operations["queryJobs"];
  };
  "/job/count": {
    /**
     * Queries for the number of jobs that fulfill given parameters.
     * Takes the same parameters as the [Get
     * Jobs](https://docs.camunda.org/manual/latest/reference/rest/job/get-query/) method.
     */
    get: operations["getJobsCount"];
    /**
     * Queries for jobs that fulfill given parameters. This method takes the same message
     * body as the [Get Jobs POST](https://docs.camunda.org/manual/latest/reference/rest/job/post-
     * query/) method and therefore it is slightly more powerful than the
     * [Get Job Count](https://docs.camunda.org/manual/latest/reference/rest/job/get-query-count/)
     * method.
     */
    post: operations["queryJobsCount"];
  };
  "/job/retries": {
    /** Create a batch to set retries of jobs asynchronously. */
    post: operations["setJobRetriesAsyncOperation"];
  };
  "/job/suspended": {
    /**
     * Activates or suspends jobs matching the given criterion.
     * This can only be on of:
     * * `jobDefinitionId`
     * * `processDefinitionId`
     * * `processInstanceId`
     * * `processDefinitionKey`
     */
    put: operations["updateSuspensionStateBy"];
  };
  "/job/{id}": {
    /** Retrieves a job by id, according to the `Job` interface in the engine. */
    get: operations["getJob"];
  };
  "/job/{id}/duedate": {
    /** Updates the due date of a job by id. */
    put: operations["setJobDuedate"];
  };
  "/job/{id}/duedate/recalculate": {
    /** Recalculates the due date of a job by id. */
    post: operations["recalculateDuedate"];
  };
  "/job/{id}/execute": {
    /**
     * Executes a job by id. **Note:** The execution of the job happens synchronously in
     * the same thread.
     */
    post: operations["executeJob"];
  };
  "/job/{id}/priority": {
    /** Sets the execution priority of a job by id. */
    put: operations["setJobPriority"];
  };
  "/job/{id}/retries": {
    /** Sets the retries of the job to the given number of retries by id. */
    put: operations["setJobRetries"];
  };
  "/job/{id}/stacktrace": {
    /** Retrieves the exception stacktrace corresponding to the passed job id. */
    get: operations["getStacktrace"];
  };
  "/job/{id}/suspended": {
    /** Activates or suspends a given job by id. */
    put: operations["updateJobSuspensionState"];
  };
  "/message": {
    /**
     * Correlates a message to the process engine to either trigger a message start event or an intermediate message
     * catching event. Internally this maps to the engine's message correlation builder methods
     * `MessageCorrelationBuilder#correlateWithResult()` and `MessageCorrelationBuilder#correlateAllWithResult()`.
     * For more information about the correlation behavior, see the [Message Events](https://docs.camunda.org/manual/latest/bpmn20/events/message-events/)
     * section of the [BPMN 2.0 Implementation Reference](https://docs.camunda.org/manual/latest/reference/bpmn20/).
     */
    post: operations["deliverMessage"];
  };
  "/metrics": {
    /** Retrieves a list of metrics, aggregated for a given interval. */
    get: operations["interval"];
  };
  "/metrics/task-worker": {
    /** Deletes all task worker metrics prior to the given date or all if no date is provided. */
    delete: operations["deleteTaskMetrics"];
  };
  "/metrics/{metrics-name}/sum": {
    /** Retrieves the `sum` (count) for a given metric. */
    get: operations["getMetrics"];
  };
  "/process-definition": {
    /**
     * Queries for process definitions that fulfill given parameters. Parameters may be the properties of
     * process definitions, such as the name, key or version. The size of the result set can be retrieved
     * by using the [Get Definition Count](https://docs.camunda.org/manual/latest/reference/rest/process-definition/get-query-count/) method.
     */
    get: operations["getProcessDefinitions"];
  };
  "/process-definition/count": {
    /**
     * Requests the number of process definitions that fulfill the query criteria.
     * Takes the same filtering parameters as the [Get Definitions](https://docs.camunda.org/manual/latest/reference/rest/process-definition/get-query/) method.
     */
    get: operations["getProcessDefinitionsCount"];
  };
  "/process-definition/key/{key}": {
    /** Retrieves the latest version of the process definition which belongs to no tenant according to the `ProcessDefinition` interface in the engine. */
    get: operations["getProcessDefinitionByKey"];
    /** Deletes process definitions by a given key which belong to no tenant id. */
    delete: operations["deleteProcessDefinitionsByKey"];
  };
  "/process-definition/key/{key}/deployed-start-form": {
    /**
     * Retrieves the deployed form that can be referenced from a start event.
     * For further information please refer to [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
     */
    get: operations["getDeployedStartFormByKey"];
  };
  "/process-definition/key/{key}/diagram": {
    /**
     * Retrieves the diagram for the latest version of the process definition which belongs to no tenant.
     *
     * If the process definition's deployment contains an image resource with the same file name
     * as the process definition, the deployed image will be returned by the Get Diagram endpoint.
     * Example: `someProcess.bpmn` and `someProcess.png`.
     * Supported file extentions for the image are: `svg`, `png`, `jpg`, and `gif`.
     */
    get: operations["getProcessDefinitionDiagramByKey"];
  };
  "/process-definition/key/{key}/form-variables": {
    /**
     * Retrieves the start form variables for the latest process definition which belongs to no tenant
     * (only if they are defined via the
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms) approach).
     * The start form variables take form data specified on the start event into account.
     * If form fields are defined, the variable types and default values
     * of the form fields are taken into account.
     */
    get: operations["getStartFormVariablesByKey"];
  };
  "/process-definition/key/{key}/history-time-to-live": {
    /**
     * Updates history time to live for the latest version of the process definition which belongs to no tenant.
     * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
     */
    put: operations["updateHistoryTimeToLiveByProcessDefinitionKey"];
  };
  "/process-definition/key/{key}/rendered-form": {
    /**
     * Retrieves  the rendered form for the latest version of the process definition which belongs to no tenant.
     * This method can be used to get the HTML rendering of a
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    get: operations["getRenderedStartFormByKey"];
  };
  "/process-definition/key/{key}/start": {
    /**
     * Instantiates a given process definition, starts the latest version of the process definition
     * which belongs to no tenant.
     * Process variables and business key may be supplied in the request body.
     */
    post: operations["startProcessInstanceByKey"];
  };
  "/process-definition/key/{key}/startForm": {
    /**
     * Retrieves the key of the start form for the latest version of the process definition
     * which belongs to no tenant.
     * The form key corresponds to the `FormData#formKey` property in the engine.
     */
    get: operations["getStartFormByKey"];
  };
  "/process-definition/key/{key}/statistics": {
    /**
     * Retrieves runtime statistics of the latest version of the given process definition
     * which belongs to no tenant, grouped by activities.
     * These statistics include the number of running activity instances, optionally the number of failed jobs
     * and also optionally the number of incidents either grouped by incident types or
     * for a specific incident type.
     * **Note**: This does not include historic data.
     */
    get: operations["getActivityStatisticsByProcessDefinitionKey"];
  };
  "/process-definition/key/{key}/submit-form": {
    /**
     * Starts the latest version of the process definition which belongs to no tenant
     * using a set of process variables and the business key.
     * If the start event has Form Field Metadata defined, the process engine will perform backend validation
     * for any form fields which have validators defined.
     * See [Documentation on Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    post: operations["submitFormByKey"];
  };
  "/process-definition/key/{key}/suspended": {
    /**
     * Activates or suspends a given process definition by latest version of process definition key
     * which belongs to no tenant.
     */
    put: operations["updateProcessDefinitionSuspensionStateByKey"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}": {
    /**
     * Retrieves the latest version of the process definition for tenant according to
     * the `ProcessDefinition` interface in the engine.
     */
    get: operations["getLatestProcessDefinitionByTenantId"];
    /** Deletes process definitions by a given key and which belong to a tenant id. */
    delete: operations["deleteProcessDefinitionsByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/deployed-start-form": {
    /**
     * Retrieves the deployed form that can be referenced from a start event.
     * For further information please refer to [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
     */
    get: operations["getDeployedStartFormByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/diagram": {
    /**
     * Retrieves the diagram for the latest version of the process definition for tenant.
     *
     * If the process definition's deployment contains an image resource with the same file name
     * as the process definition, the deployed image will be returned by the Get Diagram endpoint.
     * Example: `someProcess.bpmn` and `someProcess.png`.
     * Supported file extentions for the image are: `svg`, `png`, `jpg`, and `gif`.
     */
    get: operations["getProcessDefinitionDiagramByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/form-variables": {
    /**
     * Retrieves the start form variables for the latest process definition for a tenant
     * (only if they are defined via the
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms) approach).
     * The start form variables take form data specified on the start event into account.
     * If form fields are defined, the variable types and default values
     * of the form fields are taken into account.
     */
    get: operations["getStartFormVariablesByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/history-time-to-live": {
    /**
     * Updates history time to live for the latest version of the process definition for a tenant.
     * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
     */
    put: operations["updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/rendered-form": {
    /**
     * Retrieves  the rendered form for the latest version of the process definition for a tenant.
     * This method can be used to get the HTML rendering of a
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    get: operations["getRenderedStartFormByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/start": {
    /**
     * Instantiates a given process definition, starts the latest version of the process definition for tenant.
     * Process variables and business key may be supplied in the request body.
     */
    post: operations["startProcessInstanceByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/startForm": {
    /**
     * Retrieves the key of the start form for the latest version of the process definition for a tenant.
     * The form key corresponds to the `FormData#formKey` property in the engine.
     */
    get: operations["getStartFormByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/statistics": {
    /**
     * Retrieves runtime statistics of the latest version of the given process definition for a tenant,
     * grouped by activities.
     * These statistics include the number of running activity instances, optionally the number of failed jobs
     * and also optionally the number of incidents either grouped by incident types or
     * for a specific incident type.
     * **Note**: This does not include historic data.
     */
    get: operations["getActivityStatisticsByProcessDefinitionKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/submit-form": {
    /**
     * Starts the latest version of the process definition for a tenant
     * using a set of process variables and the business key.
     * If the start event has Form Field Metadata defined, the process engine will perform backend validation
     * for any form fields which have validators defined.
     * See [Documentation on Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    post: operations["submitFormByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/suspended": {
    /**
     * Activates or suspends a given process definition by the latest version of
     * the process definition for tenant.
     */
    put: operations["updateProcessDefinitionSuspensionStateByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/tenant-id/{tenant-id}/xml": {
    /**
     * Retrieves latest version the BPMN 2.0 XML of a process definition.
     * Returns the XML for the latest version of the process definition for tenant.
     */
    get: operations["getProcessDefinitionBpmn20XmlByKeyAndTenantId"];
  };
  "/process-definition/key/{key}/xml": {
    /** Retrieves latest version the BPMN 2.0 XML of a process definition. */
    get: operations["getProcessDefinitionBpmn20XmlByKey"];
  };
  "/process-definition/statistics": {
    /**
     * Retrieves runtime statistics of the process engine, grouped by process definitions.
     * These statistics include the number of running process instances, optionally the number of failed jobs
     * and also optionally the number of incidents either grouped by incident types or
     * for a specific incident type.
     * **Note**: This does not include historic data.
     */
    get: operations["getProcessDefinitionStatistics"];
  };
  "/process-definition/suspended": {
    /** Activates or suspends process definitions with the given process definition key. */
    put: operations["updateProcessDefinitionSuspensionState"];
  };
  "/process-definition/{id}": {
    /** Retrieves a process definition according to the `ProcessDefinition` interface in the engine. */
    get: operations["getProcessDefinition"];
    /** Deletes a running process instance by id. */
    delete: operations["deleteProcessDefinition"];
  };
  "/process-definition/{id}/deployed-start-form": {
    /**
     * Retrieves the deployed form that can be referenced from a start event.
     * For further information please refer to [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
     */
    get: operations["getDeployedStartForm"];
  };
  "/process-definition/{id}/diagram": {
    /**
     * Retrieves the diagram of a process definition.
     *
     * If the process definition's deployment contains an image resource with the same file name
     * as the process definition, the deployed image will be returned by the Get Diagram endpoint.
     * Example: `someProcess.bpmn` and `someProcess.png`.
     * Supported file extentions for the image are: `svg`, `png`, `jpg`, and `gif`.
     */
    get: operations["getProcessDefinitionDiagram"];
  };
  "/process-definition/{id}/form-variables": {
    /**
     * Retrieves the start form variables for a process definition
     * (only if they are defined via the
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms) approach).
     * The start form variables take form data specified on the start event into account.
     * If form fields are defined, the variable types and default values
     * of the form fields are taken into account.
     */
    get: operations["getStartFormVariables"];
  };
  "/process-definition/{id}/history-time-to-live": {
    /**
     * Updates history time to live for process definition.
     * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
     */
    put: operations["updateHistoryTimeToLiveByProcessDefinitionId"];
  };
  "/process-definition/{id}/rendered-form": {
    /**
     * Retrieves the rendered form for a process definition.
     * This method can be used to get the HTML rendering of a
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    get: operations["getRenderedStartForm"];
  };
  "/process-definition/{id}/restart": {
    /**
     * Restarts process instances that were canceled or terminated synchronously.
     * Can also restart completed process instances.
     * It will create a new instance using the original instance information.
     * To execute the restart asynchronously, use the
     * [Restart Process Instance Async](https://docs.camunda.org/manual/latest/reference/rest/process-definition/post-restart-process-instance-async/) method.
     *
     * For more information about the difference between synchronous and asynchronous execution,
     * please refer to the related section of the
     * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-instance-restart/#execution).
     */
    post: operations["restartProcessInstance"];
  };
  "/process-definition/{id}/restart-async": {
    /**
     * Restarts process instances that were canceled or terminated asynchronously.
     * Can also restart completed process instances.
     * It will create a new instance using the original instance information.
     * To execute the restart asynchronously, use the
     * [Restart Process Instance](https://docs.camunda.org/manual/latest/reference/rest/process-definition/post-restart-process-instance-sync/) method.
     *
     * For more information about the difference between synchronous and asynchronous execution,
     * please refer to the related section of the
     * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-instance-restart/#execution).
     */
    post: operations["restartProcessInstanceAsyncOperation"];
  };
  "/process-definition/{id}/start": {
    /**
     * Instantiates a given process definition.
     * Process variables and business key may be supplied in the request body.
     */
    post: operations["startProcessInstance"];
  };
  "/process-definition/{id}/startForm": {
    /**
     * Retrieves the key of the start form for a process definition.
     * The form key corresponds to the `FormData#formKey` property in the engine.
     */
    get: operations["getStartForm"];
  };
  "/process-definition/{id}/statistics": {
    /**
     * Retrieves runtime statistics of a given process definition, grouped by activities.
     * These statistics include the number of running activity instances, optionally the number of failed jobs
     * and also optionally the number of incidents either grouped by incident types or for a specific incident type.
     * **Note**: This does not include historic data.
     */
    get: operations["getActivityStatistics"];
  };
  "/process-definition/{id}/submit-form": {
    /**
     * Starts a process instance using a set of process variables and the business key.
     * If the start event has Form Field Metadata defined, the process engine will perform backend validation
     * for any form fields which have validators defined.
     * See [Documentation on Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    post: operations["submitForm"];
  };
  "/process-definition/{id}/suspended": {
    /** Activates or suspends a given process definition by id. */
    put: operations["updateProcessDefinitionSuspensionStateById"];
  };
  "/process-definition/{id}/xml": {
    /** Retrieves the BPMN 2.0 XML of a process definition. */
    get: operations["getProcessDefinitionBpmn20Xml"];
  };
  "/process-instance": {
    /**
     * Queries for process instances that fulfill given parameters.
     * Parameters may be static as well as dynamic runtime properties of process instances.
     * The size of the result set can be retrieved by using the Get Instance Count method.
     */
    get: operations["getProcessInstances"];
    /**
     * Queries for process instances that fulfill given parameters through a JSON object.
     * This method is slightly more powerful than the Get Instances method because
     * it allows filtering by multiple process variables of types `string`, `number` or `boolean`.
     */
    post: operations["queryProcessInstances"];
  };
  "/process-instance/count": {
    /** Queries for the number of process instances that fulfill given parameters. */
    get: operations["getProcessInstancesCount"];
    /**
     * Queries for the number of process instances that fulfill the given parameters.
     * This method takes the same message body as the Get Instances (POST) method and
     * therefore it is slightly more powerful than the Get Instance Count method.
     */
    post: operations["queryProcessInstancesCount"];
  };
  "/process-instance/delete": {
    /** Deletes multiple process instances asynchronously (batch). */
    post: operations["deleteProcessInstancesAsyncOperation"];
  };
  "/process-instance/delete-historic-query-based": {
    /** Deletes a set of process instances asynchronously (batch) based on a historic process instance query. */
    post: operations["deleteAsyncHistoricQueryBased"];
  };
  "/process-instance/job-retries": {
    /** Create a batch to set retries of jobs associated with given processes asynchronously. */
    post: operations["setRetriesByProcess"];
  };
  "/process-instance/job-retries-historic-query-based": {
    /** Create a batch to set retries of jobs asynchronously based on a historic process instance query. */
    post: operations["setRetriesByProcessHistoricQueryBased"];
  };
  "/process-instance/suspended": {
    /**
     * Activates or suspends process instances by providing certain criteria:
     *
     * # Activate/Suspend Process Instance By Process Definition Id
     * * `suspend`
     * * `processDefinitionId`
     *
     * # Activate/Suspend Process Instance By Process Definition Key
     *
     * * `suspend`
     * * `processDefinitionKey`
     * * `processDefinitionTenantId`
     * * `processDefinitionWithoutTenantId`
     *
     * # Activate/Suspend Process Instance In Group
     * * `suspend`
     * * `processInstanceIds`
     * * `processInstanceQuery`
     * * `historicProcessInstanceQuery`
     */
    put: operations["updateSuspensionState"];
  };
  "/process-instance/suspended-async": {
    /**
     * Activates or suspends process instances asynchronously with a list of process instance ids,
     * a process instance query, and/or a historical process instance query.
     */
    post: operations["updateSuspensionStateAsyncOperation"];
  };
  "/process-instance/variables-async": {
    /** Update or create runtime process variables in the root scope of process instances. */
    post: operations["setVariablesAsyncOperation"];
  };
  "/process-instance/{id}": {
    /** Retrieves a process instance by id, according to the `ProcessInstance` interface in the engine. */
    get: operations["getProcessInstance"];
    /** Deletes a running process instance by id. */
    delete: operations["deleteProcessInstance"];
  };
  "/process-instance/{id}/activity-instances": {
    /** Retrieves an Activity Instance (Tree) for a given process instance by id. */
    get: operations["getActivityInstanceTree"];
  };
  "/process-instance/{id}/modification": {
    /**
     * Submits a list of modification instructions to change a process instance's execution state.
     * A modification instruction is one of the following:
     *
     * * Starting execution before an activity
     * * Starting execution after an activity on its single outgoing sequence flow
     * * Starting execution on a specific sequence flow
     * * Canceling an activity instance, transition instance, or all instances (activity or transition) for an activity
     *
     * Instructions are executed immediately and in the order they are provided in this request's body.
     * Variables can be provided with every starting instruction.
     *
     * The exact semantics of modification can be read about in the [User guide](https://docs.camunda.org/manual/develop/user-guide/process-engine/process-instance-modification/).
     */
    post: operations["modifyProcessInstance"];
  };
  "/process-instance/{id}/modification-async": {
    /**
     * Submits a list of modification instructions to change a process instance's execution state async.
     * A modification instruction is one of the following:
     *
     * * Starting execution before an activity
     * * Starting execution after an activity on its single outgoing sequence flow
     * * Starting execution on a specific sequence flow
     * * Cancelling an activity instance, transition instance, or all instances (activity or transition) for an activity
     *
     * Instructions are executed asynchronous and in the order they are provided in this request's body.
     * Variables can be provided with every starting instruction.
     *
     * The exact semantics of modification can be read about in the
     * [User guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-instance-modification/).
     */
    post: operations["modifyProcessInstanceAsyncOperation"];
  };
  "/process-instance/{id}/suspended": {
    /** Activates or suspends a given process instance by id. */
    put: operations["updateSuspensionStateById"];
  };
  "/process-instance/{id}/variables": {
    /** Retrieves all variables of a given process instance by id. */
    get: operations["getProcessInstanceVariables"];
    /**
     * Updates or deletes the variables of a process instance by id. Updates precede deletions.
     * So, if a variable is updated AND deleted, the deletion overrides the update.
     */
    post: operations["modifyProcessInstanceVariables"];
  };
  "/process-instance/{id}/variables/{varName}": {
    /** Retrieves a variable of a given process instance by id. */
    get: operations["getProcessInstanceVariable"];
    /** Sets a variable of a given process instance by id. */
    put: operations["setProcessInstanceVariable"];
    /** Deletes a variable of a process instance by id. */
    delete: operations["deleteProcessInstanceVariable"];
  };
  "/process-instance/{id}/variables/{varName}/data": {
    /**
     * Retrieves the content of a Process Variable by the Process Instance id and the Process Variable name.
     * Applicable for byte array or file Process Variables.
     */
    get: operations["getProcessInstanceVariableBinary"];
    /** Sets the serialized value for a binary variable or the binary value for a file variable. */
    post: operations["setProcessInstanceVariableBinary"];
  };
  "/schema/log": {
    /** Queries for schema log entries that fulfill given parameters. */
    get: operations["getSchemaLog"];
    /** Queries for schema log entries that fulfill given parameters. */
    post: operations["querySchemaLog"];
  };
  "/signal": {
    /**
     * A signal is an event of global scope (broadcast semantics) and is delivered to all
     * active handlers. Internally this maps to the engine's signal event received builder
     * method `RuntimeService#createSignalEvent()`. For more information about the signal
     * behavior, see the [Signal Events](https://docs.camunda.org/manual/latest/reference/bpmn20/events/signal-events/)
     * section of the [BPMN 2.0 Implementation Reference](https://docs.camunda.org/manual/latest/reference/bpmn20/).
     */
    post: operations["throwSignal"];
  };
  "/task": {
    /**
     * Queries for tasks that fulfill a given filter. The size of the result set can be
     * retrieved by using the Get Task Count method.
     *
     * **Security Consideration:** There are several query parameters (such as
     * assigneeExpression) for specifying an EL expression. These are disabled by default to
     * prevent remote code execution. See the section on
     * [security considerations](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
     * for custom code in the user guide for details.
     */
    get: operations["getTasks"];
    /**
     * Queries for tasks that fulfill a given filter. This method is slightly more powerful
     * than the [Get Tasks](https://docs.camunda.org/manual/latest/reference/rest/task/get-query/) method because it
     * allows filtering by multiple process or task variables of types `String`, `Number`
     * or `Boolean`. The size of the result set can be retrieved by using the
     * [Get Task Count (POST)](https://docs.camunda.org/manual/latest/reference/rest/task/post-query-count/) method.
     *
     * **Security Consideration**:
     * There are several parameters (such as `assigneeExpression`) for specifying an EL
     * expression. These are disabled by default to prevent remote code execution. See the
     * section on
     * [security considerations for custom code](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
     * in the user guide for details.
     */
    post: operations["queryTasks"];
  };
  "/task/count": {
    /**
     * Retrieves the number of tasks that fulfill a provided filter. Corresponds to the size
     * of the result set when using the [Get Tasks](https://docs.camunda.org/manual/latest/reference/rest/task/) method.
     *
     * **Security Consideration:** There are several query parameters (such as
     * assigneeExpression) for specifying an EL expression. These are disabled by default to
     * prevent remote code execution. See the section on
     * [security considerations](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
     * for custom code in the user guide for details.
     */
    get: operations["getTasksCount"];
    /**
     * Retrieves the number of tasks that fulfill the given filter. Corresponds to the size
     * of the result set of the [Get Tasks (POST)](https://docs.camunda.org/manual/latest/reference/rest/task/post-query/)
     * method and takes the same parameters.
     *
     * **Security Consideration**:
     * There are several parameters (such as `assigneeExpression`) for specifying an EL
     * expression. These are disabled by default to prevent remote code execution. See the
     * section on
     * [security considerations for custom code](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
     * in the user guide for details.
     */
    post: operations["queryTasksCount"];
  };
  "/task/create": {
    /** Creates a new task. */
    post: operations["createTask"];
  };
  "/task/{id}": {
    /** Retrieves a task by id. */
    get: operations["getTask"];
    /** Updates a task. */
    put: operations["updateTask"];
    /** Removes a task by id. */
    delete: operations["deleteTask"];
  };
  "/task/{id}/assignee": {
    /**
     * Changes the assignee of a task to a specific user.
     *
     * **Note:** The difference with the [Claim Task](https://docs.camunda.org/manual/latest/reference/rest/task/post-claim/)
     * method is that this method does not check if the task already has a user
     * assigned to it.
     */
    post: operations["setAssignee"];
  };
  "/task/{id}/attachment": {
    /** Gets the attachments for a task. */
    get: operations["getAttachments"];
  };
  "/task/{id}/attachment/create": {
    /** Creates an attachment for a task. */
    post: operations["addAttachment"];
  };
  "/task/{id}/attachment/{attachmentId}": {
    /** Retrieves a task attachment by task id and attachment id. */
    get: operations["getAttachment"];
    /** Removes an attachment from a task by id. */
    delete: operations["deleteAttachment"];
  };
  "/task/{id}/attachment/{attachmentId}/data": {
    /** Retrieves the binary content of a task attachment by task id and attachment id. */
    get: operations["getAttachmentData"];
  };
  "/task/{id}/bpmnError": {
    /**
     * Reports a business error in the context of a running task by id. The error code must
     * be specified to identify the BPMN error handler. See the documentation for
     * [Reporting Bpmn Error](https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/#reporting-bpmn-error)
     * in User Tasks.
     */
    post: operations["handleBpmnError"];
  };
  "/task/{id}/bpmnEscalation": {
    /**
     * Reports an escalation in the context of a running task by id. The escalation code must
     * be specified to identify the escalation handler. See the documentation for
     * [Reporting Bpmn Escalation](https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/#reporting-bpmn-escalation)
     * in User Tasks.
     */
    post: operations["handleEscalation"];
  };
  "/task/{id}/claim": {
    /**
     * Claims a task for a specific user.
     *
     * **Note:** The difference with the
     * [Set Assignee](https://docs.camunda.org/manual/latest/reference/rest/task/post-assignee/)
     * method is that here a check is performed to see if the task already has a user
     * assigned to it.
     */
    post: operations["claim"];
  };
  "/task/{id}/comment": {
    /** Gets the comments for a task by id. */
    get: operations["getComments"];
  };
  "/task/{id}/comment/create": {
    /** Creates a comment for a task by id. */
    post: operations["createComment"];
  };
  "/task/{id}/comment/{commentId}": {
    /** Retrieves a task comment by task id and comment id. */
    get: operations["getComment"];
  };
  "/task/{id}/complete": {
    /** Completes a task and updates process variables. */
    post: operations["complete"];
  };
  "/task/{id}/delegate": {
    /** Delegates a task to another user. */
    post: operations["delegateTask"];
  };
  "/task/{id}/deployed-form": {
    /**
     * Retrieves the deployed form that is referenced from a given task. For further
     * information please refer to the
     * [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
     */
    get: operations["getDeployedForm"];
  };
  "/task/{id}/form": {
    /**
     * Retrieves the form key for a task. The form key corresponds to the `FormData#formKey`
     * property in the engine. This key can be used to do task-specific form rendering in
     * client applications. Additionally, the context path of the containing process
     * application is returned.
     */
    get: operations["getForm"];
  };
  "/task/{id}/form-variables": {
    /**
     * Retrieves the form variables for a task. The form variables take form data specified
     * on the task into account. If form fields are defined, the variable types and default
     * values of the form fields are taken into account.
     */
    get: operations["getFormVariables"];
  };
  "/task/{id}/identity-links": {
    /**
     * Gets the identity links for a task by id, which are the users and groups that are in
     * *some* relation to it (including assignee and owner).
     */
    get: operations["getIdentityLinks"];
    /**
     * Adds an identity link to a task by id. Can be used to link any user or group to a task
     * and specify a relation.
     */
    post: operations["addIdentityLink"];
  };
  "/task/{id}/identity-links/delete": {
    /** Removes an identity link from a task by id */
    post: operations["deleteIdentityLink"];
  };
  "/task/{id}/localVariables": {
    /** Retrieves all variables of a given task by id. */
    get: operations["getTaskLocalVariables"];
    /**
     * Updates or deletes the variables in the context of a task. Updates precede deletions. So, if a variable is
     * updated AND deleted, the deletion overrides the update.
     */
    post: operations["modifyTaskLocalVariables"];
  };
  "/task/{id}/localVariables/{varName}": {
    /** Retrieves a variable from the context of a given task by id. */
    get: operations["getTaskLocalVariable"];
    /** Sets a variable in the context of a given task. */
    put: operations["putTaskLocalVariable"];
    /** Removes a local variable from a task by id. */
    delete: operations["deleteTaskLocalVariable"];
  };
  "/task/{id}/localVariables/{varName}/data": {
    /**
     * Retrieves a binary variable from the context of a given task by id. Applicable for byte array and file
     * variables.
     */
    get: operations["getTaskLocalVariableBinary"];
    /** Sets the serialized value for a binary variable or the binary value for a file variable. */
    post: operations["setBinaryTaskLocalVariable"];
  };
  "/task/{id}/rendered-form": {
    /**
     * Retrieves the rendered form for a task. This method can be used to get the HTML
     * rendering of a
     * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
     */
    get: operations["getRenderedForm"];
  };
  "/task/{id}/resolve": {
    /**
     * Resolves a task and updates execution variables.
     *
     * Resolving a task marks that the assignee is done with the task delegated to them, and
     * that it can be sent back to the owner. Can only be executed when the task has been
     * delegated. The assignee will be set to the owner, who performed the delegation.
     */
    post: operations["resolve"];
  };
  "/task/{id}/submit-form": {
    /**
     * Completes a task and updates process variables using a form submit. There are two
     * difference between this method and the `complete` method:
     *
     * * If the task is in state `PENDING` - i.e., has been delegated before, it is not
     * completed but resolved. Otherwise it will be completed.
     * * If the task has Form Field Metadata defined, the process engine will perform backend
     * validation for any form fields which have validators defined.
     * See the
     * [Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/_index/#generated-task-forms)
     * section of the [User Guide](https://docs.camunda.org/manual/latest/user-guide/) for more information.
     */
    post: operations["submit"];
  };
  "/task/{id}/unclaim": {
    /** Resets a task's assignee. If successful, the task is not assigned to a user. */
    post: operations["unclaim"];
  };
  "/task/{id}/variables": {
    /**
     * Retrieves all variables visible from the task. A variable is visible from the task if it is a local task
     * variable or declared in a parent scope of the task. See documentation on
     * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
     */
    get: operations["getTaskVariables"];
    /**
     * Updates or deletes the variables visible from the task. Updates precede deletions. So, if a variable is
     * updated AND deleted, the deletion overrides the update. A variable is visible from the task if it is a
     * local task variable or declared in a parent scope of the task. See documentation on
     * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
     */
    post: operations["modifyTaskVariables"];
  };
  "/task/{id}/variables/{varName}": {
    /**
     * Retrieves a variable from the context of a given task.
     * The variable must be visible from the task. It is visible from the task if it is a local task variable or
     * declared in a parent scope of the task. See documentation on
     * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
     */
    get: operations["getTaskVariable"];
    /**
     * Updates a process variable that is visible from the Task scope. A variable is visible from the task if it
     * is a local task variable, or declared in a parent scope of the task. See the documentation on
     * [variable scopes and visibility](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables#variable-scopes-and-variable-visibility).
     *
     * **Note**: If a variable doesn't exist, the variable is created in the top-most scope
     * visible from the task.
     */
    put: operations["putTaskVariable"];
    /**
     * Removes a variable that is visible to a task. A variable is visible to a task if it is a local task
     * variable or declared in a parent scope of the task. See documentation on
     * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
     */
    delete: operations["deleteTaskVariable"];
  };
  "/task/{id}/variables/{varName}/data": {
    /**
     * Retrieves a binary variable from the context of a given task. Applicable for byte array and file
     * variables. The variable must be visible from the task. It is visible from the task if it is a local task
     * variable or declared in a parent scope of the task. See documentation on
     * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
     */
    get: operations["getTaskVariableBinary"];
    /**
     * Sets the serialized value for a binary variable or the binary value for a file variable visible from the
     * task. A variable is visible from the task if it is a local task variable or declared in a parent scope of
     * the task. See documentation on
     * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
     */
    post: operations["setBinaryTaskVariable"];
  };
  "/telemetry/configuration": {
    /** Fetches Telemetry Configuration. */
    get: operations["getTelemetryConfiguration"];
    /** Configures whether Camunda receives data collection of the process engine setup and usage. */
    post: operations["configureTelemetry"];
  };
  "/tenant": {
    /**
     * Query for a list of tenants using a list of parameters. The size of the result set
     * can be retrieved by using the [Get Tenant
     * Count](https://docs.camunda.org/manual/latest/reference/rest/tenant/get-query-count/) method.
     */
    get: operations["queryTenants"];
    /**
     * The `/tenant` resource supports two custom OPTIONS requests, this one for the resource
     * as such and one for individual tenant instances. The OPTIONS request
     * allows checking for the set of available operations that the currently
     * authenticated user can perform on the `/tenant` resource. If the user
     * can perform an operation or not may depend on various things,
     * including the users authorizations to interact with this resource and
     * the internal configuration of the process engine.
     */
    options: operations["availableTenantResourceOperations"];
  };
  "/tenant/count": {
    /** Query for tenants using a list of parameters and retrieves the count. */
    get: operations["getTenantCount"];
  };
  "/tenant/create": {
    /** Create a new tenant. */
    post: operations["createTenant"];
  };
  "/tenant/{id}": {
    /** Retrieves a tenant. */
    get: operations["getTenant"];
    /** Updates a given tenant. */
    put: operations["updateTenant"];
    /** Deletes a tenant by id. */
    delete: operations["deleteTenant"];
    /**
     * The `/tenant` resource supports two custom OPTIONS requests, one for the resource as such and this one for
     * individual tenant instances. The OPTIONS request allows checking for the set of available operations that
     * the currently authenticated user can perform on the `/tenant/{id}` resource. If the user can perform an
     * operation or not may depend on various things, including the users authorizations to interact with this
     * resource and the internal configuration of the process engine.
     */
    options: operations["availableTenantInstanceOperations"];
  };
  "/tenant/{id}/group-members": {
    /**
     * The OPTIONS request allows checking for the set of available operations that the
     * currently authenticated user can perform on the resource. If the user
     * can perform an operation or not may depend on various things,
     * including the users authorizations to interact with this resource and
     * the internal configuration of the process engine.
     */
    options: operations["availableTenantGroupMembersOperations"];
  };
  "/tenant/{id}/group-members/{groupId}": {
    /** Creates a membership between a tenant and a group. */
    put: operations["createGroupMembership"];
    /** Creates a membership between a tenant and a group. */
    delete: operations["deleteGroupMembership"];
  };
  "/tenant/{id}/user-members": {
    /**
     * The OPTIONS request allows checking for the set of available operations that the
     * currently authenticated user can perform on the resource. If the user
     * can perform an operation or not may depend on various things,
     * including the users authorizations to interact with this resource and
     * the internal configuration of the process engine.
     */
    options: operations["availableTenantUserMembersOperations"];
  };
  "/tenant/{id}/user-members/{userId}": {
    /** Creates a membership between a tenant and an user. */
    put: operations["createUserMembership"];
    /** Deletes a membership between a tenant and an user. */
    delete: operations["deleteUserMembership"];
  };
  "/user": {
    /**
     * Query for a list of users using a list of parameters.
     * The size of the result set can be retrieved by using the Get User Count method.
     * [Get User Count](https://docs.camunda.org/manual/latest/reference/rest/user/get-query-count/) method.
     */
    get: operations["getUsers"];
    /**
     * The `/user` resource supports two custom `OPTIONS` requests, one for the resource as such
     * and one for individual user instances. The `OPTIONS` request allows checking for the set of
     * available operations that the currently authenticated user can perform on the /user resource.
     * If the user can perform an operation or not may depend on various things, including the user's
     * authorizations to interact with this resource and the internal configuration of the process
     * engine. `OPTIONS /user` returns available interactions on the resource.
     */
    options: operations["availableOperations"];
  };
  "/user/count": {
    /**
     * Queries for the number of deployments that fulfill given parameters. Takes the same parameters as the
     * [Get Users](https://docs.camunda.org/manual/latest/reference/rest/user/get-query/) method.
     */
    get: operations["getUserCount"];
  };
  "/user/create": {
    /** Create a new user. */
    post: operations["createUser"];
  };
  "/user/{id}": {
    /** Deletes a user by id. */
    delete: operations["deleteUser"];
    /**
     * The `/user` resource supports two custom `OPTIONS` requests, one for the resource as such
     * and one for individual user instances. The `OPTIONS` request allows checking for the set of
     * available operations that the currently authenticated user can perform on the /user resource.
     * If the user can perform an operation or not may depend on various things, including the user's
     * authorizations to interact with this resource and the internal configuration of the process
     * engine. `OPTIONS /user/{id}` returns available interactions on a resource instance.
     */
    options: operations["availableUserOperations"];
  };
  "/user/{id}/credentials": {
    /** Updates a user's credentials (password) */
    put: operations["updateCredentials"];
  };
  "/user/{id}/profile": {
    /** Retrieves a user's profile. */
    get: operations["getUserProfile"];
    /** Updates the profile information of an already existing user. */
    put: operations["updateProfile"];
  };
  "/user/{id}/unlock": {
    /** Unlocks a user by id. */
    post: operations["unlockUser"];
  };
  "/variable-instance": {
    /**
     * Query for variable instances that fulfill given parameters. Parameters may be the
     * properties of variable instances, such as the name or type. The size
     * of the result set can be retrieved by using the [Get Variable Instance
     * Count](https://docs.camunda.org/manual/latest/reference/rest/variable-instance/get-query-count/)
     * method.
     */
    get: operations["getVariableInstances"];
    /**
     * Query for variable instances that fulfill given parameters through a JSON object.
     * This method is slightly more powerful than the
     * [Get Variable Instances](https://docs.camunda.org/manual/latest/reference/rest/variable-
     * instance/get-query/) method because it allows filtering by multiple
     * variable instances of types `String`, `Number` or `Boolean`.
     */
    post: operations["queryVariableInstances"];
  };
  "/variable-instance/count": {
    /**
     * Query for the number of variable instances that fulfill given parameters. Takes the
     * same parameters as the [Get Variable
     * Instances](https://docs.camunda.org/manual/latest/reference/rest/variable-instance/get-query/)
     * method.
     */
    get: operations["getVariableInstancesCount"];
    /**
     * Query for the number of variable instances that fulfill given parameters. This
     * method takes the same message body as the
     * [Get Variable Instances POST](https://docs.camunda.org/manual/latest/reference/rest/variable-
     * instance/post-query/) method and therefore it is slightly more
     * powerful than the [Get Variable Instance
     * Count](https://docs.camunda.org/manual/latest/reference/rest/variable-instance/get-query-count/)
     * method.
     */
    post: operations["queryVariableInstancesCount"];
  };
  "/variable-instance/{id}": {
    /** Retrieves a variable by id. */
    get: operations["getVariableInstance"];
  };
  "/variable-instance/{id}/data": {
    /**
     * Retrieves the content of a variable by id. Applicable for byte array and file
     * variables.
     */
    get: operations["getVariableInstanceBinary"];
  };
  "/version": {
    /** Retrieves the version of the Rest API. */
    get: operations["getRestAPIVersion"];
  };
}

export interface components {
  schemas: {
    AbstractSetRemovalTimeDto: {
      /**
       * The date for which the instances shall be removed. Value may not be `null`.
       *
       * **Note:** Cannot be set in conjunction with `clearedRemovalTime` or `calculatedRemovalTime`.
       */
      absoluteRemovalTime?: string | null;
      /**
       * Sets the removal time to `null`. Value may only be `true`, as `false` is the default behavior.
       *
       * **Note:** Cannot be set in conjunction with `absoluteRemovalTime` or `calculatedRemovalTime`.
       */
      clearedRemovalTime?: boolean | null;
      /**
       * The removal time is calculated based on the engine's configuration settings. Value may only be `true`, as `false` is the default behavior.
       *
       * **Note:** Cannot be set in conjunction with `absoluteRemovalTime` or `clearedRemovalTime`.
       */
      calculatedRemovalTime?: boolean | null;
    };
    /** A JSON object corresponding to the Activity Instance tree of the given process instance. */
    ActivityInstanceDto: {
      /** The id of the activity instance. */
      id?: string | null;
      /** The id of the parent activity instance, for example a sub process instance. */
      parentActivityInstanceId?: string | null;
      /** The id of the activity. */
      activityId?: string | null;
      /** The name of the activity */
      activityName?: string | null;
      /** The type of activity (corresponds to the XML element name in the BPMN 2.0, e.g., 'userTask') */
      activityType?: string | null;
      /** The id of the process instance this activity instance is part of. */
      processInstanceId?: string | null;
      /** The id of the process definition. */
      processDefinitionId?: string | null;
      /** A list of child activity instances. */
      childActivityInstances?:
        | components["schemas"]["ActivityInstanceDto"][]
        | null;
      /**
       * A list of child transition instances.
       * A transition instance represents an execution waiting in an asynchronous continuation.
       */
      childTransitionInstances?:
        | components["schemas"]["TransitionInstanceDto"][]
        | null;
      /** A list of execution ids. */
      executionIds?: string[] | null;
      /** A list of incident ids. */
      incidentIds?: string[] | null;
      /**
       * A list of JSON objects containing incident specific properties:
       * * `id`: the id of the incident
       * * `activityId`: the activity id in which the incident occurred
       */
      incidents?: components["schemas"]["ActivityInstanceIncidentDto"][] | null;
    };
    /** An activity instance, incident pair. */
    ActivityInstanceIncidentDto: {
      /** The id of the incident. */
      id?: string | null;
      /** The activity id in which the incident happened. */
      parentActivityInstanceId?: string | null;
    };
    ActivityStatisticsResultDto: {
      /** The id of the activity the results are aggregated for. */
      id?: string | null;
      /** The total number of running process instances of this activity. */
      instances?: number;
      /**
       * The total number of failed jobs for the running instances.
       * **Note**: Will be `0` (not `null`), if failed jobs were excluded.
       */
      failedJobs?: number;
      /**
       * Each item in the resulting array is an object which contains `incidentType` and `incidentCount`.
       * **Note**: Will be an empty array, if `incidents` or `incidentsForType` were excluded.
       * Furthermore, the array will be also empty if no incidents were found.
       */
      incidents?: components["schemas"]["IncidentStatisticsResultDto"][] | null;
    };
    AnnotationDto: {
      /** The annotation value to put. */
      annotation?: string | null;
    };
    AtomLink: {
      /** The relation of the link to the object that belongs to. */
      rel?: string | null;
      /** The url of the link. */
      href?: string | null;
      /** The http method. */
      method?: string | null;
    };
    AttachmentDto: {
      /** The id of the task attachment. */
      id?: string | null;
      /** The name of the task attachment. */
      name?: string | null;
      /** The description of the task attachment. */
      description?: string | null;
      /** The id of the task to which the attachment belongs. */
      taskId?: string | null;
      /**
       * Indication of the type of content that this attachment refers to.
       * Can be MIME type or any other indication.
       */
      type?: string | null;
      /** The url to the remote content of the task attachment. */
      url?: string | null;
      /**
       * The time the variable was inserted.
       * [Default format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      createTime?: string | null;
      /**
       * The time after which the attachment should be removed by the History Cleanup job.
       * [Default format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      removalTime?: string | null;
      /** The process instance id of the root process instance that initiated the process containing the task. */
      rootProcessInstanceId?: string | null;
    } & components["schemas"]["LinkableDto"];
    AuthenticationResult: {
      /** An id of authenticated user. */
      authenticatedUser?: string | null;
      /** A flag indicating if user is authenticated. */
      isAuthenticated?: boolean | null;
      /** Will be null. */
      tenants?: string[] | null;
      /** Will be null. */
      groups?: string[] | null;
    };
    AuthorizationExceptionDto: {
      /** The id of the user that does not have expected permissions */
      userId?: string | null;
      missingAuthorizations?:
        | components["schemas"]["MissingAuthorizationDto"][]
        | null;
    } & components["schemas"]["ExceptionDto"];
    BasicUserCredentialsDto: {
      /** The username of a user. */
      username?: string | null;
      /** A password of a user. */
      password?: string | null;
    };
    BatchDto: {
      /** The id of the batch. */
      id?: string | null;
      /**
       * The type of the batch.
       * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/batch/#creating-a-batch)
       * for more information about batch types.
       */
      type?: string | null;
      /** The total jobs of a batch is the number of batch execution jobs required to complete the batch. */
      totalJobs?: number | null;
      /** The number of batch execution jobs already created by the seed job. */
      jobsCreated?: number | null;
      /**
       * The number of batch execution jobs created per seed job invocation.
       * The batch seed job is invoked until it has created all batch execution jobs required by the batch
       * (see `totalJobs` property).
       */
      batchJobsPerSeed?: number | null;
      /**
       * Every batch execution job invokes the command executed by the batch `invocationsPerBatchJob` times.
       * E.g., for a process instance migration batch this specifies the number of process instances which are migrated per batch execution job.
       */
      invocationsPerBatchJob?: number | null;
      /** The job definition id for the seed jobs of this batch. */
      seedJobDefinitionId?: string | null;
      /** The job definition id for the monitor jobs of this batch. */
      monitorJobDefinitionId?: string | null;
      /** The job definition id for the batch execution jobs of this batch. */
      batchJobDefinitionId?: string | null;
      /** Indicates whether this batch is suspended or not. */
      suspended?: boolean | null;
      /** The tenant id of the batch. */
      tenantId?: string | null;
      /** The id of the user that created the batch. */
      createUserId?: string | null;
    };
    BatchStatisticsDto: {
      /**
       * The number of remaining batch execution jobs. This does include failed batch execution jobs and
       * batch execution jobs which still have to be created by the seed job.
       */
      remainingJobs?: number | null;
      /** The number of completed batch execution jobs. This does include aborted/deleted batch execution jobs. */
      completedJobs?: number | null;
      /** The number of failed batch execution jobs. This does not include aborted or deleted batch execution jobs. */
      failedJobs?: number | null;
    } & components["schemas"]["BatchDto"];
    CaseDefinitionDto: {
      /** The id of the case definition */
      id?: string | null;
      /** The key of the case definition, i.e., the id of the CMMN 2.0 XML case definition. */
      key?: string | null;
      /** The category of the case definition. */
      category?: string | null;
      /** The name of the case definition. */
      name?: string | null;
      /** The version of the case definition that the engine assigned to it. */
      version?: number | null;
      /** The file name of the case definition. */
      resource?: string | null;
      /** The deployment id of the case definition. */
      deploymentId?: string | null;
      /** The tenant id of the case definition. */
      tenantId?: string | null;
      /**
       * History time to live value of the case definition.
       * Is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
       */
      historyTimeToLive?: number | null;
    };
    CheckPasswordPolicyResultDto: {
      /** `true` if the password is compliant with the policy, otherwise `false`. */
      valid?: boolean | null;
    } & components["schemas"]["PasswordPolicyDto"];
    CheckPasswordPolicyRuleDto: {
      /** `true` if the password is compliant with this rule, otherwise `false`. */
      valid?: boolean | null;
    } & components["schemas"]["PasswordPolicyRuleDto"];
    CommentDto: {
      /** The id of the task comment. */
      id?: string | null;
      /** The id of the user who created the comment. */
      userId?: string | null;
      /** The id of the task to which the comment belongs. */
      taskId?: string | null;
      /**
       * The time when the comment was created.
       * [Default format]($(docsUrl)/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      time?: string | null;
      /** The content of the comment. */
      message?: string | null;
      /**
       * The time after which the comment should be removed by the History Cleanup job.
       * [Default format]($(docsUrl)/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      removalTime?: string | null;
      /**
       * The process instance id of the root process instance that initiated the process
       * containing the task.
       */
      rootProcessInstanceId?: string | null;
    } & components["schemas"]["LinkableDto"];
    CompleteExternalTaskDto: {
      /** A JSON object containing variable key-value pairs. Each key is a variable name and each value a JSON variable value object with the following properties: */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /** A JSON object containing local variable key-value pairs. Local variables are set only in the scope of external task. Each key is a variable name and each value a JSON variable value object with the following properties: */
      localVariables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    } & components["schemas"]["HandleExternalTaskDto"];
    CompleteTaskDto: {
      /** A JSON object containing variable key-value pairs. */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * Indicates whether the response should contain the process variables or not. The
       * default is `false` with a response code of `204`. If set to `true` the response
       * contains the process variables and has a response code of `200`. If the task is not
       * associated with a process instance (e.g. if it's part of a case instance) no
       * variables will be returned.
       */
      withVariablesInReturn?: boolean | null;
    };
    ConditionQueryParameterDto: {
      /** Comparison operator to be used */
      operator?: ("eq" | "neq" | "gt" | "gteq" | "lt" | "lteq" | "like") | null;
      /** The variable value, could be of type boolean, string or number */
      value?: { [key: string]: any };
    };
    CorrelationMessageDto: {
      /** The name of the message to deliver. */
      messageName?: string | null;
      /**
       * Used for correlation of process instances that wait for incoming messages.
       * Will only correlate to executions that belong to a process instance with the provided business key.
       */
      businessKey?: string | null;
      /**
       * Used to correlate the message for a tenant with the given id.
       * Will only correlate to executions and process definitions which belong to the tenant.
       * Must not be supplied in conjunction with a `withoutTenantId`.
       */
      tenantId?: string | null;
      /**
       * A Boolean value that indicates whether the message should only be correlated to executions
       * and process definitions which belong to no tenant or not. Value may only be `true`, as `false`
       * is the default behavior.
       * Must not be supplied in conjunction with a `tenantId`.
       */
      withoutTenantId?: boolean | null;
      /** Used to correlate the message to the process instance with the given id. */
      processInstanceId?: string | null;
      /**
       * Used for correlation of process instances that wait for incoming messages.
       * Has to be a JSON object containing key-value pairs that are matched against process instance variables
       * during correlation. Each key is a variable name and each value a JSON variable value object with the
       * following properties.
       */
      correlationKeys?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * Local variables used for correlation of executions (process instances) that wait for incoming messages.
       * Has to be a JSON object containing key-value pairs that are matched against local variables during correlation.
       * Each key is a variable name and each value a JSON variable value object with the following properties.
       */
      localCorrelationKeys?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * A map of variables that is injected into the triggered execution or process instance after the message
       * has been delivered. Each key is a variable name and each value a JSON variable value object with
       * the following properties.
       */
      processVariables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * A map of local variables that is injected into the triggered execution or process instance after the
       * message has been delivered. Each key is a variable name and each value a JSON variable value object
       * with the following properties.
       */
      processVariablesLocal?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * A Boolean value that indicates whether the message should be correlated to exactly one entity or multiple entities.
       * If the value is set to `false`, the message will be correlated to exactly one entity (execution or process definition).
       * If the value is set to `true`, the message will be correlated to multiple executions and a process definition that
       * can be instantiated by this message in one go.
       */
      all?: boolean | null;
      /**
       * A Boolean value that indicates whether the result of the correlation should be returned or not.
       * If this property is set to `true`, there will be returned a list of message correlation result objects. Depending on the
       * all property, there will be either one ore more returned results in the list.
       *
       * The default value is `false`, which means no result will be returned.
       */
      resultEnabled?: boolean | null;
      /**
       * A Boolean value that indicates whether the result of the correlation should contain process variables or not.
       * The parameter resultEnabled should be set to `true` in order to use this it.
       *
       * The default value is `false`, which means the variables will not be returned.
       */
      variablesInResultEnabled?: boolean | null;
    };
    CountResultDto: {
      /** The number of matching instances. */
      count?: number;
    };
    CreateIncidentDto: {
      /** A type of the new incident. */
      incidentType?: string | null;
      /** A configuration for the new incident. */
      configuration?: string | null;
      /** A message for the new incident. */
      message?: string | null;
    };
    DecisionDefinitionDiagramDto: {
      /** The id of the decision definition. */
      id?: string | null;
      /**
       * An escaped XML string containing the XML that this decision definition was deployed with.
       * Carriage returns, line feeds and quotation marks are escaped.
       */
      dmnXml?: string | null;
    };
    DecisionDefinitionDto: {
      /** The id of the decision definition */
      id?: string | null;
      /** The key of the decision definition, i.e., the id of the DMN 1.0 XML decision definition. */
      key?: string | null;
      /** The category of the decision definition. */
      category?: string | null;
      /** The name of the decision definition. */
      name?: string | null;
      /** The version of the decision definition that the engine assigned to it. */
      version?: number | null;
      /** The file name of the decision definition. */
      resource?: string | null;
      /** The deployment id of the decision definition. */
      deploymentId?: string | null;
      /** The tenant id of the decision definition. */
      tenantId?: string | null;
      /** The id of the decision requirements definition this decision definition belongs to. */
      decisionRequirementsDefinitionId?: string | null;
      /** The key of the decision requirements definition this decision definition belongs to. */
      decisionRequirementsDefinitionKey?: string | null;
      /**
       * History time to live value of the decision definition.
       * Is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
       */
      historyTimeToLive?: number | null;
      /** The version tag of the decision definition. */
      versionTag?: string | null;
    };
    DecisionRequirementsDefinitionDto: {
      /** The id of the decision requirements definition */
      id?: string | null;
      /** The key of the decision requirements definition, i.e., the id of the DMN 1.0 XML decision definition. */
      key?: string | null;
      /** The name of the decision requirements definition. */
      name?: string | null;
      /** The category of the decision requirements definition. */
      category?: string | null;
      /** The version of the decision requirements definition that the engine assigned to it. */
      version?: number | null;
      /** The file name of the decision requirements definition. */
      resource?: string | null;
      /** The deployment id of the decision requirements definition. */
      deploymentId?: string | null;
      /** The tenant id of the decisionrequirements definition. */
      tenantId?: string | null;
    };
    DeleteHistoricProcessInstancesDto: {
      /** A list historic process instance ids to delete. */
      historicProcessInstanceIds?: string[] | null;
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
      /** A string with delete reason. */
      deleteReason?: string | null;
      /** If set to `false`, the request will still be successful if one ore more of the process ids are not found. */
      failIfNotExists?: boolean | null;
    };
    DeleteProcessInstancesDto: {
      /** A list process instance ids to delete. */
      processInstanceIds?: string[] | null;
      /** A string with delete reason. */
      deleteReason?: string | null;
      /** Skip execution listener invocation for activities that are started or ended as part of this request. */
      skipCustomListeners?: boolean | null;
      /** Skip deletion of the subprocesses related to deleted processes as part of this request. */
      skipSubprocesses?: boolean | null;
      processInstanceQuery?: components["schemas"]["ProcessInstanceQueryDto"];
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
    };
    DeploymentDto: {
      /** The id of the deployment. */
      id?: string | null;
      /** The tenant id of the deployment. */
      tenantId?: string | null;
      /** The time when the deployment was created. */
      deploymentTime?: string | null;
      /** The source of the deployment. */
      source?: string | null;
      /** The name of the deployment. */
      name?: string | null;
    } & components["schemas"]["LinkableDto"];
    /**
     * A JSON object corresponding to the `Resource` interface in the engine.
     * Its properties are as follows:
     */
    DeploymentResourceDto: {
      /** The id of the deployment resource. */
      id?: string | null;
      /** The name of the deployment resource */
      name?: string | null;
      /** The id of the deployment. */
      deploymentId?: string | null;
    };
    DeploymentWithDefinitionsDto: {
      /**
       * A JSON Object containing a property for each of the process definitions,
       * which are successfully deployed with that deployment.
       * The key is the process definition id, the value is a JSON Object corresponding to the process definition.
       */
      deployedProcessDefinitions?: {
        [key: string]: components["schemas"]["ProcessDefinitionDto"];
      } | null;
      /**
       * A JSON Object containing a property for each of the decision definitions,
       * which are successfully deployed with that deployment.
       * The key is the decision definition id, the value is a JSON Object corresponding to the decision definition.
       */
      deployedDecisionDefinitions?: {
        [key: string]: components["schemas"]["DecisionDefinitionDto"];
      } | null;
      /**
       * A JSON Object containing a property for each of the decision requirements definitions,
       * which are successfully deployed with that deployment.
       * The key is the decision requirements definition id, the value is a JSON Object corresponding to the decision requirements definition.
       */
      deployedDecisionRequirementsDefinitions?: {
        [
          key: string
        ]: components["schemas"]["DecisionRequirementsDefinitionDto"];
      } | null;
      /**
       * A JSON Object containing a property for each of the case definitions,
       * which are successfully deployed with that deployment.
       * The key is the case definition id, the value is a JSON Object corresponding to the case definition.
       */
      deployedCaseDefinitions?: {
        [key: string]: components["schemas"]["CaseDefinitionDto"];
      } | null;
    } & components["schemas"]["DeploymentDto"];
    DurationReportResultDto: {
      /**
       * Specifies a timespan within a year.
       * **Note:** The period must be interpreted in conjunction with the returned `periodUnit`.
       */
      period?: number | null;
      /** The unit of the given period. Possible values are `MONTH` and `QUARTER`. */
      periodUnit?: ("MONTH" | "QUARTER") | null;
      /** The smallest duration in milliseconds of all completed process instances which were started in the given period. */
      minimum?: number | null;
      /** The greatest duration in milliseconds of all completed process instances which were started in the given period. */
      maximum?: number | null;
      /** The average duration in milliseconds of all completed process instances which were started in the given period. */
      average?: number | null;
    };
    EvaluateDecisionDto: {
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    EvaluationConditionDto: {
      /**
       * A map of variables which are used for evaluation of the conditions and are injected into the process instances which have been triggered.
       * Each key is a variable name and each value a JSON variable value object with the following properties.
       */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /** Used for the process instances that have been triggered after the evaluation. */
      businessKey?: string | null;
      /**
       * Used to evaluate a condition for a tenant with the given id.
       * Will only evaluate conditions of process definitions which belong to the tenant.
       */
      tenantId?: string | null;
      /**
       * A Boolean value that indicates whether the conditions should only be evaluated of process definitions which belong to no tenant or not.
       * Value may only be true, as false is the default behavior.
       */
      withoutTenantId?: boolean | null;
      /** Used to evaluate conditions of the process definition with the given id. */
      processDefinitionId?: string | null;
    };
    EventSubscriptionDto: {
      /** The id of the event subscription. */
      id?: string | null;
      /** The type of the event subscription. */
      eventType?: string | null;
      /** The name of the event this subscription belongs to as defined in the process model. */
      eventName?: string | null;
      /** The execution that is subscribed on the referenced event. */
      executionId?: string | null;
      /** The process instance this subscription belongs to. */
      processInstanceId?: string | null;
      /**
       * The identifier of the activity that this event subscription belongs to.
       * This could for example be the id of a receive task.
       */
      activityId?: string | null;
      /** The time this event subscription was created. */
      createdDate?: string | null;
      /**
       * The id of the tenant this event subscription belongs to.
       * Can be `null` if the subscription belongs to no single tenant.
       */
      tenantId?: string | null;
    };
    /** A event subscription query which retrieves a list of event subscriptions */
    EventSubscriptionQueryDto: {
      /** The id of the event subscription. */
      eventSubscriptionId?: string | null;
      /** The name of the event this subscription belongs to as defined in the process model. */
      eventName?: string | null;
      /** The type of the event subscription. */
      eventType?: ("message" | "signal" | "compensate" | "conditional") | null;
      /** The execution that is subscribed on the referenced event. */
      executionId?: string | null;
      /** The process instance this subscription belongs to. */
      processInstanceId?: string | null;
      /**
       * The identifier of the activity that this event subscription belongs to.
       * This could for example be the id of a receive task.
       */
      activityId?: string | null;
      /**
       * Filter by a comma-separated list of tenant ids.
       * Only select subscriptions that belong to one of the given tenant ids.
       */
      tenantIdIn?: string[] | null;
      /**
       * Only select subscriptions which have no tenant id.
       * Value may only be `true`, as `false` is the default behavior.
       */
      withoutTenantId?: boolean | null;
      /**
       * Select event subscriptions which have no tenant id.
       * Can be used in combination with tenantIdIn parameter.
       * Value may only be `true`, as `false` is the default behavior.
       */
      includeEventSubscriptionsWithoutTenantId?: boolean | null;
      /** Apply sorting of the result */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: ("created" | "tenantId") | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    ExceptionDto: {
      /** An exception class indicating the occurred error. */
      type?: string | null;
      /** A detailed message of the error. */
      message?: string | null;
    };
    ExecutionDto: {
      /** The id of the Execution. */
      id?: string | null;
      /** The id of the root of the execution tree representing the process instance. */
      processInstanceId?: string | null;
      /** Indicates if the execution is ended. */
      ended?: boolean | null;
      /**
       * The id of the tenant this execution belongs to. Can be `null`
       * if the execution belongs to no single tenant.
       */
      tenantId?: string | null;
    };
    /** A Execution instance query which defines a list of Execution instances */
    ExecutionQueryDto: {
      /** Filter by the business key of the process instances the executions belong to. */
      businessKey?: string | null;
      /** Filter by the process definition the executions run on. */
      processDefinitionId?: string | null;
      /** Filter by the key of the process definition the executions run on. */
      processDefinitionKey?: string | null;
      /** Filter by the id of the process instance the execution belongs to. */
      processInstanceId?: string | null;
      /** Filter by the id of the activity the execution currently executes. */
      activityId?: string | null;
      /** Select only those executions that expect a signal of the given name. */
      signalEventSubscriptionName?: string | null;
      /** Select only those executions that expect a message of the given name. */
      messageEventSubscriptionName?: string | null;
      /**
       * Only include active executions. Value may only be `true`, as `false` is the default
       * behavior.
       */
      active?: boolean | null;
      /**
       * Only include suspended executions. Value may only be `true`, as `false` is the default
       * behavior.
       */
      suspended?: boolean | null;
      /** Filter by the incident id. */
      incidentId?: string | null;
      /** Filter by the incident type. See the [User Guide](/manual/develop/user-guide/process-engine/incidents/#incident-types) for a list of incident types. */
      incidentType?: string | null;
      /** Filter by the incident message. Exact match. */
      incidentMessage?: string | null;
      /** Filter by the incident message that the parameter is a substring of. */
      incidentMessageLike?: string | null;
      /**
       * Filter by a  list of tenant ids. An execution must have one of the given
       * tenant ids.
       */
      tenantIdIn?: string[] | null;
      /**
       * An array to only include executions that have variables with certain values.
       *
       * The array consists of objects with the three properties `name`, `operator`
       * and `value`.
       * `name (String)` is the variable name, `operator (String)` is the comparison
       * operator to be used and `value` the variable value.
       * `value` may be `String`, `Number` or `Boolean`.
       *
       * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` -
       * greater than;
       * `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or
       * equal to;
       * `like`.
       */
      variables?: components["schemas"]["VariableQueryParameterDto"][] | null;
      /**
       * An array to only include executions that belong to a process instance with variables
       * with certain values.
       *
       * The array consists of objects with the three properties `name`, `operator`
       * and `value`.
       * `name (String)` is the variable name, `operator (String)` is the comparison
       * operator to be used and `value` the variable value.
       * `value` may be `String`, `Number` or `Boolean`.
       *
       * Valid operator values are: `eq` - equal to; `neq` - not equal to.
       */
      processVariables?:
        | components["schemas"]["VariableQueryParameterDto"][]
        | null;
      /**
       * Match all variable names provided in `variables` and `processVariables` case-
       * insensitively. If set to `true` **variableName** and **variablename** are
       * treated as equal.
       */
      variableNamesIgnoreCase?: boolean | null;
      /**
       * Match all variable values provided in `variables` and `processVariables` case-
       * insensitively. If set to `true` **variableValue** and **variablevalue** are
       * treated as equal.
       */
      variableValuesIgnoreCase?: boolean | null;
      /**
       * An array of criteria to sort the result by. Each element of the array is
       *                        an object that specifies one ordering. The position in the array
       *                        identifies the rank of an ordering, i.e., whether it is primary, secondary,
       *                        etc. Has no effect for the `/count` endpoint
       */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | ("instanceId" | "definitionKey" | "definitionId" | "tenantId")
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    ExecutionTriggerDto: {
      /**
       * A JSON object containing variable key-value pairs. Each key is a variable name and
       * each value a JSON variable value object.
       */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    ExtendLockOnExternalTaskDto: {
      /**
       * An amount of time (in milliseconds). This is the new lock duration starting from the
       * current moment.
       */
      newDuration?: number | null;
    } & components["schemas"]["HandleExternalTaskDto"];
    ExternalTaskBpmnError: {
      /**
       * The id of the worker that reports the failure. Must match the id of the worker who has most recently
       * locked the task.
       */
      workerId?: string | null;
    } & components["schemas"]["TaskBpmnErrorDto"];
    /** An External Task object with the following properties */
    ExternalTaskDto: {
      /** The id of the activity that this external task belongs to. */
      activityId?: string | null;
      /** The id of the activity instance that the external task belongs to. */
      activityInstanceId?: string | null;
      /**
       * The full error message submitted with the latest reported failure executing this task; `null` if no
       * failure was reported previously or if no error message was submitted
       */
      errorMessage?: string | null;
      /** The id of the execution that the external task belongs to. */
      executionId?: string | null;
      /** The id of the external task. */
      id?: string | null;
      /** The date that the task's most recent lock expires or has expired. */
      lockExpirationTime?: string | null;
      /** The id of the process definition the external task is defined in. */
      processDefinitionId?: string | null;
      /** The key of the process definition the external task is defined in. */
      processDefinitionKey?: string | null;
      /** The version tag of the process definition the external task is defined in. */
      processDefinitionVersionTag?: string | null;
      /** The id of the process instance the external task belongs to. */
      processInstanceId?: string | null;
      /** The id of the tenant the external task belongs to. */
      tenantId?: string | null;
      /** The number of retries the task currently has left. */
      retries?: number | null;
      /** A flag indicating whether the external task is suspended or not. */
      suspended?: boolean | null;
      /** The id of the worker that posesses or posessed the most recent lock. */
      workerId?: string | null;
      /** The topic name of the external task. */
      topicName?: string | null;
      /** The priority of the external task. */
      priority?: number | null;
      /** The business key of the process instance the external task belongs to. */
      businessKey?: string | null;
    };
    ExternalTaskFailureDto: {
      /** An message indicating the reason of the failure. */
      errorMessage?: string | null;
      /** A detailed error description. */
      errorDetails?: string | null;
      /**
       * A number of how often the task should be retried. Must be >= 0. If this is 0, an incident is created and
       * the task cannot be fetched anymore unless the retries are increased again. The incident's message is set
       * to the `errorMessage` parameter.
       */
      retries?: number | null;
      /** A timeout in milliseconds before the external task becomes available again for fetching. Must be >= 0. */
      retryTimeout?: number | null;
      /** A JSON object containing variable key-value pairs. Each key is a variable name and each value a JSON variable value object with the following properties: */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /** A JSON object containing local variable key-value pairs. Local variables are set only in the scope of external task. Each key is a variable name and each value a JSON variable value object with the following properties: */
      localVariables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    } & components["schemas"]["HandleExternalTaskDto"];
    /** A JSON object with the following properties: */
    ExternalTaskQueryDto: {
      /** Filter by an external task's id. */
      externalTaskId?: string | null;
      /** Filter by the comma-separated list of external task ids. */
      externalTaskIdIn?: string[] | null;
      /** Filter by an external task topic. */
      topicName?: string | null;
      /** Filter by the id of the worker that the task was most recently locked by. */
      workerId?: string | null;
      /**
       * Only include external tasks that are currently locked (i.e., they have a lock time and it has not expired).
       * Value may only be `true`, as `false` matches any external task.
       */
      locked?: boolean | null;
      /**
       * Only include external tasks that are currently not locked (i.e., they have no lock or it has expired).
       * Value may only be `true`, as `false` matches any external task.
       */
      notLocked?: boolean | null;
      /**
       * Only include external tasks that have a positive (> 0) number of retries (or `null`). Value may only be
       * `true`, as `false` matches any external task.
       */
      withRetriesLeft?: boolean | null;
      /**
       * Only include external tasks that have 0 retries. Value may only be `true`, as `false` matches any
       * external task.
       */
      noRetriesLeft?: boolean | null;
      /**
       * Restrict to external tasks that have a lock that expires after a given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      lockExpirationAfter?: string | null;
      /**
       * Restrict to external tasks that have a lock that expires before a given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      lockExpirationBefore?: string | null;
      /** Filter by the id of the activity that an external task is created for. */
      activityId?: string | null;
      /** Filter by the comma-separated list of ids of the activities that an external task is created for. */
      activityIdIn?: string[] | null;
      /** Filter by the id of the execution that an external task belongs to. */
      executionId?: string | null;
      /** Filter by the id of the process instance that an external task belongs to. */
      processInstanceId?: string | null;
      /** Filter by a comma-separated list of process instance ids that an external task may belong to. */
      processInstanceIdIn?: string[] | null;
      /** Filter by the id of the process definition that an external task belongs to. */
      processDefinitionId?: string | null;
      /**
       * Filter by a comma-separated list of tenant ids.
       * An external task must have one of the given tenant ids.
       */
      tenantIdIn?: string[] | null;
      /** Only include active tasks. Value may only be `true`, as `false` matches any external task. */
      active?: boolean | null;
      /** Only include suspended tasks. Value may only be `true`, as `false` matches any external task. */
      suspended?: boolean | null;
      /**
       * Only include jobs with a priority higher than or equal to the given value.
       * Value must be a valid `long` value.
       */
      priorityHigherThanOrEquals?: number | null;
      /**
       * Only include jobs with a priority lower than or equal to the given value.
       * Value must be a valid `long` value.
       */
      priorityLowerThanOrEquals?: number | null;
      /**
       * A JSON array of criteria to sort the result by. Each element of the array is a JSON object that
       *                     specifies one ordering. The position in the array identifies the rank of an ordering, i.e., whether
       *                     it is primary, secondary, etc. The ordering objects have the following properties:
       *
       *                     **Note:** The `sorting` properties will not be applied to the External Task count query.
       */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "id"
              | "lockExpirationTime"
              | "processInstanceId"
              | "processDefinitionId"
              | "processDefinitionKey"
              | "taskPriority"
              | "tenantId"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    FetchExternalTaskTopicDto: {
      /** **Mandatory.** The topic's name. */
      topicName: string;
      /** **Mandatory.** The duration to lock the external tasks for in milliseconds. */
      lockDuration: number | null;
      /**
       * A JSON array of `String` values that represent variable names. For each result task belonging to this
       * topic, the given variables are returned as well if they are accessible from the external task's
       * execution. If not provided - all variables will be fetched.
       */
      variables?: string[] | null;
      /** If `true` only local variables will be fetched. */
      localVariables?: boolean | null;
      /** A `String` value which enables the filtering of tasks based on process instance business key. */
      businessKey?: string | null;
      /** Filter tasks based on process definition id. */
      processDefinitionId?: string | null;
      /** Filter tasks based on process definition ids. */
      processDefinitionIdIn?: string[] | null;
      /** Filter tasks based on process definition key. */
      processDefinitionKey?: string | null;
      /** Filter tasks based on process definition keys. */
      processDefinitionKeyIn?: string[] | null;
      /** Filter tasks based on process definition version tag. */
      processDefinitionVersionTag?: string | null;
      /** Filter tasks without tenant id. */
      withoutTenantId?: boolean | null;
      /** Filter tasks based on tenant ids. */
      tenantIdIn?: string[] | null;
      /**
       * A `JSON` object used for filtering tasks based on process instance variable values. A property name of
       * the object represents a process variable name, while the property value represents the process variable
       * value to filter tasks by.
       */
      processVariables?: { [key: string]: any };
      /**
       * Determines whether serializable variable values (typically variables that store custom Java objects)
       * should be deserialized on server side (default `false`).
       *
       * If set to `true`, a serializable variable will be deserialized on server side and transformed to JSON
       * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature. Note
       * that this requires the Java classes of the variable value to be on the REST API's classpath.
       *
       * If set to `false`, a serializable variable will be returned in its serialized format. For example, a
       * variable that is serialized as XML will be returned as a JSON string containing XML.
       */
      deserializeValues?: boolean | null;
      /**
       * Determines whether custom extension properties defined in the BPMN activity of the external task (e.g.
       * via the Extensions tab in the Camunda modeler) should be included in the response. Default: false
       */
      includeExtensionProperties?: boolean | null;
    };
    FetchExternalTasksDto: {
      /**
       * **Mandatory.** The id of the worker on which behalf tasks are fetched. The returned tasks are locked for
       * that worker and can only be completed when providing the same worker id.
       */
      workerId: string;
      /** **Mandatory.** The maximum number of tasks to return. */
      maxTasks: number | null;
      /**
       * A `boolean` value, which indicates whether the task should be fetched based on its priority
       * or arbitrarily.
       */
      usePriority?: boolean | null;
      /**
       * The [Long Polling](https://docs.camunda.org/manual/latest/user-guide/process-engine/external-tasks/#long-polling-to-fetch-and-lock-external-tasks)
       * timeout in milliseconds.
       *
       * **Note:** The value cannot be set larger than 1.800.000 milliseconds (corresponds to 30 minutes).
       */
      asyncResponseTimeout?: number | null;
      /**
       * A JSON array of topic objects for which external tasks should be fetched. The returned tasks may be
       * arbitrarily distributed among these topics. Each topic object has the following properties:
       */
      topics?: components["schemas"]["FetchExternalTaskTopicDto"][] | null;
    };
    FormDto: {
      /** The form key. */
      key?: string | null;
      /**
       * The context path of the process application. If the task (or the process definition) does not
       * belong to a process application deployment or a process definition at all, this
       * property is not set.
       */
      contextPath?: string | null;
    };
    GroupDto: {
      /** The id of the group. */
      id?: string | null;
      /** The name of the group. */
      name?: string | null;
      /** The type of the group. */
      type?: string | null;
    };
    /** A group instance query which defines a list of group instances */
    GroupQueryDto: {
      /** Filter by the id of the group. */
      id?: string | null;
      /** Filter by a JSON string array of group ids. */
      idIn?: string[] | null;
      /** Filter by the name of the group. */
      name?: string | null;
      /** Filter by the name that the parameter is a substring of. */
      nameLike?: string | null;
      /** Filter by the type of the group. */
      type?: string | null;
      /** Only retrieve groups where the given user id is a member of. */
      member?: string | null;
      /** Only retrieve groups which are members of the given tenant. */
      memberOfTenant?: string | null;
      /** Apply sorting of the result */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: ("id" | "name" | "type") | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    HandleExternalTaskDto: {
      /**
       * **Mandatory.** The ID of the worker who is performing the operation on the external task.
       * If the task is already locked, must match the id of the worker who has most recently
       * locked the task.
       */
      workerId?: string;
    };
    HistoricActivityInstanceDto: {
      /** The id of the activity instance. */
      id?: string | null;
      /** The id of the parent activity instance, for example a sub process instance. */
      parentActivityInstanceId?: string | null;
      /** The id of the activity that this object is an instance of. */
      activityId?: string | null;
      /** The name of the activity that this object is an instance of. */
      activityName?: string | null;
      /** The type of the activity that this object is an instance of. */
      activityType?: string | null;
      /** The key of the process definition that this activity instance belongs to. */
      processDefinitionKey?: string | null;
      /** The id of the process definition that this activity instance belongs to. */
      processDefinitionId?: string | null;
      /** The id of the process instance that this activity instance belongs to. */
      processInstanceId?: string | null;
      /** The id of the execution that executed this activity instance. */
      executionId?: string | null;
      /** The id of the task that is associated to this activity instance. Is only set if the activity is a user task. */
      taskId?: string | null;
      /** The assignee of the task that is associated to this activity instance. Is only set if the activity is a user task. */
      assignee?: string | null;
      /** The id of the called process instance. Is only set if the activity is a call activity and the called instance a process instance. */
      calledProcessInstanceId?: string | null;
      /** The id of the called case instance. Is only set if the activity is a call activity and the called instance a case instance. */
      calledCaseInstanceId?: string | null;
      /**
       * The time the instance was started. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      startTime?: string | null;
      /**
       * The time the instance ended. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      endTime?: string | null;
      /** The time the instance took to finish (in milliseconds). */
      durationInMillis?: number | null;
      /** If `true`, this activity instance is canceled. */
      canceled?: boolean | null;
      /** If `true`, this activity instance did complete a BPMN 2.0 scope. */
      completeScope?: boolean | null;
      /** The tenant id of the activity instance. */
      tenantId?: string | null;
      /**
       * The time after which the activity instance should be removed by the History Cleanup job. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      removalTime?: string | null;
      /** The process instance id of the root process instance that initiated the process containing this activity instance. */
      rootProcessInstanceId?: string | null;
    };
    /** A historic activity instance query which defines a group of historic activity instances */
    HistoricActivityInstanceQueryDto: {
      /** Filter by activity instance id. */
      activityInstanceId?: string | null;
      /** Filter by process instance id. */
      processInstanceId?: string | null;
      /** Filter by process definition id. */
      processDefinitionId?: string | null;
      /** Filter by the id of the execution that executed the activity instance. */
      executionId?: string | null;
      /** Filter by the activity id (according to BPMN 2.0 XML). */
      activityId?: string | null;
      /** Filter by the activity name (according to BPMN 2.0 XML). */
      activityName?: string | null;
      /** Filter by activity type. */
      activityType?: string | null;
      /** Only include activity instances that are user tasks and assigned to a given user. */
      taskAssignee?: string | null;
      /**
       * Only include finished activity instances.
       * Value may only be `true`, as `false` behaves the same as when the property is not set.
       */
      finished?: boolean | null;
      /**
       * Only include unfinished activity instances.
       * Value may only be `true`, as `false` behaves the same as when the property is not set.
       */
      unfinished?: boolean | null;
      /**
       * Only include canceled activity instances.
       * Value may only be `true`, as `false` behaves the same as when the property is not set.
       */
      canceled?: boolean | null;
      /**
       * Only include activity instances which completed a scope.
       * Value may only be `true`, as `false` behaves the same as when the property is not set.
       */
      completeScope?: boolean | null;
      /**
       * Restrict to instances that were started before the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      startedBefore?: string | null;
      /**
       * Restrict to instances that were started after the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      startedAfter?: string | null;
      /**
       * Restrict to instances that were finished before the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      finishedBefore?: string | null;
      /**
       * Restrict to instances that were finished after the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      finishedAfter?: string | null;
      /** Must be a JSON array of Strings. An activity instance must have one of the given tenant ids. */
      tenantIdIn?: string[] | null;
      /** Only include historic activity instances that belong to no tenant. Value may only be `true`, as `false` is the default behavior. */
      withoutTenantId?: boolean | null;
      /** Apply sorting of the result */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "activityInstanceId"
              | "instanceId"
              | "executionId"
              | "activityId"
              | "activityName"
              | "activityType"
              | "startTime"
              | "endTime"
              | "duration"
              | "definitionId"
              | "occurrence"
              | "tenantId"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    HistoricProcessInstanceDto: {
      /** The id of the process instance. */
      id?: string | null;
      /** The process instance id of the root process instance that initiated the process. */
      rootProcessInstanceId?: string | null;
      /** The id of the parent process instance, if it exists. */
      superProcessInstanceId?: string | null;
      /** The id of the parent case instance, if it exists. */
      superCaseInstanceId?: string | null;
      /** The id of the parent case instance, if it exists. */
      caseInstanceId?: string | null;
      /** The name of the process definition that this process instance belongs to. */
      processDefinitionName?: string | null;
      /** The key of the process definition that this process instance belongs to. */
      processDefinitionKey?: string | null;
      /** The version of the process definition that this process instance belongs to. */
      processDefinitionVersion?: number | null;
      /** The id of the process definition that this process instance belongs to. */
      processDefinitionId?: string | null;
      /** The business key of the process instance. */
      businessKey?: string | null;
      /** The time the instance was started. Default [format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/) `yyyy-MM-dd'T'HH:mm:ss.SSSZ`. */
      startTime?: string | null;
      /** The time the instance ended. Default [format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/) `yyyy-MM-dd'T'HH:mm:ss.SSSZ`. */
      endTime?: string | null;
      /** The time after which the instance should be removed by the History Cleanup job. Default [format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/) `yyyy-MM-dd'T'HH:mm:ss.SSSZ`. */
      removalTime?: string | null;
      /** The time the instance took to finish (in milliseconds). */
      durationInMillis?: number | null;
      /** The id of the user who started the process instance. */
      startUserId?: string | null;
      /** The id of the initial activity that was executed (e.g., a start event). */
      startActivityId?: string | null;
      /** The provided delete reason in case the process instance was canceled during execution. */
      deleteReason?: string | null;
      /** The tenant id of the process instance. */
      tenantId?: string | null;
      /**
       * Last state of the process instance, possible values are:
       *
       * `ACTIVE` - running process instance
       *
       * `SUSPENDED` - suspended process instances
       *
       * `COMPLETED` - completed through normal end event
       *
       * `EXTERNALLY_TERMINATED` - terminated externally, for instance through REST API
       *
       * `INTERNALLY_TERMINATED` - terminated internally, for instance by terminating boundary event
       */
      state?:
        | (
            | "ACTIVE"
            | "SUSPENDED"
            | "COMPLETED"
            | "EXTERNALLY_TERMINATED"
            | "INTERNALLY_TERMINATED"
          )
        | null;
    };
    /** A historic process instance query which defines a group of historic process instances */
    HistoricProcessInstanceQueryDto: {
      /** Filter by process instance id. */
      processInstanceId?: string | null;
      /** Filter by process instance ids. Must be a JSON array of `Strings`. */
      processInstanceIds?: string[] | null;
      /** Filter by the process definition the instances run on. */
      processDefinitionId?: string | null;
      /** Filter by the key of the process definition the instances run on. */
      processDefinitionKey?: string | null;
      /** Filter by a list of process definition keys. A process instance must have one of the given process definition keys. Must be a JSON array of `Strings`. */
      processDefinitionKeyIn?: string[] | null;
      /** Filter by the name of the process definition the instances run on. */
      processDefinitionName?: string | null;
      /** Filter by process definition names that the parameter is a substring of. */
      processDefinitionNameLike?: string | null;
      /** Exclude instances that belong to a set of process definitions. Must be a JSON array of `Strings`. */
      processDefinitionKeyNotIn?: string[] | null;
      /** Filter by process instance business key. */
      processInstanceBusinessKey?: string | null;
      /** Filter by process instance business key that the parameter is a substring of. */
      processInstanceBusinessKeyLike?: string | null;
      /** Restrict the query to all process instances that are top level process instances. */
      rootProcessInstances?: boolean | null;
      /**
       * Only include finished process instances. This flag includes all process instances
       * that are completed or terminated. Value may only be `true`, as `false` is the default behavior.
       */
      finished?: boolean | null;
      /** Only include unfinished process instances. Value may only be `true`, as `false` is the default behavior. */
      unfinished?: boolean | null;
      /** Only include process instances which have an incident. Value may only be `true`, as `false` is the default behavior. */
      withIncidents?: boolean | null;
      /** Only include process instances which have a root incident. Value may only be `true`, as `false` is the default behavior. */
      withRootIncidents?: boolean | null;
      /** Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident types. */
      incidentType?: string | null;
      /** Only include process instances which have an incident in status either open or resolved. To get all process instances, use the query parameter withIncidents. */
      incidentStatus?: ("open" | "resolved") | null;
      /** Filter by the incident message. Exact match. */
      incidentMessage?: string | null;
      /** Filter by the incident message that the parameter is a substring of. */
      incidentMessageLike?: string | null;
      /**
       * Restrict to instances that were started before the given date.
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      startedBefore?: string | null;
      /**
       * Restrict to instances that were started after the given date.
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      startedAfter?: string | null;
      /**
       * Restrict to instances that were finished before the given date.
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      finishedBefore?: string | null;
      /**
       * Restrict to instances that were finished after the given date.
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      finishedAfter?: string | null;
      /**
       * Restrict to instances that executed an activity after the given date (inclusive).
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      executedActivityAfter?: string | null;
      /**
       * Restrict to instances that executed an activity before the given date (inclusive).
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      executedActivityBefore?: string | null;
      /**
       * Restrict to instances that executed an job after the given date (inclusive).
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      executedJobAfter?: string | null;
      /**
       * Restrict to instances that executed an job before the given date (inclusive).
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      executedJobBefore?: string | null;
      /** Only include process instances that were started by the given user. */
      startedBy?: string | null;
      /** Restrict query to all process instances that are sub process instances of the given process instance. Takes a process instance id. */
      superProcessInstanceId?: string | null;
      /** Restrict query to one process instance that has a sub process instance with the given id. */
      subProcessInstanceId?: string | null;
      /** Restrict query to all process instances that are sub process instances of the given case instance. Takes a case instance id. */
      superCaseInstanceId?: string | null;
      /** Restrict query to one process instance that has a sub case instance with the given id. */
      subCaseInstanceId?: string | null;
      /** Restrict query to all process instances that are sub process instances of the given case instance. Takes a case instance id. */
      caseInstanceId?: string | null;
      /** Filter by a list of tenant ids. A process instance must have one of the given tenant ids. Must be a JSON array of `Strings` */
      tenantIdIn?: string[] | null;
      /** Only include historic process instances which belong to no tenant. Value may only be `true`, as `false` is the default behavior. */
      withoutTenantId?: boolean | null;
      /** Restrict to instances that executed an activity with one of given ids. Must be a JSON array of `Strings` */
      executedActivityIdIn?: string[] | null;
      /** Restrict to instances that have an active activity with one of given ids. Must be a JSON array of `Strings` */
      activeActivityIdIn?: string[] | null;
      /** Restrict to instances that are active. */
      active?: boolean | null;
      /** Restrict to instances that are suspended. */
      suspended?: boolean | null;
      /** Restrict to instances that are completed. */
      completed?: boolean | null;
      /** Restrict to instances that are externallyTerminated. */
      externallyTerminated?: boolean | null;
      /** Restrict to instances that are internallyTerminated. */
      internallyTerminated?: boolean | null;
      /**
       * A JSON array to only include process instances that have/had variables with certain values.
       * The array consists of objects with the three properties `name`, `operator` and `value`. `name` (`String`) is the variable name,
       * `operator` (`String`) is the comparison operator to be used and `value` the variable value.
       *
       * Value may be `String`, `Number` or `Boolean`.
       *
       * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` - greater than; `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or equal to; `like`.
       */
      variables?: components["schemas"]["VariableQueryParameterDto"][] | null;
      /** Match all variable names provided in variables case-insensitively. If set to `true` variableName and variablename are treated as equal. */
      variableNamesIgnoreCase?: boolean | null;
      /** Match all variable values provided in variables case-insensitively. If set to `true` variableValue and variablevalue are treated as equal. */
      variableValuesIgnoreCase?: boolean | null;
      /**
       * A JSON array of nested historic process instance queries with OR semantics.
       *
       * A process instance matches a nested query if it fulfills at least one of the query's predicates.
       *
       * With multiple nested queries, a process instance must fulfill at least one predicate of each query
       * ([Conjunctive Normal Form](https://en.wikipedia.org/wiki/Conjunctive_normal_form)).
       *
       * All process instance query properties can be used except for: `sorting`
       *
       * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-engine-api/#or-queries) for more information about OR queries.
       */
      orQueries?:
        | components["schemas"]["HistoricProcessInstanceQueryDto"][]
        | null;
      /** Apply sorting of the result */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "instanceId"
              | "definitionId"
              | "definitionKey"
              | "definitionName"
              | "definitionVersion"
              | "businessKey"
              | "startTime"
              | "endTime"
              | "duration"
              | "tenantId"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    HistoryTimeToLiveDto: {
      /**
       * New value for historyTimeToLive field of the definition.
       * Can be `null`. Can not be negative.
       */
      historyTimeToLive?: number | null;
    };
    IdentityLinkDto: {
      /** The id of the user participating in this link. Either `userId` or `groupId` is set. */
      userId?: string | null;
      /** The id of the group participating in this link. Either `groupId` or `userId` is set. */
      groupId?: string | null;
      /**
       * The type of the identity link. The value of the this property can be user-defined. The Process Engine
       * provides three pre-defined Identity Link `type`s:
       *
       * * `candidate`
       * * `assignee` - reserved for the task assignee
       * * `owner` - reserved for the task owner
       *
       * **Note**: When adding or removing an Identity Link, the `type` property must be defined.
       */
      type: string | null;
    };
    IdentityServiceGroupDto: {
      /** The id of the group. */
      id?: string | null;
      /** The name of the group. */
      name?: string | null;
    };
    IdentityServiceGroupInfoDto: {
      /** An array of group objects. */
      groups?: components["schemas"]["IdentityServiceGroupDto"][] | null;
      /** An array that contains all users that are member in one of the groups. */
      groupUsers?: components["schemas"]["IdentityServiceUserDto"][] | null;
    };
    IdentityServiceUserDto: {
      /** The id of the user. */
      id?: string | null;
      /** The firstname of the user. */
      firstName?: string | null;
      /** The lastname of the user. */
      lastName?: string | null;
      /** The displayName is generated from the id or firstName and lastName if available. */
      displayName?: string | null;
    };
    IncidentDto: {
      /** The id of the incident. */
      id?: string | null;
      /** The id of the process definition this incident is associated with. */
      processDefinitionId?: string | null;
      /** The id of the process instance this incident is associated with. */
      processInstanceId?: string | null;
      /** The id of the execution this incident is associated with. */
      executionId?: string | null;
      /**
       * The time this incident happened. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      incidentTimestamp?: string | null;
      /**
       * The type of incident, for example: `failedJobs` will be returned in case of an incident which identified
       * a failed job during the execution of a process instance. See the
       * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident types.
       */
      incidentType?: string | null;
      /** The id of the activity this incident is associated with. */
      activityId?: string | null;
      /** The id of the activity on which the last exception occurred. */
      failedActivityId?: string | null;
      /** The id of the associated cause incident which has been triggered. */
      causeIncidentId?: string | null;
      /** The id of the associated root cause incident which has been triggered. */
      rootCauseIncidentId?: string | null;
      /** The payload of this incident. */
      configuration?: string | null;
      /** The id of the tenant this incident is associated with. */
      tenantId?: string | null;
      /** The message of this incident. */
      incidentMessage?: string | null;
      /** The job definition id the incident is associated with. */
      jobDefinitionId?: string | null;
      /** The annotation set to the incident. */
      annotation?: string | null;
    };
    IncidentStatisticsResultDto: {
      /**
       * The type of the incident the number of incidents is aggregated for.
       * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident types.
       */
      incidentType?: string | null;
      /** The total number of incidents for the corresponding incident type. */
      incidentCount?: number | null;
    };
    JobConditionQueryParameterDto: {
      /** Comparison operator to be used. */
      operator?: ("gt" | "lt") | null;
      /** Date value to compare with. */
      value?: string | null;
    };
    JobDto: {
      /** The id of the job. */
      id?: string | null;
      /** The id of the associated job definition. */
      jobDefinitionId?: string | null;
      /** The date on which this job is supposed to be processed. */
      dueDate?: string | null;
      /** The id of the process instance which execution created the job. */
      processInstanceId?: string | null;
      /** The specific execution id on which the job was created. */
      executionId?: string | null;
      /** The id of the process definition which this job belongs to. */
      processDefinitionId?: string | null;
      /** The key of the process definition which this job belongs to. */
      processDefinitionKey?: string | null;
      /** The number of retries this job has left. */
      retries?: number | null;
      /**
       * The message of the exception that occurred, the last time the job was executed. Is
       * null when no exception occurred.
       */
      exceptionMessage?: string | null;
      /**
       * The id of the activity on which the last exception occurred, the last time the job
       * was executed. Is null when no exception occurred.
       */
      failedActivityId?: string | null;
      /** A flag indicating whether the job is suspended or not. */
      suspended?: boolean | null;
      /** The job's priority for execution. */
      priority?: number | null;
      /** The id of the tenant which this job belongs to. */
      tenantId?: string | null;
      /** The date on which this job has been created. */
      createTime?: string | null;
    };
    JobDuedateDto: {
      /** The date to set when the job has the next execution. */
      duedate?: string | null;
      /**
       * A boolean value to indicate if modifications to the due date should cascade to
       * subsequent jobs. (e.g. Modify the due date of a timer by +15
       * minutes. This flag indicates if a +15 minutes should be applied to all
       * subsequent timers.) This flag only affects timer jobs and only works if due date
       * is not null. Default: `false`
       */
      cascade?: boolean | null;
    };
    /** A Job instance query which defines a list of Job instances */
    JobQueryDto: {
      /** Filter by job id. */
      jobId?: string | null;
      /** Filter by a  list of job ids. */
      jobIds?: string[] | null;
      /** Only select jobs which exist for the given job definition. */
      jobDefinitionId?: string | null;
      /** Only select jobs which exist for the given process instance. */
      processInstanceId?: string | null;
      /** Only select jobs which exist for the given  list of process instance ids. */
      processInstanceIds?: string[] | null;
      /** Only select jobs which exist for the given execution. */
      executionId?: string | null;
      /** Filter by the id of the process definition the jobs run on. */
      processDefinitionId?: string | null;
      /** Filter by the key of the process definition the jobs run on. */
      processDefinitionKey?: string | null;
      /** Only select jobs which exist for an activity with the given id. */
      activityId?: string | null;
      /**
       * Only select jobs which have retries left. Value may only be `true`, as `false` is the
       * default behavior.
       */
      withRetriesLeft?: boolean | null;
      /**
       * Only select jobs which are executable, i.e., retries > 0 and due date is `null` or due
       * date is in the past. Value may only be `true`, as `false` is the default
       * behavior.
       */
      executable?: boolean | null;
      /**
       * Only select jobs that are timers. Cannot be used together with `messages`. Value may only
       * be `true`, as `false` is the default behavior.
       */
      timers?: boolean | null;
      /**
       * Only select jobs that are messages. Cannot be used together with `timers`. Value may only
       * be `true`, as `false` is the default behavior.
       */
      messages?: boolean | null;
      /** Only select jobs where the due date is lower or higher than the given date. */
      dueDates?:
        | components["schemas"]["JobConditionQueryParameterDto"][]
        | null;
      /** Only select jobs created before or after the given date. */
      createTimes?:
        | components["schemas"]["JobConditionQueryParameterDto"][]
        | null;
      /**
       * Only select jobs that failed due to an exception. Value may only be `true`, as `false` is
       * the default behavior.
       */
      withException?: boolean | null;
      /** Only select jobs that failed due to an exception with the given message. */
      exceptionMessage?: string | null;
      /** Only select jobs that failed due to an exception at an activity with the given id. */
      failedActivityId?: string | null;
      /**
       * Only select jobs which have no retries left. Value may only be `true`, as `false` is the
       * default behavior.
       */
      noRetriesLeft?: boolean | null;
      /** Only include active jobs. Value may only be `true`, as `false` is the default behavior. */
      active?: boolean | null;
      /** Only include suspended jobs. Value may only be `true`, as `false` is the default behavior. */
      suspended?: boolean | null;
      /**
       * Only include jobs with a priority lower than or equal to the given value. Value must be a
       * valid `long` value.
       */
      priorityLowerThanOrEquals?: number | null;
      /**
       * Only include jobs with a priority higher than or equal to the given value. Value must be a
       * valid `long` value.
       */
      priorityHigherThanOrEquals?: number | null;
      /** Only include jobs which belong to one of the passed  tenant ids. */
      tenantIdIn?: string[] | null;
      /**
       * Only include jobs which belong to no tenant. Value may only be `true`, as `false` is the
       * default behavior.
       */
      withoutTenantId?: boolean | null;
      /**
       * Include jobs which belong to no tenant. Can be used in combination with `tenantIdIn`.
       * Value may only be `true`, as `false` is the default behavior.
       */
      includeJobsWithoutTenantId?: boolean | null;
      /**
       * An array of criteria to sort the result by. Each element of the array is
       *                        an object that specifies one ordering. The position in the array
       *                        identifies the rank of an ordering, i.e., whether it is primary, secondary,
       *                        etc. Does not have an effect for the `count` endpoint.
       */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "jobId"
              | "executionId"
              | "processInstanceId"
              | "processDefinitionId"
              | "processDefinitionKey"
              | "jobPriority"
              | "jobRetries"
              | "jobDueDate"
              | "tenantId"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    JobSuspensionStateDto: {
      /** The job definition id of the jobs to activate or suspend. */
      "jobDefinitionId	"?: string | null;
      /** The process definition id of the jobs to activate or suspend. */
      processDefinitionId?: string | null;
      /** The process instance id of the jobs to activate or suspend. */
      processInstanceId?: string | null;
      /** The process definition key of the jobs to activate or suspend. */
      processDefinitionKey?: string | null;
      /**
       * Only activate or suspend jobs of a process definition which belongs to a tenant
       * with the given id. Works only when selecting with `processDefinitionKey`.
       */
      processDefinitionTenantId?: string | null;
      /**
       * Only activate or suspend jobs of a process definition which belongs to no tenant.
       * Value may only be `true`, as `false` is the default behavior. Works only when selecting with `processDefinitionKey`.
       */
      processDefinitionWithoutTenantId?: boolean | null;
    } & components["schemas"]["SuspensionStateDto"];
    LinkableDto: {
      /** The links associated to this resource, with `method`, `href` and `rel`. */
      links?: components["schemas"]["AtomLink"][] | null;
    };
    LockExternalTaskDto: {
      /**
       * The duration to lock the external task for in milliseconds.
       * **Note:** Attempting to lock an already locked external task with the same `workerId`
       * will succeed and a new lock duration will be set, starting from the current moment.
       */
      lockDuration?: number;
    } & components["schemas"]["HandleExternalTaskDto"];
    LockedExternalTaskDto: {
      /** The id of the activity that this external task belongs to. */
      activityId?: string | null;
      /** The id of the activity instance that the external task belongs to. */
      activityInstanceId?: string | null;
      /**
       * The full error message submitted with the latest reported failure executing this task;`null` if no failure
       * was reported previously or if no error message was submitted
       */
      errorMessage?: string | null;
      /**
       * The error details submitted with the latest reported failure executing this task.`null` if no failure was
       * reported previously or if no error details was submitted
       */
      errorDetails?: string | null;
      /** The id of the execution that the external task belongs to. */
      executionId?: string | null;
      /** The id of the external task. */
      id?: string | null;
      /** The date that the task's most recent lock expires or has expired. */
      lockExpirationTime?: string | null;
      /** The id of the process definition the external task is defined in. */
      processDefinitionId?: string | null;
      /** The key of the process definition the external task is defined in. */
      processDefinitionKey?: string | null;
      /** The version tag of the process definition the external task is defined in. */
      processDefinitionVersionTag?: string | null;
      /** The id of the process instance the external task belongs to. */
      processInstanceId?: string | null;
      /** The id of the tenant the external task belongs to. */
      tenantId?: string | null;
      /** The number of retries the task currently has left. */
      retries?: number | null;
      /** Whether the process instance the external task belongs to is suspended. */
      suspended?: boolean | null;
      /** The id of the worker that posesses or posessed the most recent lock. */
      workerId?: string | null;
      /** The priority of the external task. */
      priority?: number | null;
      /** The topic name of the external task. */
      topicName?: string | null;
      /** The business key of the process instance the external task belongs to. */
      businessKey?: string | null;
      /**
       * A JSON object containing a property for each of the requested variables. The key is the variable name,
       * the value is a JSON object of serialized variable values with the following properties:
       */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    /**
     * The `processInstance` property only has a value if the resultType is set to `ProcessDefinition`.
     * The processInstance with the properties as described in the
     * [get single instance](https://docs.camunda.org/manual/latest/reference/rest/process-instance/get/) method.
     *
     * The `execution` property only has a value if the resultType is set to `Execution`.
     * The execution with the properties as described in the
     * [get single execution](https://docs.camunda.org/manual/latest/reference/rest/execution/get/) method.
     */
    MessageCorrelationResultWithVariableDto: {
      /**
       * Indicates if the message was correlated to a message start event or an
       * intermediate message catching event. In the first case, the resultType is
       * `ProcessDefinition` and otherwise `Execution`.
       */
      resultType?: ("Execution" | "ProcessDefinition") | null;
      processInstance?: components["schemas"]["ProcessInstanceDto"];
      execution?: components["schemas"]["ExecutionDto"];
      /**
       * This property is returned if the `variablesInResultEnabled` is set to `true`.
       * Contains a list of the process variables.
       */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    MetricsIntervalResultDto: {
      /** The interval timestamp. */
      timestamp?: string | null;
      /** The name of the metric. */
      name?: string | null;
      /** The reporter of the metric. `null` if the metrics are aggregated by reporter. */
      reporter?: string | null;
      /** The value of the metric aggregated by the interval. */
      value?: number | null;
    };
    MetricsResultDto: {
      /** The current sum (count) for the selected metric. */
      result?: number | null;
    };
    MissingAuthorizationDto: {
      /** The permission name that the user is missing. */
      permissionName?: string | null;
      /** The name of the resource that the user is missing permission for. */
      resourceName?: string | null;
      /** The id of the resource that the user is missing permission for. */
      resourceId?: string | null;
    };
    MultiFormAttachmentDto: {
      /** The name of the attachment. */
      "attachment-name"?: string | null;
      /** The description of the attachment. */
      "attachment-description"?: string | null;
      /** The type of the attachment. */
      "attachment-type"?: string | null;
      /** The url to the remote content of the attachment. */
      url?: string | null;
      /** The content of the attachment. */
      content?: string | null;
    };
    MultiFormDeploymentDto: {
      /** The tenant id for the deployment to be created. */
      "tenant-id"?: string | null;
      /** The source for the deployment to be created. */
      "deployment-source"?: string | null;
      /**
       * A flag indicating whether the process engine should perform duplicate checking on a per-resource basis.
       * If set to true, only those resources that have actually changed are deployed.
       * Checks are made against resources included previous deployments of the same name and only against the latest versions of those resources.
       * If set to true, the option enable-duplicate-filtering is overridden and set to true.
       */
      "deploy-changed-only"?: boolean | null;
      /**
       * A flag indicating whether the process engine should perform duplicate checking for the deployment or not.
       * This allows you to check if a deployment with the same name and the same resouces already exists and
       * if true, not create a new deployment but instead return the existing deployment. The default value is false.
       */
      "enable-duplicate-filtering"?: boolean | null;
      /** The name for the deployment to be created. */
      "deployment-name"?: string | null;
      /**
       * The binary data to create the deployment resource.
       * It is possible to have more than one form part with different form part names for the binary data to create a deployment.
       */
      data?: string | null;
    };
    MultiFormVariableBinaryDto: {
      /**
       * The binary data to be set.
       * For File variables, this multipart can contain the filename, binary value and MIME type of the file variable to be set
       * Only the filename is mandatory.
       */
      data?: string | null;
      /** The name of the variable type. Either Bytes for a byte array variable or File for a file variable. */
      valueType?: ("Bytes" | "File") | null;
    };
    ParseExceptionDto: {
      /** A JSON Object containing list of errors and warnings occurred during deployment. */
      details?: {
        [key: string]: components["schemas"]["ResourceReportDto"];
      } | null;
    } & components["schemas"]["ExceptionDto"];
    PasswordPolicyDto: {
      /** An array of password policy rules. Each element of the array is representing one rule of the policy. */
      rules?: components["schemas"]["PasswordPolicyRuleDto"][] | null;
    };
    PasswordPolicyRequestDto: {
      /** The candidate password to be check against the password policy. */
      password?: string | null;
      profile?: components["schemas"]["UserProfileDto"];
    };
    /** Describes a rule of a password policy. */
    PasswordPolicyRuleDto: {
      /** A placeholder string that contains the name of a password policy rule. */
      placeholder?: string | null;
      /** A map that describes the characteristics of a password policy rule, such as the minimum number of digits. */
      parameter?: { [key: string]: string };
    };
    PatchVariablesDto: {
      /** A JSON object containing variable key-value pairs. */
      modifications?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /** An array of String keys of variables to be deleted. */
      deletions?: string[] | null;
    };
    PriorityDto: {
      /** The priority of the resource. */
      priority?: number | null;
    };
    ProblemDto: {
      /** The message of the problem. */
      message?: string | null;
      /** The line where the problem occurred. */
      line?: number | null;
      /** The column where the problem occurred. */
      column?: number | null;
      /** The main element id where the problem occurred. */
      mainElementId?: string | null;
      /** A list of element id affected by the problem. */
      elementIds?: string[] | null;
    };
    ProcessDefinitionDiagramDto: {
      /** The id of the process definition. */
      id?: string | null;
      /**
       * An escaped XML string containing the XML that this definition was deployed with.
       * Carriage returns, line feeds and quotation marks are escaped.
       */
      bpmn20Xml?: string | null;
    };
    ProcessDefinitionDto: {
      /** The id of the process definition */
      id?: string | null;
      /** The key of the process definition, i.e., the id of the BPMN 2.0 XML process definition. */
      key?: string | null;
      /** The category of the process definition. */
      category?: string | null;
      /** The description of the process definition. */
      description?: string | null;
      /** The name of the process definition. */
      name?: string | null;
      /** The version of the process definition that the engine assigned to it. */
      version?: number | null;
      /** The file name of the process definition. */
      resource?: string | null;
      /** The deployment id of the process definition. */
      deploymentId?: string | null;
      /** The file name of the process definition diagram, if it exists. */
      diagram?: string | null;
      /** A flag indicating whether the definition is suspended or not. */
      suspended?: boolean | null;
      /** The tenant id of the process definition. */
      tenantId?: string | null;
      /** The version tag of the process definition. */
      versionTag?: string | null;
      /**
       * History time to live value of the process definition.
       * Is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
       */
      historyTimeToLive?: number | null;
      /** A flag indicating whether the process definition is startable in Tasklist or not. */
      startableInTasklist?: boolean | null;
    };
    ProcessDefinitionStatisticsResultDto: {
      /** The id of the process definition the results are aggregated for. */
      id?: string | null;
      /** The total number of running process instances of this process definition. */
      instances?: number;
      /**
       * The total number of failed jobs for the running instances.
       * **Note**: Will be `0` (not `null`), if failed jobs were excluded.
       */
      failedJobs?: number;
      /**
       * Each item in the resulting array is an object which contains `incidentType` and `incidentCount`.
       * **Note**: Will be an empty array, if `incidents` or `incidentsForType` were excluded.
       * Furthermore, the array will be also empty if no incidents were found.
       */
      incidents?: components["schemas"]["IncidentStatisticsResultDto"][] | null;
      definition?: components["schemas"]["ProcessDefinitionDto"];
    };
    ProcessDefinitionSuspensionStateDto: {
      /**
       * A `Boolean` value which indicates whether to activate or suspend all process definitions with the given key.
       * When the value is set to `true`, all process definitions with the given key will be suspended and
       * when the value is set to `false`, all process definitions with the given key will be activated.
       */
      suspended?: boolean | null;
      /** The id of the process definitions to activate or suspend. */
      processDefinitionId?: string | null;
      /** The key of the process definitions to activate or suspend. */
      processDefinitionKey?: string | null;
      /**
       * A `Boolean` value which indicates whether to activate or suspend also all process instances of
       * the process definitions with the given key.
       * When the value is set to `true`, all process instances of the process definitions with the given key
       * will be activated or suspended and when the value is set to `false`, the suspension state of
       * all process instances of the process definitions with the given key will not be updated.
       */
      includeProcessInstances?: boolean | null;
      /**
       * The date on which all process definitions with the given key will be activated or suspended.
       * If `null`, the suspension state of all process definitions with the given key is updated immediately.
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
       * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
       */
      executionDate?: string | null;
    };
    ProcessEngineDto: {
      /** The name of the process engine. */
      name?: string | null;
    };
    ProcessInstanceDto: {
      /** The id of the process instance. */
      id?: string | null;
      /** The id of the process definition that this process instance belongs to. */
      definitionId?: string | null;
      /** The business key of the process instance. */
      businessKey?: string | null;
      /** The id of the case instance associated with the process instance. */
      caseInstanceId?: string | null;
      /** A flag indicating whether the process instance has ended or not. Deprecated: will always be false! */
      ended?: boolean | null;
      /** A flag indicating whether the process instance is suspended or not. */
      suspended?: boolean | null;
      /** The tenant id of the process instance. */
      tenantId?: string | null;
    } & components["schemas"]["LinkableDto"];
    ProcessInstanceModificationDto: {
      /** Skip execution listener invocation for activities that are started or ended as part of this request. */
      skipCustomListeners?: boolean | null;
      /**
       * Skip execution of [input/output variable mappings](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/#input-output-variable-mapping)
       * for activities that are started or ended as part of this request.
       */
      skipIoMappings?: boolean | null;
      /** JSON array of modification instructions. The instructions are executed in the order they are in. */
      instructions?:
        | components["schemas"]["ProcessInstanceModificationInstructionDto"][]
        | null;
      /** An arbitrary text annotation set by a user for auditing reasons. */
      annotation?: string | null;
    };
    ProcessInstanceModificationInstructionDto: {
      /**
       * **Mandatory**. One of the following values: `cancel`, `startBeforeActivity`, `startAfterActivity`, `startTransition`.
       *
       * * A cancel instruction requests cancellation of a single activity instance or all instances of one activity.
       * * A startBeforeActivity instruction requests to enter a given activity.
       * * A startAfterActivity instruction requests to execute the single outgoing sequence flow of a given activity.
       * * A startTransition instruction requests to execute a specific sequence flow.
       */
      type:
        | "cancel"
        | "startBeforeActivity"
        | "startAfterActivity"
        | "startTransition";
      variables?: components["schemas"]["TriggerVariableValueDto"];
      /** Can be used with instructions of types `startTransition`. Specifies the sequence flow to start. */
      activityId?: string | null;
      /** Can be used with instructions of types `startTransition`. Specifies the sequence flow to start. */
      transitionId?: string | null;
      /**
       * Can be used with instructions of type `cancel`. Specifies the activity instance to cancel.
       * Valid values are the activity instance IDs supplied by the [Get Activity Instance request](https://docs.camunda.org/manual/latest/reference/rest/process-instance/get-activity-instances/).
       */
      activityInstanceId?: string | null;
      /**
       * Can be used with instructions of type `cancel`. Specifies the transition instance to cancel.
       * Valid values are the transition instance IDs supplied by the [Get Activity Instance request](https://docs.camunda.org/manual/latest/reference/rest/process-instance/get-activity-instances/).
       */
      transitionInstanceId?: string | null;
      /**
       * Can be used with instructions of type `startBeforeActivity`, `startAfterActivity`, and `startTransition`.
       * Valid values are the activity instance IDs supplied by the Get Activity Instance request.
       * If there are multiple parent activity instances of the targeted activity,
       * this specifies the ancestor scope in which hierarchy the activity/transition is to be instantiated.
       *
       * Example: When there are two instances of a subprocess and an activity contained in the subprocess is to be started,
       * this parameter allows to specifiy under which subprocess instance the activity should be started.
       */
      ancestorActivityInstanceId?: string | null;
      /** Can be used with instructions of type cancel. Prevents the deletion of new created activity instances. */
      cancelCurrentActiveActivityInstances?: boolean | null;
    };
    /** A process instance query which defines a group of process instances */
    ProcessInstanceQueryDto: {
      /** Filter by the deployment the id belongs to. */
      deploymentId?: string | null;
      /** Filter by the process definition the instances run on. */
      processDefinitionId?: string | null;
      /** Filter by the key of the process definition the instances run on. */
      processDefinitionKey?: string | null;
      /**
       * Filter by a list of process definition keys.
       * A process instance must have one of the given process definition keys. Must be a JSON array of Strings.
       */
      processDefinitionKeyIn?: string[] | null;
      /**
       * Exclude instances by a list of process definition keys.
       * A process instance must not have one of the given process definition keys. Must be a JSON array of Strings.
       */
      processDefinitionKeyNotIn?: string[] | null;
      /** Filter by process instance business key. */
      businessKey?: string | null;
      /** Filter by process instance business key that the parameter is a substring of. */
      businessKeyLike?: string | null;
      /** Filter by case instance id. */
      caseInstanceId?: string | null;
      /**
       * Restrict query to all process instances that are sub process instances of the given process instance.
       * Takes a process instance id.
       */
      superProcessInstance?: string | null;
      /**
       * Restrict query to all process instances that have the given process instance as a sub process instance.
       * Takes a process instance id.
       */
      subProcessInstance?: string | null;
      /**
       * Restrict query to all process instances that are sub process instances of the given case instance.
       * Takes a case instance id.
       */
      superCaseInstance?: string | null;
      /**
       * Restrict query to all process instances that have the given case instance as a sub case instance.
       * Takes a case instance id.
       */
      subCaseInstance?: string | null;
      /** Only include active process instances. Value may only be true, as false is the default behavior. */
      active?: boolean | null;
      /** Only include suspended process instances. Value may only be true, as false is the default behavior. */
      suspended?: boolean | null;
      /** Filter by a list of process instance ids. Must be a JSON array of Strings. */
      processInstanceIds?: string[] | null;
      /** Filter by presence of incidents. Selects only process instances that have an incident. */
      withIncident?: boolean | null;
      /** Filter by the incident id. */
      incidentId?: string | null;
      /** Filter by the incident type. See the User Guide for a list of incident types. */
      incidentType?: string | null;
      /** Filter by the incident message. Exact match. */
      incidentMessage?: string | null;
      /** Filter by the incident message that the parameter is a substring of. */
      incidentMessageLike?: string | null;
      /**
       * Filter by a list of tenant ids. A process instance must have one of the given tenant ids.
       * Must be a JSON array of Strings.
       */
      tenantIdIn?: string[] | null;
      /**
       * Only include process instances which belong to no tenant.
       * Value may only be true, as false is the default behavior.
       */
      withoutTenantId?: boolean | null;
      /** Only include process instances which process definition has no tenant id. */
      processDefinitionWithoutTenantId?: boolean | null;
      /**
       * Filter by a list of activity ids.
       * A process instance must currently wait in a leaf activity with one of the given activity ids.
       */
      activityIdIn?: string[] | null;
      /** Restrict the query to all process instances that are top level process instances. */
      rootProcessInstances?: boolean | null;
      /** Restrict the query to all process instances that are leaf instances. (i.e. don't have any sub instances) */
      leafProcessInstances?: boolean | null;
      /**
       * A JSON array to only include process instances that have variables with certain values.
       * The array consists of objects with the three properties `name`, `operator` and `value`.
       * `name` (String) is the variable name,
       * `operator` (String) is the comparison operator to be used and `value` the variable value.
       * The `value` may be String, Number or Boolean.
       *
       * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` - greater than;
       * `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or equal to; `like`.
       */
      variables?: components["schemas"]["VariableQueryParameterDto"][] | null;
      /**
       * Match all variable names in this query case-insensitively.
       * If set to true variableName and variablename are treated as equal.
       */
      variableNamesIgnoreCase?: boolean | null;
      /**
       * Match all variable values in this query case-insensitively.
       * If set to true variableValue and variablevalue are treated as equal.
       */
      variableValuesIgnoreCase?: boolean | null;
      /**
       * A JSON array of nested process instance queries with OR semantics.
       * A process instance matches a nested query if it fulfills at least one of the query's predicates.
       * With multiple nested queries, a process instance must fulfill at least one predicate of each query (Conjunctive Normal Form).
       * All process instance query properties can be used except for: `sorting`
       * See the [User guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-engine-api/#or-queries) for more information about OR queries.
       */
      orQueries?: components["schemas"]["ProcessInstanceQueryDto"][] | null;
      /** Apply sorting of the result */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "instanceId"
              | "definitionId"
              | "definitionKey"
              | "businessKey"
              | "tenantId"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    ProcessInstanceSuspensionStateAsyncDto: {
      /**
       * A list of process instance ids which defines a group of process instances
       * which will be activated or suspended by the operation.
       */
      processInstanceIds?: string[] | null;
      processInstanceQuery?: components["schemas"]["ProcessInstanceQueryDto"];
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
    } & components["schemas"]["SuspensionStateDto"];
    ProcessInstanceSuspensionStateDto: {
      /**
       * The process definition id of the process instances to activate or suspend.
       *
       * **Note**: This parameter can be used only with combination of `suspended`.
       */
      processDefinitionId?: string | null;
      /**
       * The process definition key of the process instances to activate or suspend.
       *
       * **Note**: This parameter can be used only with combination of `suspended`, `processDefinitionTenantId`, and `processDefinitionWithoutTenantId`.
       */
      processDefinitionKey?: string | null;
      /**
       * Only activate or suspend process instances of a process definition which belongs to a tenant with the given id.
       *
       * **Note**: This parameter can be used only with combination of `suspended`, `processDefinitionKey`, and `processDefinitionWithoutTenantId`.
       */
      processDefinitionTenantId?: string | null;
      /**
       * Only activate or suspend process instances of a process definition which belongs to no tenant.
       * Value may only be true, as false is the default behavior.
       *
       * **Note**: This parameter can be used only with combination of `suspended`, `processDefinitionKey`, and `processDefinitionTenantId`.
       */
      processDefinitionWithoutTenantId?: boolean | null;
      /**
       * A list of process instance ids which defines a group of process instances
       * which will be activated or suspended by the operation.
       *
       * **Note**: This parameter can be used only with combination of `suspended`, `processInstanceQuery`, and `historicProcessInstanceQuery`.
       */
      processInstanceIds?: string[] | null;
      processInstanceQuery?: components["schemas"]["ProcessInstanceQueryDto"];
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
    } & components["schemas"]["SuspensionStateDto"];
    ProcessInstanceWithVariablesDto: {
      /** The id of the process instance. */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    } & components["schemas"]["ProcessInstanceDto"];
    /** A JSON object with the following properties: */
    RedeploymentDto: {
      /** A list of deployment resource ids to re-deploy. */
      resourceIds?: string[] | null;
      /** A list of deployment resource names to re-deploy. */
      resourceNames?: string[] | null;
      /** Sets the source of the deployment. */
      source?: string | null;
    };
    ResourceOptionsDto: {
      [key: string]: any;
    } & components["schemas"]["LinkableDto"];
    ResourceReportDto: {
      /** A list of errors occurred during parsing. */
      errors?: components["schemas"]["ProblemDto"][] | null;
      /** A list of warnings occurred during parsing. */
      warnings?: components["schemas"]["ProblemDto"][] | null;
    };
    RestartProcessInstanceDto: {
      /** A list of process instance ids to restart. */
      processInstanceIds?: string[] | null;
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
      /** Skip execution listener invocation for activities that are started as part of this request. */
      skipCustomListeners?: boolean | null;
      /**
       * Skip execution of
       * [input/output variable mappings](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/#input-output-variable-mapping)
       * for activities that are started as part of this request.
       */
      skipIoMappings?: boolean | null;
      /** Set the initial set of variables during restart. By default, the last set of variables is used. */
      initialVariables?: boolean | null;
      /** Do not take over the business key of the historic process instance. */
      withoutBusinessKey?: boolean | null;
      /**
       * **Optional**. A JSON array of instructions that specify which activities to start the process instance at.
       * If this property is omitted, the process instance starts at its default blank start event.
       */
      instructions?:
        | components["schemas"]["RestartProcessInstanceModificationInstructionDto"][]
        | null;
    };
    RestartProcessInstanceModificationInstructionDto: {
      /**
       * **Mandatory**. One of the following values: `startBeforeActivity`, `startAfterActivity`, `startTransition`.
       *
       * * A `startBeforeActivity` instruction requests to enter a given activity.
       * * A `startAfterActivity` instruction requests to execute the single outgoing sequence flow of a given activity.
       * * A `startTransition` instruction requests to execute a specific sequence flow.
       */
      type: "startBeforeActivity" | "startAfterActivity" | "startTransition";
      /**
       * **Can be used with instructions of types** `startBeforeActivity`
       * and `startAfterActivity`. Specifies the sequence flow to start.
       */
      activityId?: string | null;
      /**
       * **Can be used with instructions of types** `startTransition`.
       * Specifies the sequence flow to start.
       */
      transitionId?: string | null;
    };
    RetriesDto: {
      /**
       * The number of retries to set for the resource.  Must be >= 0. If this is 0, an incident is created
       * and the task, or job, cannot be fetched, or acquired anymore unless the retries are increased again.
       * Can not be null.
       */
      retries?: number | null;
    };
    SchemaLogEntryDto: {
      /** The id of the schema log entry. */
      id?: string | null;
      /** The date and time of the schema update. */
      timestamp?: string | null;
      /** The version of the schema. */
      version?: string | null;
    };
    SchemaLogQueryDto: {
      /** The version of the schema. */
      version?: string | null;
      /**
       * A JSON array of criteria to sort the result by. Each element of the array is
       *                       a JSON object that specifies one ordering. The position in the array
       *                       identifies the rank of an ordering, i.e., whether it is primary, secondary,
       *                       etc.
       */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "timestamp" | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    SetJobRetriesByProcessDto: {
      /** A list of process instance ids to fetch jobs, for which retries will be set. */
      processInstances?: string[] | null;
      /** An integer representing the number of retries. Please note that the value cannot be negative or null. */
      retries?: number | null;
      processInstanceQuery?: components["schemas"]["ProcessInstanceQueryDto"];
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
    };
    /**
     * Defines the number of retries for a selection of jobs.
     * Please note that if both jobIds and jobQuery are provided,
     * then retries will be set on the union of these sets.
     */
    SetJobRetriesDto: {
      /** A list of job ids to set retries for. */
      jobIds?: string[] | null;
      jobQuery?: components["schemas"]["JobQueryDto"];
      /**
       * An integer representing the number of retries. Please note that the value cannot be
       * negative or null.
       */
      retries?: number | null;
    };
    SetRemovalTimeToHistoricProcessInstancesDto: {
      /** The id of the process instance. */
      historicProcessInstanceIds?: string[] | null;
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
      /**
       * Sets the removal time to all historic process instances in the hierarchy.
       * Value may only be `true`, as `false` is the default behavior.
       */
      hierarchical?: boolean | null;
    } & components["schemas"]["AbstractSetRemovalTimeDto"];
    SetRetriesForExternalTasksDto: {
      /**
       * The number of retries to set for the external task.  Must be >= 0. If this is 0, an incident is created
       * and the task cannot be fetched anymore unless the retries are increased again. Can not be null.
       */
      retries?: number | null;
      /** The ids of the external tasks to set the number of retries for. */
      externalTaskIds?: string[] | null;
      /** The ids of process instances containing the tasks to set the number of retries for. */
      processInstanceIds?: string[] | null;
      externalTaskQuery?: components["schemas"]["ExternalTaskQueryDto"];
      processInstanceQuery?: components["schemas"]["ProcessInstanceQueryDto"];
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
    };
    SetVariablesAsyncDto: {
      /**
       * A list of process instance ids that define a group of process instances
       * to which the operation will set variables.
       *
       * Please note that if `processInstanceIds`, `processInstanceQuery` and `historicProcessInstanceQuery`
       * are defined, the resulting operation will be performed on the union of these sets.
       */
      processInstanceIds?: string[] | null;
      processInstanceQuery?: components["schemas"]["ProcessInstanceQueryDto"];
      historicProcessInstanceQuery?: components["schemas"]["HistoricProcessInstanceQueryDto"];
      /** A variables the operation will set in the root scope of the process instances. */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    SignalDto: {
      /**
       * The name of the signal to deliver.
       *
       * **Note**: This property is mandatory.
       */
      name?: string;
      /**
       * Optionally specifies a single execution which is notified by the signal.
       *
       * **Note**: If no execution id is defined the signal is broadcasted to all subscribed
       * handlers.
       */
      executionId?: string | null;
      /**
       * A JSON object containing variable key-value pairs. Each key is a variable name and
       * each value a JSON variable value object.
       */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * Specifies a tenant to deliver the signal. The signal can only be received on
       * executions or process definitions which belongs to the given tenant.
       *
       * **Note**: Cannot be used in combination with executionId.
       */
      tenantId?: string | null;
      /**
       * If true the signal can only be received on executions or process definitions which
       * belongs to no tenant. Value may not be false as this is the default behavior.
       *
       * **Note**: Cannot be used in combination with `executionId`.
       */
      withoutTenantId?: boolean | null;
    };
    /**
     * Mandatory when `sortBy` is one of the following values: `processVariable`, `executionVariable`,
     * `taskVariable`, `caseExecutionVariable` or `caseInstanceVariable`. Must be a JSON object with the properties
     * `variable` and `type` where `variable` is a variable name and `type` is the name of a variable value type.
     */
    SortTaskQueryParametersDto: {
      /** The name of the variable to sort by. */
      variable?: string | null;
      /** The name of the type of the variable value. */
      type?: string | null;
    };
    StartProcessInstanceDto: {
      /** The business key of the process instance. */
      businessKey?: string | null;
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /** The case instance id the process instance is to be initialized with. */
      caseInstanceId?: string | null;
      /**
       * **Optional**. A JSON array of instructions that specify which activities to start the process instance at.
       * If this property is omitted, the process instance starts at its default blank start event.
       */
      startInstructions?:
        | components["schemas"]["ProcessInstanceModificationInstructionDto"][]
        | null;
      /**
       * Skip execution listener invocation for activities that are started or ended as part of this request.
       * **Note**: This option is currently only respected when start instructions are submitted
       * via the `startInstructions` property.
       */
      skipCustomListeners?: boolean | null;
      /**
       * Skip execution of
       * [input/output variable mappings](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/#input-output-variable-mapping)
       * for activities that are started or ended as part of this request.
       * **Note**: This option is currently only respected when start instructions are submitted
       * via the `startInstructions` property.
       */
      skipIoMappings?: boolean | null;
      /**
       * Indicates if the variables, which was used by the process instance during execution, should be returned.
       * Default value: `false`
       */
      withVariablesInReturn?: boolean | null;
    };
    StartProcessInstanceFormDto: {
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
      /**
       * The business key the process instance is to be initialized with.
       * The business key uniquely identifies the process instance in the context of the given process definition.
       */
      businessKey?: string | null;
    };
    SuspensionStateDto: {
      /**
       * A Boolean value which indicates whether to activate or suspend a given instance (e.g. process instance, job, or batch).
       * When the value is set to true, the given instance will be suspended and when the value is set to false,
       * the given instance will be activated.
       */
      suspended?: boolean | null;
    };
    TaskBpmnErrorDto: {
      /**
       * An error code that indicates the predefined error. It is used to identify the BPMN
       * error handler.
       */
      errorCode?: string | null;
      /** An error message that describes the error. */
      errorMessage?: string | null;
      /** A JSON object containing variable key-value pairs. */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    TaskDto: {
      /** The task id. */
      id?: string | null;
      /** The task name. */
      name?: string | null;
      /** The assignee's id. */
      assignee?: string | null;
      /** The owner's id. */
      owner?: string | null;
      /**
       * The date the task was created on.
       * [Default format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      created?: string | null;
      /**
       * The task's due date.
       * [Default format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      due?: string | null;
      /**
       * The follow-up date for the task.
       * [Default format](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/)
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
       */
      followUp?: string | null;
      /** The task's delegation state. Possible values are `PENDING` and `RESOLVED`. */
      delegationState?: ("PENDING" | "RESOLVED") | null;
      /** The task's description. */
      description?: string | null;
      /** The id of the execution the task belongs to. */
      executionId?: string | null;
      /** The id the parent task, if this task is a subtask. */
      parentTaskId?: string | null;
      /** The task's priority. */
      priority?: number | null;
      /** The id of the process definition the task belongs to. */
      processDefinitionId?: string | null;
      /** The id of the process instance the task belongs to. */
      processInstanceId?: string | null;
      /** The id of the case execution the task belongs to. */
      caseExecutionId?: string | null;
      /** The id of the case definition the task belongs to. */
      caseDefinitionId?: string | null;
      /** The id of the case instance the task belongs to. */
      caseInstanceId?: string | null;
      /** The task's key. */
      taskDefinitionKey?: string | null;
      /** Whether the task belongs to a process instance that is suspended. */
      suspended?: boolean | null;
      /** If not `null`, the form key for the task. */
      formKey?: string | null;
      /** If not `null`, the tenant id of the task. */
      tenantId?: string | null;
    };
    TaskEscalationDto: {
      /**
       * An escalation code that indicates the predefined escalation. It is used to identify
       * the BPMN escalation handler.
       */
      escalationCode?: string | null;
      /** A JSON object containing variable key-value pairs. */
      variables?: {
        [key: string]: components["schemas"]["VariableValueDto"];
      } | null;
    };
    /** A Task query which defines a group of Tasks. */
    TaskQueryDto: {
      /** Restrict to tasks that belong to process instances with the given id. */
      processInstanceId?: string | null;
      /** Restrict to tasks that belong to process instances with the given ids. */
      processInstanceIdIn?: string[] | null;
      /** Restrict to tasks that belong to process instances with the given business key. */
      processInstanceBusinessKey?: string | null;
      /**
       * Restrict to tasks that belong to process instances with the given business key which
       * is described by an expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      processInstanceBusinessKeyExpression?: string | null;
      /**
       * Restrict to tasks that belong to process instances with one of the give business keys.
       * The keys need to be in a comma-separated list.
       */
      processInstanceBusinessKeyIn?: string[] | null;
      /**
       * Restrict to tasks that have a process instance business key that has the parameter
       * value as a substring.
       */
      processInstanceBusinessKeyLike?: string | null;
      /**
       * Restrict to tasks that have a process instance business key that has the parameter
       * value as a substring and is described by an expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      processInstanceBusinessKeyLikeExpression?: string | null;
      /** Restrict to tasks that belong to a process definition with the given id. */
      processDefinitionId?: string | null;
      /** Restrict to tasks that belong to a process definition with the given key. */
      processDefinitionKey?: string | null;
      /**
       * Restrict to tasks that belong to a process definition with one of the given keys. The
       * keys need to be in a comma-separated list.
       */
      processDefinitionKeyIn?: string[] | null;
      /** Restrict to tasks that belong to a process definition with the given name. */
      processDefinitionName?: string | null;
      /**
       * Restrict to tasks that have a process definition name that has the parameter value as
       * a substring.
       */
      processDefinitionNameLike?: string | null;
      /** Restrict to tasks that belong to an execution with the given id. */
      executionId?: string | null;
      /** Restrict to tasks that belong to case instances with the given id. */
      caseInstanceId?: string | null;
      /** Restrict to tasks that belong to case instances with the given business key. */
      caseInstanceBusinessKey?: string | null;
      /**
       * Restrict to tasks that have a case instance business key that has the parameter value
       * as a substring.
       */
      caseInstanceBusinessKeyLike?: string | null;
      /** Restrict to tasks that belong to a case definition with the given id. */
      caseDefinitionId?: string | null;
      /** Restrict to tasks that belong to a case definition with the given key. */
      caseDefinitionKey?: string | null;
      /** Restrict to tasks that belong to a case definition with the given name. */
      caseDefinitionName?: string | null;
      /**
       * Restrict to tasks that have a case definition name that has the parameter value as a
       * substring.
       */
      caseDefinitionNameLike?: string | null;
      /** Restrict to tasks that belong to a case execution with the given id. */
      caseExecutionId?: string | null;
      /**
       * Only include tasks which belong to one of the passed and comma-separated activity
       * instance ids.
       */
      activityInstanceIdIn?: string[] | null;
      /**
       * Only include tasks which belong to one of the passed and comma-separated
       * tenant ids.
       */
      tenantIdIn?: string[] | null;
      /**
       * Only include tasks which belong to no tenant. Value may only be `true`,
       * as `false` is the default behavior.
       */
      withoutTenantId?: boolean | null;
      /** Restrict to tasks that the given user is assigned to. */
      assignee?: string | null;
      /**
       * Restrict to tasks that the user described by the given expression is assigned to. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      assigneeExpression?: string | null;
      /**
       * Restrict to tasks that have an assignee that has the parameter
       * value as a substring.
       */
      assigneeLike?: string | null;
      /**
       * Restrict to tasks that have an assignee that has the parameter value described by the
       * given expression as a substring. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      assigneeLikeExpression?: string | null;
      /** Only include tasks which are assigned to one of the passed and comma-separated user ids. */
      assigneeIn?: string[] | null;
      /** Restrict to tasks that the given user owns. */
      owner?: string | null;
      /**
       * Restrict to tasks that the user described by the given expression owns. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      ownerExpression?: string | null;
      /** Only include tasks that are offered to the given group. */
      candidateGroup?: string | null;
      /**
       * Only include tasks that are offered to the group described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      candidateGroupExpression?: string | null;
      /** Only include tasks that are offered to the given user or to one of his groups. */
      candidateUser?: string | null;
      /**
       * Only include tasks that are offered to the user described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      candidateUserExpression?: string | null;
      /**
       * Also include tasks that are assigned to users in candidate queries. Default is to only
       * include tasks that are not assigned to any user if you query by candidate user or
       * group(s).
       */
      includeAssignedTasks?: boolean | null;
      /**
       * Only include tasks that the given user is involved in. A user is involved in a task if
       * an identity link exists between task and user (e.g., the user is the assignee).
       */
      involvedUser?: string | null;
      /**
       * Only include tasks that the user described by the given expression is involved in.
       * A user is involved in a task if an identity link exists between task and user
       * (e.g., the user is the assignee). See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions.
       */
      involvedUserExpression?: string | null;
      /** If set to `true`, restricts the query to all tasks that are assigned. */
      assigned?: boolean | null;
      /** If set to `true`, restricts the query to all tasks that are unassigned. */
      unassigned?: boolean | null;
      /** Restrict to tasks that have the given key. */
      taskDefinitionKey?: string | null;
      /** Restrict to tasks that have one of the given keys. The keys need to be in a comma-separated list. */
      taskDefinitionKeyIn?: string[] | null;
      /** Restrict to tasks that have a key that has the parameter value as a substring. */
      taskDefinitionKeyLike?: string | null;
      /** Restrict to tasks that have the given name. */
      name?: string | null;
      /** Restrict to tasks that do not have the given name. */
      nameNotEqual?: string | null;
      /** Restrict to tasks that have a name with the given parameter value as substring. */
      nameLike?: string | null;
      /**
       * Restrict to tasks that do not have a name with the given parameter
       * value as substring.
       */
      nameNotLike?: string | null;
      /** Restrict to tasks that have the given description. */
      description?: string | null;
      /**
       * Restrict to tasks that have a description that has the parameter
       * value as a substring.
       */
      descriptionLike?: string | null;
      /** Restrict to tasks that have the given priority. */
      priority?: number | null;
      /** Restrict to tasks that have a lower or equal priority. */
      maxPriority?: number | null;
      /** Restrict to tasks that have a higher or equal priority. */
      minPriority?: number | null;
      /**
       * Restrict to tasks that are due on the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
       * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.546+0200`.
       */
      dueDate?: string | null;
      /**
       * Restrict to tasks that are due on the date described by the given expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      dueDateExpression?: string | null;
      /**
       * Restrict to tasks that are due after the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
       * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.435+0200`.
       */
      dueAfter?: string | null;
      /**
       * Restrict to tasks that are due after the date described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      dueAfterExpression?: string | null;
      /**
       * Restrict to tasks that are due before the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
       * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.243+0200`.
       */
      dueBefore?: string | null;
      /**
       * Restrict to tasks that are due before the date described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      dueBeforeExpression?: string | null;
      /**
       * Only include tasks which have no due date. Value may only be `true`,
       * as `false` is the default behavior.
       */
      withoutDueDate?: boolean | null;
      /**
       * Restrict to tasks that have a followUp date on the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date
       * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.342+0200`.
       */
      followUpDate?: string | null;
      /**
       * Restrict to tasks that have a followUp date on the date described by the given
       * expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      followUpDateExpression?: string | null;
      /**
       * Restrict to tasks that have a followUp date after the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
       * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.542+0200`.
       */
      followUpAfter?: string | null;
      /**
       * Restrict to tasks that have a followUp date after the date described by the given
       * expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      followUpAfterExpression?: string | null;
      /**
       * Restrict to tasks that have a followUp date before the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
       * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.234+0200`.
       */
      followUpBefore?: string | null;
      /**
       * Restrict to tasks that have a followUp date before the date described by the given
       * expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      followUpBeforeExpression?: string | null;
      /**
       * Restrict to tasks that have no followUp date or a followUp date before the given date.
       * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
       * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.432+0200`. The typical use case
       * is to query all `active` tasks for a user for a given date.
       */
      followUpBeforeOrNotExistent?: string | null;
      /**
       * Restrict to tasks that have no followUp date or a followUp date before the date
       * described by the given expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      followUpBeforeOrNotExistentExpression?: string | null;
      /**
       * Restrict to tasks that were created on the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
       * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.324+0200`.
       */
      createdOn?: string | null;
      /**
       * Restrict to tasks that were created on the date described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      createdOnExpression?: string | null;
      /**
       * Restrict to tasks that were created after the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must
       * have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.342+0200`.
       */
      createdAfter?: string | null;
      /**
       * Restrict to tasks that were created after the date described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      createdAfterExpression?: string | null;
      /**
       * Restrict to tasks that were created before the given date. By
       * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must
       * have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.332+0200`.
       */
      createdBefore?: string | null;
      /**
       * Restrict to tasks that were created before the date described by the given expression.
       * See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to a
       * `java.util.Date` or `org.joda.time.DateTime` object.
       */
      createdBeforeExpression?: string | null;
      /**
       * Restrict to tasks that are in the given delegation state. Valid values are
       * `PENDING` and `RESOLVED`.
       */
      delegationState?: ("PENDING" | "RESOLVED") | null;
      /**
       * Restrict to tasks that are offered to any of the given candidate groups. Takes a
       * comma-separated list of group names, so for example
       * `developers,support,sales`.
       */
      candidateGroups?: string[] | null;
      /**
       * Restrict to tasks that are offered to any of the candidate groups described by the
       * given expression. See the
       * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
       * for more information on available functions. The expression must evaluate to
       * `java.util.List` of Strings.
       */
      candidateGroupsExpression?: string | null;
      /**
       * Only include tasks which have a candidate group. Value may only be `true`,
       * as `false` is the default behavior.
       */
      withCandidateGroups?: boolean | null;
      /**
       * Only include tasks which have no candidate group. Value may only be `true`,
       * as `false` is the default behavior.
       */
      withoutCandidateGroups?: boolean | null;
      /**
       * Only include tasks which have a candidate user. Value may only be `true`,
       * as `false` is the default behavior.
       */
      withCandidateUsers?: boolean | null;
      /**
       * Only include tasks which have no candidate users. Value may only be `true`,
       * as `false` is the default behavior.
       */
      withoutCandidateUsers?: boolean | null;
      /**
       * Only include active tasks. Value may only be `true`, as `false`
       * is the default behavior.
       */
      active?: boolean | null;
      /**
       * Only include suspended tasks. Value may only be `true`, as
       * `false` is the default behavior.
       */
      suspended?: boolean | null;
      /**
       * A JSON array to only include tasks that have variables with certain values. The
       * array consists of JSON objects with three properties `name`, `operator` and `value`.
       * `name` is the variable name, `operator` is the comparison operator to be used and
       * `value` the variable value. `value` may be of type `String`, `Number` or `Boolean`.
       *
       * Valid `operator` values are:
       * `eq` - equal to;
       * `neq` - not equal to;
       * `gt` - greater than;
       * `gteq` - greater than or equal to;
       * `lt` - lower than;
       * `lteq` - lower than or equal to;
       * `like`.
       * `key` and `value` may not contain underscore or comma characters.
       */
      taskVariables?:
        | components["schemas"]["VariableQueryParameterDto"][]
        | null;
      /**
       * A JSON array to only include tasks that belong to a process instance with variables
       * with certain values. The array consists of JSON objects with three properties
       * `name`, `operator` and `value`. `name` is the variable name, `operator` is the
       * comparison operator to be used and `value` the variable value. `value` may be of
       * type `String`, `Number` or `Boolean`.
       *
       * Valid `operator` values are:
       * `eq` - equal to;
       * `neq` - not equal to;
       * `gt` - greater than;
       * `gteq` - greater than or equal to;
       * `lt` - lower than;
       * `lteq` - lower than or equal to;
       * `like`;
       * `notLike`.
       * `key` and `value` may not contain underscore or comma characters.
       */
      processVariables?:
        | components["schemas"]["VariableQueryParameterDto"][]
        | null;
      /**
       * A JSON array to only include tasks that belong to a case instance with variables
       * with certain values. The array consists of JSON objects with three properties
       * `name`, `operator` and `value`. `name` is the variable name, `operator` is the
       * comparison operator to be used and `value` the variable value. `value` may be of
       * type `String`, `Number` or `Boolean`.
       *
       * Valid `operator` values are:
       * `eq` - equal to;
       * `neq` - not equal to;
       * `gt` - greater than;
       * `gteq` - greater than or equal to;
       * `lt` - lower than;
       * `lteq` - lower than or equal to;
       * `like`.
       * `key` and `value` may not contain underscore or comma characters.
       */
      caseInstanceVariables?:
        | components["schemas"]["VariableQueryParameterDto"][]
        | null;
      /**
       * Match all variable names in this query case-insensitively. If set
       * `variableName` and `variablename` are treated as equal.
       */
      variableNamesIgnoreCase?: boolean | null;
      /**
       * Match all variable values in this query case-insensitively. If set
       * `variableValue` and `variablevalue` are treated as equal.
       */
      variableValuesIgnoreCase?: boolean | null;
      /** Restrict query to all tasks that are sub tasks of the given task. Takes a task id. */
      parentTaskId?: string | null;
      /**
       * A JSON array of nested task queries with OR semantics. A task matches a nested query if it fulfills
       * *at least one* of the query's predicates. With multiple nested queries, a task must fulfill at least one predicate of *each* query ([Conjunctive Normal Form](https://en.wikipedia.org/wiki/Conjunctive_normal_form)).
       *
       * All task query properties can be used except for: `sorting`, `withCandidateGroups`,
       * `withoutCandidateGroups`, `withCandidateUsers`, `withoutCandidateUsers`
       *
       * See the [User guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-engine-api/#or-queries)
       * for more information about OR queries.
       */
      orQueries?: components["schemas"]["TaskQueryDto"][] | null;
      /** Apply sorting of the result */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "instanceId"
              | "caseInstanceId"
              | "dueDate"
              | "executionId"
              | "caseExecutionId"
              | "assignee"
              | "created"
              | "description"
              | "id"
              | "name"
              | "nameCaseInsensitive"
              | "priority"
              | "processVariable"
              | "executionVariable"
              | "taskVariable"
              | "caseExecutionVariable"
              | "caseInstanceVariable"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
        parameters?: components["schemas"]["SortTaskQueryParametersDto"];
      }[];
    };
    TelemetryConfigurationDto: {
      /** Specifies if the telemetry data should be sent or not. */
      enableTelemetry?: boolean | null;
    };
    TenantDto: {
      /** The id of the tenant. */
      id?: string | null;
      /** The name of the tenant. */
      name?: string | null;
    };
    /** A JSON object corresponding to the Activity Instance tree of the given process instance. */
    TransitionInstanceDto: {
      /** The id of the transition instance. */
      id?: string | null;
      /** The id of the parent activity instance, for example a sub process instance. */
      parentActivityInstanceId?: string | null;
      /** The id of the activity that this instance enters (asyncBefore job) or leaves (asyncAfter job) */
      activityId?: string | null;
      /** The name of the activity that this instance enters (asyncBefore job) or leaves (asyncAfter job) */
      activityName?: string | null;
      /** The type of the activity that this instance enters (asyncBefore job) or leaves (asyncAfter job) */
      activityType?: string | null;
      /** The id of the process instance this instance is part of. */
      processInstanceId?: string | null;
      /** The id of the process definition. */
      processDefinitionId?: string | null;
      /** The execution id. */
      executionId?: string | null;
      /** A list of incident ids. */
      incidentIds?: string[] | null;
      /**
       * A list of JSON objects containing incident specific properties:
       * * `id`: the id of the incident
       * * `activityId`: the activity id in which the incident occurred
       */
      incidents?: components["schemas"]["ActivityInstanceIncidentDto"][] | null;
    };
    TriggerVariableValueDto: {
      /**
       * Indicates whether the variable should be a local variable or not.
       * If set to true, the variable becomes a local variable of the execution
       * entering the target activity.
       */
      local?: boolean | null;
    } & components["schemas"]["VariableValueDto"];
    UserCredentialsDto: {
      /** The users new password. */
      password?: string | null;
      /**
       * The password of the authenticated user who changes the password of the user
       * (i.e., the user with passed id as path parameter).
       */
      authenticatedUserPassword?: string | null;
    };
    UserDto: {
      profile?: components["schemas"]["UserProfileDto"];
      credentials?: components["schemas"]["UserCredentialsDto"];
    };
    UserIdDto: {
      /** The id of the user that the current action refers to. */
      userId?: string | null;
    };
    UserProfileDto: {
      /** The id of the user. */
      id?: string | null;
      /** The first name of the user. */
      firstName?: string | null;
      /** The first name of the user. */
      lastName?: string | null;
      /** The email of the user. */
      email?: string | null;
    };
    VariableInstanceDto: {
      /** The id of the variable instance. */
      id?: string | null;
      /** The name of the variable instance. */
      name?: string | null;
      /** The id of the process definition that this variable instance belongs to. */
      processDefinitionId?: string | null;
      /** The id of the process instance that this variable instance belongs to. */
      processInstanceId?: string | null;
      /** The id of the execution that this variable instance belongs to. */
      executionId?: string | null;
      /** The id of the case instance that this variable instance belongs to. */
      caseInstanceId?: string | null;
      /** The id of the case execution that this variable instance belongs to. */
      caseExecutionId?: string | null;
      /** The id of the task that this variable instance belongs to. */
      taskId?: string | null;
      /** The id of the batch that this variable instance belongs to.< */
      batchId?: string | null;
      /** The id of the activity instance that this variable instance belongs to. */
      activityInstanceId?: string | null;
      /** The id of the tenant that this variable instance belongs to. */
      tenantId?: string | null;
      /** An error message in case a Java Serialized Object could not be de-serialized. */
      errorMessage?: string | null;
    } & components["schemas"]["VariableValueDto"];
    /** A variable instance query which defines a list of variable instances */
    VariableInstanceQueryDto: {
      /** Filter by variable instance name. */
      variableName?: string | null;
      /**
       * Filter by the variable instance name. The parameter can include the wildcard `%` to
       * express like-strategy such as: starts with (`%`name), ends with (name`%`) or
       * contains (`%`name`%`).
       */
      variableNameLike?: string | null;
      /**
       * Only include variable instances which belong to one of the passed
       * process instance ids.
       */
      processInstanceIdIn?: string[] | null;
      /**
       * Only include variable instances which belong to one of the passed
       * execution ids.
       */
      executionIdIn?: string[] | null;
      /** Only include variable instances which belong to one of the passed  case instance ids. */
      caseInstanceIdIn?: string[] | null;
      /** Only include variable instances which belong to one of the passed  case execution ids. */
      caseExecutionIdIn?: string[] | null;
      /**
       * Only include variable instances which belong to one of the passed  task
       * ids.
       */
      taskIdIn?: string[] | null;
      /**
       * Only include variable instances which belong to one of the passed
       * batch ids.
       */
      batchIdIn?: string[] | null;
      /**
       * Only include variable instances which belong to one of the passed
       * activity instance ids.
       */
      activityInstanceIdIn?: string[] | null;
      /**
       * Only include variable instances which belong to one of the passed
       * tenant ids.
       */
      tenantIdIn?: string[] | null;
      /**
       * An array to only include variable instances that have the certain values.
       * The array consists of objects with the three properties `name`, `operator` and `value`. `name (String)` is the
       * variable name, `operator (String)` is the comparison operator to be used and `value` the variable value.
       * `value` may be `String`, `Number` or `Boolean`.
       *
       * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` - greater than; `gteq` - greater
       * than or equal to; `lt` - lower than; `lteq` - lower than or equal to; `like`
       */
      variableValues?:
        | components["schemas"]["VariableQueryParameterDto"][]
        | null;
      /**
       * Match all variable names provided in `variableValues` case-insensitively. If set to `true`
       * **variableName** and **variablename** are treated as equal.
       */
      variableNamesIgnoreCase?: boolean | null;
      /**
       * Match all variable values provided in `variableValues` case-insensitively. If set to
       * `true` **variableValue** and **variablevalue** are treated as equal.
       */
      variableValuesIgnoreCase?: boolean | null;
      /**
       * An array of criteria to sort the result by. Each element of the array is an object that specifies one ordering.
       *                       The position in the array identifies the rank of an ordering, i.e., whether it is primary, secondary, etc.
       *                       Sorting has no effect for `count` endpoints
       */
      sorting?: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | (
              | "variableName"
              | "variableType"
              | "activityInstanceId"
              | "tenantId"
            )
          | null;
        /**
         * Sort the results in a given order. Values may be `asc` for ascending order or `desc` for
         * descending order. Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: ("asc" | "desc") | null;
      }[];
    };
    VariableQueryParameterDto: {
      /** Variable name */
      name?: string | null;
    } & components["schemas"]["ConditionQueryParameterDto"];
    VariableValueDto: {
      /** The variable's value. Value differs depending on the variable's type and on the deserializeValues parameter. */
      value?: any;
      /** The value type of the variable. */
      type?: string | null;
      /**
       * A JSON object containing additional, value-type-dependent properties.
       * For serialized variables of type Object, the following properties can be provided:
       *
       * * `objectTypeName`: A string representation of the object's type name.
       * * `serializationDataFormat`: The serialization format used to store the variable.
       *
       * For serialized variables of type File, the following properties can be provided:
       *
       * * `filename`: The name of the file. This is not the variable name but the name that will be used when downloading the file again.
       * * `mimetype`: The MIME type of the file that is being uploaded.
       * * `encoding`: The encoding of the file that is being uploaded.
       *
       * The following property can be provided for all value types:
       *
       * * `transient`: Indicates whether the variable should be transient or
       * not. See [documentation](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables#transient-variables) for more informations.
       * (Not applicable for `decision-definition` and ` /process-instance/variables-async` endpoints)
       */
      valueInfo?: { [key: string]: any };
    };
    VersionDto: {
      /** The version of the Rest API. */
      version?: string | null;
    };
  };
}

export interface operations {
  /**
   * Queries for batches that fulfill given parameters. Parameters may be the properties of batches, such as the id or type.
   * The size of the result set can be retrieved by using the
   * [Get Batch Count](https://docs.camunda.org/manual/latest/reference/rest/batch/get-query-count/) method.
   */
  getBatches: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "batchId" | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by batch id. */
        batchId?: string;
        /**
         * Filter by batch type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/batch/#creating-a-batch)
         * for more information about batch types.
         */
        type?: string;
        /** Filter by a comma-separated list of `Strings`. A batch matches if it has one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include batches which belong to no tenant.
         * Value can effectively only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * A `Boolean` value which indicates whether only active or suspended batches should be included.
         * When the value is set to `true`, only suspended batches will be returned and
         * when the value is set to `false`, only active batches will be returned.
         */
        suspended?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid,
       * for example if a `sortOrder` parameter is supplied, but no `sortBy`.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Requests the number of batches that fulfill the query criteria.
   * Takes the same filtering parameters as the [Get Batches](https://docs.camunda.org/manual/latest/reference/rest/batch/get-query/) method.
   */
  getBatchesCount: {
    parameters: {
      query: {
        /** Filter by batch id. */
        batchId?: string;
        /**
         * Filter by batch type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/batch/#creating-a-batch)
         * for more information about batch types.
         */
        type?: string;
        /** Filter by a comma-separated list of `Strings`. A batch matches if it has one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include batches which belong to no tenant.
         * Value can effectively only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * A `Boolean` value which indicates whether only active or suspended batches should be included.
         * When the value is set to `true`, only suspended batches will be returned and
         * when the value is set to `false`, only active batches will be returned.
         */
        suspended?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for batch statistics that fulfill given parameters.
   * Parameters may be the properties of batches, such as the id or type.
   * The size of the result set can be retrieved by using the
   * [Get Batch Statistics Count](https://docs.camunda.org/manual/latest/reference/rest/batch/get-statistics-query-count/) method.
   */
  getBatchStatistics: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "batchId" | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by batch id. */
        batchId?: string;
        /**
         * Filter by batch type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/batch/#creating-a-batch)
         * for more information about batch types.
         */
        type?: string;
        /** Filter by a comma-separated list of `Strings`. A batch matches if it has one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include batches which belong to no tenant.
         * Value can effectively only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * A `Boolean` value which indicates whether only active or suspended batches should be included.
         * When the value is set to `true`, only suspended batches will be returned and
         * when the value is set to `false`, only active batches will be returned.
         */
        suspended?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchStatisticsDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid,
       * for example if a `sortOrder` parameter is supplied, but no `sortBy`.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Requests the number of batch statistics that fulfill the query criteria.
   * Takes the same filtering parameters as the
   * [Get Batch Statistics](https://docs.camunda.org/manual/latest/reference/rest/batch/get-statistics-query/) method.
   */
  getBatchStatisticsCount: {
    parameters: {
      query: {
        /** Filter by batch id. */
        batchId?: string;
        /**
         * Filter by batch type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/batch/#creating-a-batch)
         * for more information about batch types.
         */
        type?: string;
        /** Filter by a comma-separated list of `Strings`. A batch matches if it has one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include batches which belong to no tenant.
         * Value can effectively only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * A `Boolean` value which indicates whether only active or suspended batches should be included.
         * When the value is set to `true`, only suspended batches will be returned and
         * when the value is set to `false`, only active batches will be returned.
         */
        suspended?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves a batch by id, according to the Batch interface in the engine. */
  getBatch: {
    parameters: {
      path: {
        /** The id of the batch to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Batch with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Deletes a batch by id, including all related jobs and job definitions.
   * Optionally also deletes the batch history.
   */
  deleteBatch: {
    parameters: {
      path: {
        /** The id of the batch to be deleted. */
        id: string;
      };
      query: {
        /** `true`, if the historic batch and historic job logs for this batch should also be deleted. */
        cascade?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Batch with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Activates or suspends a batch by id. */
  updateBatchSuspensionState: {
    parameters: {
      path: {
        /** The id of the batch to activate or suspend. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the batch cannot be suspended or activated.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SuspensionStateDto"];
      };
    };
  };
  /**
   * Triggers evaluation of conditions for conditional start event(s).
   * Internally this maps to the engines condition evaluation builder method ConditionEvaluationBuilder#evaluateStartConditions().
   * For more information see the [Conditional Start Events](https://docs.camunda.org/manual/latest/reference/bpmn20/events/conditional-events/#conditional-start-event)
   * section of the [BPMN 2.0 Implementation Reference](https://docs.camunda.org/manual/latest/reference/bpmn20/).
   */
  evaluateCondition: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"][];
        };
      };
      /** If both tenantId and withoutTenantId are supplied. */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** If the user is not allowed to start the process instance of the process definition, which start condition was evaluated to `true`. */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["EvaluationConditionDto"];
      };
    };
  };
  /**
   * Queries for decision definitions that fulfill given parameters.
   * Parameters may be the properties of decision definitions, such as the name, key or version.
   * The size of the result set can be retrieved by using
   * the [Get Decision Definition Count](https://docs.camunda.org/manual/latest/reference/rest/decision-definition/get-query-count/) method.
   */
  getDecisionDefinitions: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "category"
          | "decisionRequirementsDefinitionKey"
          | "key"
          | "id"
          | "name"
          | "version"
          | "deploymentId"
          | "deployTime"
          | "versionTag"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by decision definition id. */
        decisionDefinitionId?: string;
        /** Filter by decision definition ids. */
        decisionDefinitionIdIn?: string;
        /** Filter by decision definition name. */
        name?: string;
        /** Filter by decision definition names that the parameter is a substring of. */
        nameLike?: string;
        /** Filter by the deployment the id belongs to. */
        deploymentId?: string;
        /**
         * Filter by the deploy time of the deployment the decision definition belongs to.
         * Only selects decision definitions that have been deployed after (exclusive) a specific time.
         */
        deployedAfter?: string;
        /**
         * Filter by the deploy time of the deployment the decision definition belongs to.
         * Only selects decision definitions that have been deployed at a specific time (exact match).
         */
        deployedAt?: string;
        /** Filter by decision definition key, i.e., the id in the DMN 1.0 XML. Exact match. */
        key?: string;
        /** Filter by decision definition keys that the parameter is a substring of. */
        keyLike?: string;
        /** Filter by decision definition category. Exact match. */
        category?: string;
        /** Filter by decision definition categories that the parameter is a substring of. */
        categoryLike?: string;
        /** Filter by decision definition version. */
        version?: number;
        /**
         * Only include those decision definitions that are latest versions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        latestVersion?: boolean;
        /** Filter by the name of the decision definition resource. Exact match. */
        resourceName?: string;
        /** Filter by names of those decision definition resources that the parameter is a substring of. */
        resourceNameLike?: string;
        /** Filter by the id of the decision requirements definition this decision definition belongs to. */
        decisionRequirementsDefinitionId?: string;
        /** Filter by the key of the decision requirements definition this decision definition belongs to. */
        decisionRequirementsDefinitionKey?: string;
        /**
         * Only include decision definitions which does not belongs to any decision requirements definition.
         * Value may only be `true`, as `false` is the default behavior.
         */
        withoutDecisionRequirementsDefinition?: boolean;
        /** Filter by a comma-separated list of `Strings`. A decision definition must have one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include decision definitions which belong to no tenant.
         * Value can effectively only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include decision definitions which belong to no tenant.
         * Can be used in combination with `tenantIdIn`.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeDecisionDefinitionsWithoutTenantId?: boolean;
        /** Filter by the version tag. */
        versionTag?: string;
        /** Filter by the version tags of those decision definition resources that the parameter is a substring of. */
        versionTagLike?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid,
       * for example if a `sortOrder` parameter is supplied, but no `sortBy`.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Requests the number of decision definitions that fulfill the query criteria.
   * Takes the same filtering parameters as the
   * [Get Decision Definition](https://docs.camunda.org/manual/latest/reference/rest/decision-definition/get-query/) method.
   */
  getDecisionDefinitionsCount: {
    parameters: {
      query: {
        /** Filter by decision definition id. */
        decisionDefinitionId?: string;
        /** Filter by decision definition ids. */
        decisionDefinitionIdIn?: string;
        /** Filter by decision definition name. */
        name?: string;
        /** Filter by decision definition names that the parameter is a substring of. */
        nameLike?: string;
        /** Filter by the deployment the id belongs to. */
        deploymentId?: string;
        /**
         * Filter by the deploy time of the deployment the decision definition belongs to.
         * Only selects decision definitions that have been deployed after (exclusive) a specific time.
         */
        deployedAfter?: string;
        /**
         * Filter by the deploy time of the deployment the decision definition belongs to.
         * Only selects decision definitions that have been deployed at a specific time (exact match).
         */
        deployedAt?: string;
        /** Filter by decision definition key, i.e., the id in the DMN 1.0 XML. Exact match. */
        key?: string;
        /** Filter by decision definition keys that the parameter is a substring of. */
        keyLike?: string;
        /** Filter by decision definition category. Exact match. */
        category?: string;
        /** Filter by decision definition categories that the parameter is a substring of. */
        categoryLike?: string;
        /** Filter by decision definition version. */
        version?: number;
        /**
         * Only include those decision definitions that are latest versions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        latestVersion?: boolean;
        /** Filter by the name of the decision definition resource. Exact match. */
        resourceName?: string;
        /** Filter by names of those decision definition resources that the parameter is a substring of. */
        resourceNameLike?: string;
        /** Filter by the id of the decision requirements definition this decision definition belongs to. */
        decisionRequirementsDefinitionId?: string;
        /** Filter by the key of the decision requirements definition this decision definition belongs to. */
        decisionRequirementsDefinitionKey?: string;
        /**
         * Only include decision definitions which does not belongs to any decision requirements definition.
         * Value may only be `true`, as `false` is the default behavior.
         */
        withoutDecisionRequirementsDefinition?: boolean;
        /** Filter by a comma-separated list of `Strings`. A decision definition must have one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include decision definitions which belong to no tenant.
         * Value can effectively only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include decision definitions which belong to no tenant.
         * Can be used in combination with `tenantIdIn`.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeDecisionDefinitionsWithoutTenantId?: boolean;
        /** Filter by the version tag. */
        versionTag?: string;
        /** Filter by the version tags of those decision definition resources that the parameter is a substring of. */
        versionTagLike?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the latest version of the decision definition which belongs to no tenant. */
  getDecisionDefinitionByKey: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof) to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDto"];
        };
      };
      /**
       * Decision definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Returns the diagram for the latest version of the decision definition which belongs to no tenant */
  getDecisionDefinitionDiagramByKey: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof) to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. The image diagram of this process. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /** The decision definition doesn't have an associated diagram. */
      204: never;
      /**
       * Decision definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Evaluates the latest version of the decision definition which belongs to no tenant.
   * The input values of the decision have to be supplied in the request body.
   */
  evaluateDecisionByKey: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof) to be evaluated. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          }[];
        };
      };
      /**
       * Decision definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["EvaluateDecisionDto"];
      };
    };
  };
  /**
   * Updates the latest version of the decision definition which belongs to no tenant.
   * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
   */
  updateHistoryTimeToLiveByDecisionDefinitionKey: {
    parameters: {
      path: {
        /** The key of the decision definitions to change history time to live. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the request parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Decision definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoryTimeToLiveDto"];
      };
    };
  };
  /** Retrieves the latest version of the decision definition for tenant */
  getDecisionDefinitionByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the decision definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDto"];
        };
      };
      /**
       * Decision definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Returns the XML of the latest version of the decision definition for tenant. */
  getDecisionDefinitionDiagramByKeyAndTenant: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the decision definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. The image diagram of this process. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /** The decision definition doesn't have an associated diagram. */
      204: never;
      /**
       * Decision definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Evaluates the latest version of the decision definition for tenant.
   * The input values of the decision have to be supplied in the request body.
   */
  evaluateDecisionByKeyAndTenant: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof) to be evaluated. */
        key: string;
        /** The id of the tenant the decision definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          }[];
        };
      };
      /**
       * Decision definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["EvaluateDecisionDto"];
      };
    };
  };
  /**
   * Updates the latest version of the decision definition for tenant.
   * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
   */
  updateHistoryTimeToLiveByDecisionDefinitionKeyAndTenant: {
    parameters: {
      path: {
        /** The key of the decision definitions to change history time to live. */
        key: string;
        /** The id of the tenant the decision definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the request parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Decision definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoryTimeToLiveDto"];
      };
    };
  };
  /** Retrieves the XML of the latest version of the decision definition for tenant */
  getDecisionDefinitionDmnXmlByKeyAndTenant: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof). */
        key: string;
        /** The id of the tenant the decision definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDiagramDto"];
        };
      };
      /**
       * Decision definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the XML for the latest version of the decision definition which belongs to no tenant. */
  getDecisionDefinitionDmnXmlByKey: {
    parameters: {
      path: {
        /** The key of the decision definition (the latest version thereof). */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDiagramDto"];
        };
      };
      /**
       * Decision definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves a decision definition by id, according to the `DecisionDefinition` interface in the engine. */
  getDecisionDefinitionById: {
    parameters: {
      path: {
        /** The id of the decision definition to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDto"];
        };
      };
      /**
       * Decision definition with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the diagram of a decision definition. */
  getDecisionDefinitionDiagram: {
    parameters: {
      path: {
        /** The id of the process definition. */
        id: string;
      };
    };
    responses: {
      /** Request successful. The image diagram of this process. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /** The decision definition doesn't have an associated diagram. */
      204: never;
      /**
       * Decision definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Evaluates a given decision and returns the result.
   * The input values of the decision have to be supplied in the request body.
   */
  evaluateDecisionById: {
    parameters: {
      path: {
        /** The id of the decision definition to be evaluated. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          }[];
        };
      };
      /**
       * Decision definition with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["EvaluateDecisionDto"];
      };
    };
  };
  /**
   * Updates history time to live for decision definition.
   * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
   */
  updateHistoryTimeToLiveByDecisionDefinitionId: {
    parameters: {
      path: {
        /** The id of the decision definition to change history time to live. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the request parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Decision definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoryTimeToLiveDto"];
      };
    };
  };
  /** Retrieves the DMN XML of a decision definition. */
  getDecisionDefinitionDmnXmlById: {
    parameters: {
      path: {
        /** The id of the decision definition. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DecisionDefinitionDiagramDto"];
        };
      };
      /**
       * Decision definition with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for deployments that fulfill given parameters. Parameters may be the properties of deployments,
   * such as the id or name or a range of the deployment time. The size of the result set can be retrieved by
   * using the [Get Deployment count](https://docs.camunda.org/manual/latest/reference/rest/deployment/get-query-count/) method.
   */
  getDeployments: {
    parameters: {
      query: {
        /** Filter by deployment id */
        id?: string;
        /** Filter by the deployment name. Exact match. */
        name?: string;
        /**
         * Filter by the deployment name that the parameter is a substring of. The parameter can include the
         * wildcard `%` to express like-strategy such as: starts with (`%`name), ends with (name`%`) or contains
         * (`%`name`%`).
         */
        nameLike?: string;
        /** Filter by the deployment source. */
        source?: string;
        /** Filter by the deployment source whereby source is equal to `null`. */
        withoutSource?: boolean;
        /** Filter by a comma-separated list of tenant ids. A deployment must have one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include deployments which belong to no tenant. Value may only be `true`, as `false` is the default
         * behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include deployments which belong to no tenant. Can be used in combination with `tenantIdIn`. Value may
         * only be `true`, as `false` is the default behavior.
         */
        includeDeploymentsWithoutTenantId?: boolean;
        /**
         * Restricts to all deployments after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        after?: string;
        /**
         * Restricts to all deployments before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        before?: string;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "id" | "name" | "deploymentTime" | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DeploymentDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy`, or if an invalid operator for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of deployments that fulfill given parameters. Takes the same parameters as the
   * [Get Deployments](https://docs.camunda.org/manual/latest/reference/rest/deployment/get-query/) method.
   */
  getDeploymentsCount: {
    parameters: {
      query: {
        /** Filter by deployment id */
        id?: string;
        /** Filter by the deployment name. Exact match. */
        name?: string;
        /**
         * Filter by the deployment name that the parameter is a substring of. The parameter can include the
         * wildcard `%` to express like-strategy such as: starts with (`%`name), ends with (name`%`) or contains
         * (`%`name`%`).
         */
        nameLike?: string;
        /** Filter by the deployment source. */
        source?: string;
        /** Filter by the deployment source whereby source is equal to `null`. */
        withoutSource?: boolean;
        /** Filter by a comma-separated list of tenant ids. A deployment must have one of the given tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include deployments which belong to no tenant. Value may only be `true`, as `false` is the default
         * behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include deployments which belong to no tenant. Can be used in combination with `tenantIdIn`. Value may
         * only be `true`, as `false` is the default behavior.
         */
        includeDeploymentsWithoutTenantId?: boolean;
        /**
         * Restricts to all deployments after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        after?: string;
        /**
         * Restricts to all deployments before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        before?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example, if an invalid operator for variable
       * comparison is used. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Creates a deployment.
   *
   * **Security Consideration**
   *
   * Deployments can contain custom code in form of scripts or EL expressions to customize process behavior.
   * This may be abused for remote execution of arbitrary code.
   */
  createDeployment: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DeploymentWithDefinitionsDto"];
        };
      };
      /**
       * Bad Request. In case one of the bpmn resources cannot be parsed.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#parse-exceptions) for
       * the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ParseExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["MultiFormDeploymentDto"];
      };
    };
  };
  /** Retrieves a deployment by id, according to the `Deployment` interface of the engine. */
  getDeployment: {
    parameters: {
      path: {
        /** The id of the deployment. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DeploymentDto"];
        };
      };
      /**
       * Deployment with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes a deployment by id. */
  deleteDeployment: {
    parameters: {
      path: {
        /** The id of the deployment to be deleted. */
        id: string;
      };
      query: {
        /**
         * `true`, if all process instances, historic process instances and jobs for this deployment
         * should be deleted.
         */
        cascade?: boolean;
        /** `true`, if only the built-in ExecutionListeners should be notified with the end event. */
        skipCustomListeners?: boolean;
        /** `true`, if all input/output mappings should not be invoked. */
        skipIoMappings?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * A Deployment with the provided id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Re-deploys an existing deployment.
   *
   * The deployment resources to re-deploy can be restricted by using the properties `resourceIds` or
   * `resourceNames`. If no deployment resources to re-deploy are passed then all existing resources of the
   * given deployment are re-deployed.
   *
   * **Warning**: Deployments can contain custom code in form of scripts or EL expressions to customize
   * process behavior. This may be abused for remote execution of arbitrary code. See the section on
   * [security considerations for custom code](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/) in
   * the user guide for details.
   */
  redeploy: {
    parameters: {
      path: {
        /** The id of the deployment to re-deploy. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DeploymentWithDefinitionsDto"];
        };
      };
      /**
       * Deployment or a deployment resource for the given deployment does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["RedeploymentDto"];
      };
    };
  };
  /** Retrieves all deployment resources of a given deployment. */
  getDeploymentResources: {
    parameters: {
      path: {
        /** The id of the deployment to retrieve the deployment resources for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DeploymentResourceDto"][];
        };
      };
      /**
       * Deployment resources for the given deployment do not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves a deployment resource by resource id for the given deployment. */
  getDeploymentResource: {
    parameters: {
      path: {
        /** The id of the deployment */
        id: string;
        /** The id of the deployment resource */
        resourceId: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DeploymentResourceDto"];
        };
      };
      /**
       * Deployment Resource with given resource id or deployment id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the binary content of a deployment resource for the given deployment by id. */
  getDeploymentResourceData: {
    parameters: {
      path: {
        /** The id of the deployment. */
        id: string;
        /** The id of the deployment resource. */
        resourceId: string;
      };
    };
    responses: {
      /** Request successful. The media type of the response depends on the filename. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /**
       * Deployment Resource with given resource id or deployment id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the names of all process engines available on your platform.
   * **Note**: You cannot prepend `/engine/{name}` to this method.
   */
  getProcessEngineNames: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessEngineDto"][];
        };
      };
    };
  };
  /**
   * Queries for event subscriptions that fulfill given parameters.
   * The size of the result set can be retrieved by using the
   * [Get Event Subscriptions count](https://docs.camunda.org/manual/latest/reference/rest/event-subscription/get-query-count/) method.
   */
  getEventSubscriptions: {
    parameters: {
      query: {
        /** Only select subscription with the given id. */
        eventSubscriptionId?: string;
        /** Only select subscriptions for events with the given name. */
        eventName?: string;
        /**
         * Only select subscriptions for events with the given type.
         * Valid values: `message`, `signal`, `compensate` and `conditional`.
         */
        eventType?: "message" | "signal" | "compensate" | "conditional";
        /** Only select subscriptions that belong to an execution with the given id. */
        executionId?: string;
        /** Only select subscriptions that belong to a process instance with the given id. */
        processInstanceId?: string;
        /** Only select subscriptions that belong to an activity with the given id. */
        activityId?: string;
        /**
         * Filter by a comma-separated list of tenant ids.
         * Only select subscriptions that belong to one of the given tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only select subscriptions which have no tenant id.
         * Value may only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Select event subscriptions which have no tenant id.
         * Can be used in combination with tenantIdIn parameter.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeEventSubscriptionsWithoutTenantId?: boolean;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "created" | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["EventSubscriptionDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid,
       * for example if a `sortOrder` parameter is supplied, but no `sortBy`.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of event subscriptions that fulfill given parameters.
   * Takes the same parameters as the
   * [Get Event Subscriptions](https://docs.camunda.org/manual/latest/reference/rest/event-subscription/get-query/) method.
   */
  getEventSubscriptionsCount: {
    parameters: {
      query: {
        /** Only select subscription with the given id. */
        eventSubscriptionId?: string;
        /** Only select subscriptions for events with the given name. */
        eventName?: string;
        /**
         * Only select subscriptions for events with the given type.
         * Valid values: `message`, `signal`, `compensate` and `conditional`.
         */
        eventType?: "message" | "signal" | "compensate" | "conditional";
        /** Only select subscriptions that belong to an execution with the given id. */
        executionId?: string;
        /** Only select subscriptions that belong to a process instance with the given id. */
        processInstanceId?: string;
        /** Only select subscriptions that belong to an activity with the given id. */
        activityId?: string;
        /**
         * Filter by a comma-separated list of tenant ids.
         * Only select subscriptions that belong to one of the given tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only select subscriptions which have no tenant id.
         * Value may only be `true`, as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Select event subscriptions which have no tenant id.
         * Can be used in combination with tenantIdIn parameter.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeEventSubscriptionsWithoutTenantId?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the executions that fulfill given parameters.
   * Parameters may be static as well as dynamic runtime properties of
   * executions.
   * The size of the result set can be retrieved by using the [Get
   * Execution Count](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query-count/)
   * method.
   */
  getExecutions: {
    parameters: {
      query: {
        /** Filter by the business key of the process instances the executions belong to. */
        businessKey?: string;
        /** Filter by the process definition the executions run on. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the executions run on. */
        processDefinitionKey?: string;
        /** Filter by the id of the process instance the execution belongs to. */
        processInstanceId?: string;
        /** Filter by the id of the activity the execution currently executes. */
        activityId?: string;
        /** Select only those executions that expect a signal of the given name. */
        signalEventSubscriptionName?: string;
        /** Select only those executions that expect a message of the given name. */
        messageEventSubscriptionName?: string;
        /**
         * Only include active executions. Value may only be `true`, as `false` is the default
         * behavior.
         */
        active?: boolean;
        /**
         * Only include suspended executions. Value may only be `true`, as `false` is the default
         * behavior.
         */
        suspended?: boolean;
        /** Filter by the incident id. */
        incidentId?: string;
        /** Filter by the incident type. See the [User Guide](/manual/develop/user-guide/process-engine/incidents/#incident-types) for a list of incident types. */
        incidentType?: string;
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /**
         * Filter by a comma-separated list of tenant ids. An execution must have one of the given
         * tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include executions that have variables with certain values.
         * Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`.
         * `key` is the variable name, `operator` is the comparison operator to be used
         * and `value` the variable value.
         * **Note:** Values are always treated as `String` objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` -
         * greater than;
         * `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or
         * equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        variables?: string;
        /**
         * Only include executions that belong to a process instance with variables with certain
         * values.
         * Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`.
         * `key` is the variable name, `operator` is the comparison operator to be used
         * and `value` the variable value.
         * **Note:** Values are always treated as `String` objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to.
         * `key` and `value` may not contain underscore or comma characters.
         */
        processVariables?: string;
        /**
         * Match all variable names provided in `variables` and `processVariables` case-
         * insensitively. If set to `true` **variableName** and **variablename** are
         * treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values provided in `variables` and `processVariables` case-
         * insensitively. If set to `true` **variableValue** and **variablevalue** are
         * treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "instanceId" | "definitionKey" | "definitionId" | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ExecutionDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator
       * for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for executions that fulfill given parameters through a JSON object.
   * This method is slightly more powerful than the [Get
   * Executions](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query/) method
   * because it allows
   * to filter by multiple instance and execution variables of types
   * `String`, `Number` or `Boolean`.
   */
  queryExecutions: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ExecutionDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator
       * for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExecutionQueryDto"];
      };
    };
  };
  /**
   * Queries for the number of executions that fulfill given parameters.
   * Takes the same parameters as the [Get
   * Executions](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query/) method.
   */
  getExecutionsCount: {
    parameters: {
      query: {
        /** Filter by the business key of the process instances the executions belong to. */
        businessKey?: string;
        /** Filter by the process definition the executions run on. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the executions run on. */
        processDefinitionKey?: string;
        /** Filter by the id of the process instance the execution belongs to. */
        processInstanceId?: string;
        /** Filter by the id of the activity the execution currently executes. */
        activityId?: string;
        /** Select only those executions that expect a signal of the given name. */
        signalEventSubscriptionName?: string;
        /** Select only those executions that expect a message of the given name. */
        messageEventSubscriptionName?: string;
        /**
         * Only include active executions. Value may only be `true`, as `false` is the default
         * behavior.
         */
        active?: boolean;
        /**
         * Only include suspended executions. Value may only be `true`, as `false` is the default
         * behavior.
         */
        suspended?: boolean;
        /** Filter by the incident id. */
        incidentId?: string;
        /** Filter by the incident type. See the [User Guide](/manual/develop/user-guide/process-engine/incidents/#incident-types) for a list of incident types. */
        incidentType?: string;
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /**
         * Filter by a comma-separated list of tenant ids. An execution must have one of the given
         * tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include executions that have variables with certain values.
         * Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`.
         * `key` is the variable name, `operator` is the comparison operator to be used
         * and `value` the variable value.
         * **Note:** Values are always treated as `String` objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` -
         * greater than;
         * `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or
         * equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        variables?: string;
        /**
         * Only include executions that belong to a process instance with variables with certain
         * values.
         * Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`.
         * `key` is the variable name, `operator` is the comparison operator to be used
         * and `value` the variable value.
         * **Note:** Values are always treated as `String` objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to.
         * `key` and `value` may not contain underscore or comma characters.
         */
        processVariables?: string;
        /**
         * Match all variable names provided in `variables` and `processVariables` case-
         * insensitively. If set to `true` **variableName** and **variablename** are
         * treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values provided in `variables` and `processVariables` case-
         * insensitively. If set to `true` **variableValue** and **variablevalue** are
         * treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if an invalid operator
       * for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of executions that fulfill given parameters. This method
   * takes the same message body as the [Get Executions
   * POST](https://docs.camunda.org/manual/latest/reference/rest/execution/post-query/) method and
   * therefore it is slightly more powerful than the [Get Execution
   * Count](https://docs.camunda.org/manual/latest/reference/rest/execution/get-query-count/) method.
   */
  queryExecutionsCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if an invalid operator
       * for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExecutionQueryDto"];
      };
    };
  };
  /**
   * Retrieves an execution by id, according to the `Execution` interface in the
   * engine.
   */
  getExecution: {
    parameters: {
      path: {
        /** The id of the execution to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ExecutionDto"];
        };
      };
      /**
       * Execution with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Creates a custom incident with given properties. */
  createIncident: {
    parameters: {
      path: {
        /** The id of the execution to create a new incident for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["IncidentDto"];
        };
      };
      /**
       * Returned if the incident type is null, the execution does not exist or the
       * execution is not related to any activity.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CreateIncidentDto"];
      };
    };
  };
  /** Retrieves all variables of a given execution by id. */
  getLocalExecutionVariables: {
    parameters: {
      path: {
        /** The id of the execution to retrieve the variables from. */
        id: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically
         * variables that store custom Java objects) should be deserialized
         * on server side (default `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on
         * server side and transformed to JSON using
         * [Jackson's](https://github.com/FasterXML/jackson) POJO/bean
         * property introspection feature. Note that this requires the Java
         * classes of the variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its
         * serialized format. For example, a variable that is serialized as
         * XML will be returned as a JSON string containing XML.
         *
         * **Note:** While `true` is the default value for reasons of
         * backward compatibility, we recommend setting this parameter to
         * `false` when developing web applications that are independent of
         * the Java process applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. Returns A JSON object of variables key-value pairs. Each key is a variable name and each value a VariableValueDto */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * Execution with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates or deletes the variables in the context of an execution by id. The updates
   * do not propagate upwards in the execution hierarchy.
   * Updates precede deletions. So, if a variable is updated AND deleted,
   * the deletion overrides the update.
   */
  modifyLocalExecutionVariables: {
    parameters: {
      path: {
        /** The id of the execution to set variables for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed
       * to an Integer value or the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-
       * handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Update or delete could not be executed, for example because the execution does not
       * exist.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PatchVariablesDto"];
      };
    };
  };
  /**
   * Retrieves a variable from the context of a given execution by id. Does not traverse
   * the parent execution hierarchy.
   */
  getLocalExecutionVariable: {
    parameters: {
      path: {
        /** The id of the execution to retrieve the variable from. */
        id: string;
        /** The name of the variable to get. */
        varName: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically
         * variables that store custom Java objects) should be deserialized
         * on server side (default `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on
         * server side and transformed to JSON using
         * [Jackson's](https://github.com/FasterXML/jackson) POJO/bean
         * property introspection feature. Note that this requires the Java
         * classes of the variable value to be on the REST API's classpath.
         * If set to `false`, a serializable variable will be returned in its
         * serialized format. For example, a variable that is serialized as
         * XML will be returned as a JSON string containing XML.
         *
         * **Note:** While `true` is the default value for reasons of
         * backward compatibility, we recommend setting this parameter to
         * `false` when developing web applications that are independent of
         * the Java process applications deployed to the engine.
         */
        deserializeValue?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableValueDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Sets a variable in the context of a given execution by id. Update does not
   * propagate upwards in the execution hierarchy.
   */
  putLocalExecutionVariable: {
    parameters: {
      path: {
        /** The id of the execution to set the variable for. */
        id: string;
        /** The name of the variable to set. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed
       * to an Integer value or the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-
       * handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["VariableValueDto"];
      };
    };
  };
  /**
   * Deletes a variable in the context of a given execution by id. Deletion does not
   * propagate upwards in the execution hierarchy.
   */
  deleteLocalExecutionVariable: {
    parameters: {
      path: {
        /** The id of the execution to delete the variable from. */
        id: string;
        /** The name of the variable to delete. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
    };
  };
  /**
   * Retrieves a binary variable from the context of a given execution by id. Does not
   * traverse the parent execution hierarchy. Applicable for byte array and
   * file variables.
   */
  getLocalExecutionVariableBinary: {
    parameters: {
      path: {
        /** The id of the execution to retrieve the variable from. */
        id: string;
        /** The name of the variable to get. */
        varName: string;
      };
    };
    responses: {
      /**
       * Request successful.
       *         For binary variables or files without any MIME type information, a byte stream is returned.
       *         File variables with MIME type information are returned as the saved type.
       *         Additionally, for file variables the Content-Disposition header will be set.
       */
      200: {
        content: {
          "application/octet-stream": string;
          "text/plain": string;
        };
      };
      /**
       * Variable instance with given id exists but is not a binary variable. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Variable instance with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Sets the serialized value for a binary variable or the binary value for a file
   * variable in the context of a given execution by id.
   */
  setLocalExecutionVariableBinary: {
    parameters: {
      path: {
        /** The id of the execution to set the variable for. */
        id: string;
        /** The name of the variable to set. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * The variable value or type is invalid, for example if no filename is set. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["MultiFormVariableBinaryDto"];
      };
    };
  };
  /**
   * Retrieves a message event subscription for a given execution by id and a message
   * name.
   */
  getMessageEventSubscription: {
    parameters: {
      path: {
        /** The id of the execution that holds the subscription. */
        id: string;
        /** The name of the message that the subscription corresponds to. */
        messageName: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["EventSubscriptionDto"];
        };
      };
      /**
       * A message subscription for the given name and execution does not exist.
       * This may either mean that the execution does not exist, or that
       * it is not subscribed on such a message.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Delivers a message to a specific execution by id, to trigger an existing message
   * event subscription. Inject process variables as the message's
   * payload.
   */
  triggerEvent: {
    parameters: {
      path: {
        /** The id of the execution to submit the message to. */
        id: string;
        /** The name of the message that the addressed subscription corresponds to. */
        messageName: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed
       * to an Integer value or the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The addressed execution has no pending message subscriptions for the given message.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExecutionTriggerDto"];
      };
    };
  };
  /**
   * Signals an execution by id. Can for example be used to explicitly skip user tasks
   * or signal asynchronous continuations.
   */
  signalExecution: {
    parameters: {
      path: {
        /** The id of the execution to signal. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed
       * to an Integer value or the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExecutionTriggerDto"];
      };
    };
  };
  /**
   * Queries for the external tasks that fulfill given parameters. Parameters may be static as well as dynamic
   * runtime properties of executions. The size of the result set can be retrieved by using the
   * [Get External Task Count](https://docs.camunda.org/manual/latest/reference/rest/external-task/get-query-count/) method.
   */
  getExternalTasks: {
    parameters: {
      query: {
        /** Filter by an external task's id. */
        externalTaskId?: string;
        /** Filter by the comma-separated list of external task ids. */
        externalTaskIdIn?: string;
        /** Filter by an external task topic. */
        topicName?: string;
        /** Filter by the id of the worker that the task was most recently locked by. */
        workerId?: string;
        /**
         * Only include external tasks that are currently locked (i.e., they have a lock time and it has not expired).
         * Value may only be `true`, as `false` matches any external task.
         */
        locked?: boolean;
        /**
         * Only include external tasks that are currently not locked (i.e., they have no lock or it has expired).
         * Value may only be `true`, as `false` matches any external task.
         */
        notLocked?: boolean;
        /**
         * Only include external tasks that have a positive (&gt; 0) number of retries (or `null`). Value may only be
         * `true`, as `false` matches any external task.
         */
        withRetriesLeft?: boolean;
        /**
         * Only include external tasks that have 0 retries. Value may only be `true`, as `false` matches any
         * external task.
         */
        noRetriesLeft?: boolean;
        /**
         * Restrict to external tasks that have a lock that expires after a given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        lockExpirationAfter?: string;
        /**
         * Restrict to external tasks that have a lock that expires before a given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        lockExpirationBefore?: string;
        /** Filter by the id of the activity that an external task is created for. */
        activityId?: string;
        /** Filter by the comma-separated list of ids of the activities that an external task is created for. */
        activityIdIn?: string;
        /** Filter by the id of the execution that an external task belongs to. */
        executionId?: string;
        /** Filter by the id of the process instance that an external task belongs to. */
        processInstanceId?: string;
        /** Filter by a comma-separated list of process instance ids that an external task may belong to. */
        processInstanceIdIn?: string;
        /** Filter by the id of the process definition that an external task belongs to. */
        processDefinitionId?: string;
        /**
         * Filter by a comma-separated list of tenant ids.
         * An external task must have one of the given tenant ids.
         */
        tenantIdIn?: string;
        /** Only include active tasks. Value may only be `true`, as `false` matches any external task. */
        active?: boolean;
        /** Only include suspended tasks. Value may only be `true`, as `false` matches any external task. */
        suspended?: boolean;
        /**
         * Only include jobs with a priority higher than or equal to the given value.
         * Value must be a valid `long` value.
         */
        priorityHigherThanOrEquals?: number;
        /**
         * Only include jobs with a priority lower than or equal to the given value.
         * Value must be a valid `long` value.
         */
        priorityLowerThanOrEquals?: number;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "id"
          | "lockExpirationTime"
          | "processInstanceId"
          | "processDefinitionId"
          | "processDefinitionKey"
          | "taskPriority"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ExternalTaskDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy`. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for external tasks that fulfill given parameters in the form of a JSON object.
   *
   * This method is slightly more powerful than the
   * [Get External Tasks](https://docs.camunda.org/manual/latest/reference/rest/external-task/get-query/) method because it allows to
   * specify a hierarchical result sorting.
   */
  queryExternalTasks: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. The Response is a JSON array of external task objects. */
      200: {
        content: {
          "application/json": components["schemas"]["ExternalTaskDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy`. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExternalTaskQueryDto"];
      };
    };
  };
  /**
   * Queries for the number of external tasks that fulfill given parameters. Takes the same parameters as the
   * [Get External Tasks](https://docs.camunda.org/manual/latest/reference/rest/external-task/get-query/) method.
   */
  getExternalTasksCount: {
    parameters: {
      query: {
        /** Filter by an external task's id. */
        externalTaskId?: string;
        /** Filter by the comma-separated list of external task ids. */
        externalTaskIdIn?: string;
        /** Filter by an external task topic. */
        topicName?: string;
        /** Filter by the id of the worker that the task was most recently locked by. */
        workerId?: string;
        /**
         * Only include external tasks that are currently locked (i.e., they have a lock time and it has not expired).
         * Value may only be `true`, as `false` matches any external task.
         */
        locked?: boolean;
        /**
         * Only include external tasks that are currently not locked (i.e., they have no lock or it has expired).
         * Value may only be `true`, as `false` matches any external task.
         */
        notLocked?: boolean;
        /**
         * Only include external tasks that have a positive (&gt; 0) number of retries (or `null`). Value may only be
         * `true`, as `false` matches any external task.
         */
        withRetriesLeft?: boolean;
        /**
         * Only include external tasks that have 0 retries. Value may only be `true`, as `false` matches any
         * external task.
         */
        noRetriesLeft?: boolean;
        /**
         * Restrict to external tasks that have a lock that expires after a given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        lockExpirationAfter?: string;
        /**
         * Restrict to external tasks that have a lock that expires before a given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format
         * `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        lockExpirationBefore?: string;
        /** Filter by the id of the activity that an external task is created for. */
        activityId?: string;
        /** Filter by the comma-separated list of ids of the activities that an external task is created for. */
        activityIdIn?: string;
        /** Filter by the id of the execution that an external task belongs to. */
        executionId?: string;
        /** Filter by the id of the process instance that an external task belongs to. */
        processInstanceId?: string;
        /** Filter by a comma-separated list of process instance ids that an external task may belong to. */
        processInstanceIdIn?: string;
        /** Filter by the id of the process definition that an external task belongs to. */
        processDefinitionId?: string;
        /**
         * Filter by a comma-separated list of tenant ids.
         * An external task must have one of the given tenant ids.
         */
        tenantIdIn?: string;
        /** Only include active tasks. Value may only be `true`, as `false` matches any external task. */
        active?: boolean;
        /** Only include suspended tasks. Value may only be `true`, as `false` matches any external task. */
        suspended?: boolean;
        /**
         * Only include jobs with a priority higher than or equal to the given value.
         * Value must be a valid `long` value.
         */
        priorityHigherThanOrEquals?: number;
        /**
         * Only include jobs with a priority lower than or equal to the given value.
         * Value must be a valid `long` value.
         */
        priorityLowerThanOrEquals?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of external tasks that fulfill given parameters. This method takes the same message
   * body as the [Get External Tasks (POST)](https://docs.camunda.org/manual/latest/reference/rest/external-task/post-query/) method.
   */
  queryExternalTasksCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExternalTaskQueryDto"];
      };
    };
  };
  /**
   * Fetches and locks a specific number of external tasks for execution by a worker. Query can be restricted
   * to specific task topics and for each task topic an individual lock time can be provided.
   */
  fetchAndLock: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["LockedExternalTaskDto"][];
        };
      };
      /**
       * Bad Request. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["FetchExternalTasksDto"];
      };
    };
  };
  /**
   * Sets the number of retries left to execute external tasks by id synchronously. If retries are set to 0,
   * an incident is created.
   */
  setExternalTaskRetries: {
    responses: {
      /** Request successful. */
      204: never;
      /**
       * In case the number of retries is negative or null, an exception of type `InvalidRequestException` is
       * returned. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetRetriesForExternalTasksDto"];
      };
    };
  };
  /**
   * Sets the number of retries left to execute external tasks by id asynchronously. If retries are set to 0,
   * an incident is created.
   */
  setExternalTaskRetriesAsyncOperation: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * If neither externalTaskIds nor externalTaskQuery are present or externalTaskIds contains null value or
       * the number of retries is negative or null, an exception of type `InvalidRequestException` is returned.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetRetriesForExternalTasksDto"];
      };
    };
  };
  /**
   * Queries for distinct topic names of external tasks that fulfill given parameters.
   * Query can be restricted to only tasks with retries left, tasks that are locked, or tasks
   * that are unlocked. The parameters withLockedTasks and withUnlockedTasks are
   * exclusive. Setting them both to true will return an empty list.
   * Providing no parameters will return a list of all distinct topic names with external tasks.
   */
  getTopicNames: {
    parameters: {
      query: {
        /**
         * Only include external tasks that are currently locked (i.e., they have a lock time and it has not expired).
         * Value may only be `true`, as `false` matches any external task.
         */
        withLockedTasks?: boolean;
        /**
         * Only include external tasks that are currently not locked (i.e., they have no lock or it has expired).
         * Value may only be `true`, as `false` matches any external task.
         */
        withUnlockedTasks?: boolean;
        /**
         * Only include external tasks that have a positive (&gt; 0) number of retries (or `null`). Value may only be
         * `true`, as `false` matches any external task.
         */
        withRetriesLeft?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": string[];
        };
      };
      /** Returned if some of the query parameters are invalid. */
      400: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
    };
  };
  /** Retrieves an external task by id, corresponding to the `ExternalTask` interface in the engine. */
  getExternalTask: {
    parameters: {
      path: {
        /** The id of the external task to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ExternalTaskDto"];
        };
      };
      /**
       * External task with the given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Reports a business error in the context of a running external task by id. The error code must be specified
   * to identify the BPMN error handler.
   */
  handleExternalTaskBpmnError: {
    parameters: {
      path: {
        /** The id of the external task in which context a BPMN error is reported. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the task's most recent lock was not acquired by the provided worker.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the corresponding process instance could not be resumed successfully.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExternalTaskBpmnError"];
      };
    };
  };
  /** Completes an external task by id and updates process variables. */
  completeExternalTaskResource: {
    parameters: {
      path: {
        /** The id of the task to complete. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the task's most recent lock was not acquired by the provided worker. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the corresponding process instance could not be resumed successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CompleteExternalTaskDto"];
      };
    };
  };
  /** Retrieves the error details in the context of a running external task by id. */
  getExternalTaskErrorDetails: {
    parameters: {
      path: {
        /** The id of the external task for which the error details should be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "text/plain": string;
        };
      };
      /** Request successful. In case the external task has no error details. */
      204: never;
      /**
       * An external task with the given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Extends the timeout of the lock by a given amount of time. */
  extendLock: {
    parameters: {
      path: {
        /** The id of the external task. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * In case the new lock duration is negative or the external task is not locked by the given worker or not
       * locked at all, an exception of type `InvalidRequestException` is returned. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExtendLockOnExternalTaskDto"];
      };
    };
  };
  /**
   * Reports a failure to execute an external task by id. A number of retries and a timeout until the task can
   * be retried can be specified. If retries are set to 0, an incident for this task is created.
   */
  handleFailure: {
    parameters: {
      path: {
        /** The id of the external task to report a failure for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the task's most recent lock was not acquired by the provided worker. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the corresponding process instance could not be resumed successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ExternalTaskFailureDto"];
      };
    };
  };
  /** Lock an external task by a given id for a specified worker and amount of time. */
  lock: {
    parameters: {
      path: {
        /** The id of the external task. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * In case the lock duration is negative or the external task is already locked by
       * a different worker, an exception of type `InvalidRequestException` is returned. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["LockExternalTaskDto"];
      };
    };
  };
  /** Sets the priority of an existing external task by id. The default value of a priority is 0. */
  setExternalTaskResourcePriority: {
    parameters: {
      path: {
        /** The id of the external task to set the priority for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PriorityDto"];
      };
    };
  };
  /**
   * Sets the number of retries left to execute an external task by id. If retries are set to 0, an
   * incident is created.
   */
  setExternalTaskResourceRetries: {
    parameters: {
      path: {
        /** The id of the external task to set the number of retries for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case the number of retries is negative or null, an exception of type `InvalidRequestException`
       * is returned. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["RetriesDto"];
      };
    };
  };
  /** Unlocks an external task by id. Clears the task's lock expiration time and worker id. */
  unlock: {
    parameters: {
      path: {
        /** The id of the external task to unlock. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the task does not exist. This could indicate a wrong task id as well as a cancelled task,
       * e.g., due to a caught BPMN boundary event. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for a list of groups using a list of parameters. The size of the result set can be retrieved
   * by using the [Get Group Count](https://docs.camunda.org/manual/latest/reference/rest/group/get-query-count) method.
   */
  getQueryGroups: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "id" | "name" | "type";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by the id of the group. */
        id?: string;
        /** Filter by a comma seperated list of group ids. */
        idIn?: string;
        /** Filter by the name of the group. */
        name?: string;
        /** Filter by the name that the parameter is a substring of. */
        nameLike?: string;
        /** Filter by the type of the group. */
        type?: string;
        /** Only retrieve groups where the given user id is a member of. */
        member?: string;
        /** Only retrieve groups which are members of the given tenant. */
        memberOfTenant?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["GroupDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy` is specified. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for a list of groups using a list of parameters.
   * The size of the result set can be retrieved by using the
   * [Get Group Count (POST)](https://docs.camunda.org/manual/latest/reference/rest/group/post-query-count/) method.
   */
  postQueryGroups: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["GroupDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy` is specified. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["GroupQueryDto"];
      };
    };
  };
  /**
   * The `/group` resource supports two custom OPTIONS requests, this one for the resource as such and one for
   * individual group instances. The OPTIONS request allows checking for the set of available operations that
   * the currently authenticated user can perform on the `/group` resource. If the user can perform an operation
   * or not may depend on various things, including the users authorizations to interact with this resource and
   * the internal configuration of the process engine.
   */
  availableGroupOperations: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /** Queries for groups using a list of parameters and retrieves the count. */
  getGroupCount: {
    parameters: {
      query: {
        /** Filter by the id of the group. */
        id?: string;
        /** Filter by a comma seperated list of group ids. */
        idIn?: string;
        /** Filter by the name of the group. */
        name?: string;
        /** Filter by the name that the parameter is a substring of. */
        nameLike?: string;
        /** Filter by the type of the group. */
        type?: string;
        /** Only retrieve groups where the given user id is a member of. */
        member?: string;
        /** Only retrieve groups which are members of the given tenant. */
        memberOfTenant?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response
       * format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Queries for groups using a list of parameters and retrieves the count. */
  queryGroupCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response
       * format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["GroupQueryDto"];
      };
    };
  };
  /** Creates a new group. */
  createGroup: {
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The group could not be created due to an internal server error. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the
       * error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["GroupDto"];
      };
    };
  };
  /** Retrieves a group by id. */
  getGroup: {
    parameters: {
      path: {
        /** The id of the group to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["GroupDto"];
        };
      };
      /**
       * Group with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Updates a given group by id. */
  updateGroup: {
    parameters: {
      path: {
        /** The id of the group. */
        id: string;
      };
    };
    responses: {
      /** Request successful. No content. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** If the group with the requested Id cannot be found. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The group could not be updated due to an internal server error.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error
       * response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["GroupDto"];
      };
    };
  };
  /** Deletes a group by id. */
  deleteGroup: {
    parameters: {
      path: {
        /** The id of the group to be deleted. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Group cannot be found. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for
       * the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * The `/group` resource supports two custom OPTIONS requests, one for the resource as such and this one for individual group instances.
   * The OPTIONS request allows checking for the set of available operations that the currently authenticated user can perform on the
   * `/group/{id}` resource instance. If the user can perform an operation or not may depend on various things, including the users authorizations
   * to interact with this resource and the internal configuration of the process engine.
   */
  availableGroupInstanceOperations: {
    parameters: {
      path: {
        /** The id of the group. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /**
   * The OPTIONS request allows checking for the set of available operations that the currently authenticated
   * user can perform on the resource. If the user can perform an operation or not may depend on various
   * things, including the users authorizations to interact with this resource and the internal configuration
   * of the process engine.
   */
  availableGroupMembersOperations: {
    parameters: {
      path: {
        /** The id of the group. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /** Adds a member to a group. */
  createGroupMember: {
    parameters: {
      path: {
        /** The id of the group. */
        id: string;
        /** The id of user to add to the group. */
        userId: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case an internal error occurs. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Removes a member from a group. */
  deleteGroupMember: {
    parameters: {
      path: {
        /** The id of the group. */
        id: string;
        /** The id of user to remove from the group. */
        userId: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case an error occurs. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for historic activity instances that fulfill the given parameters.
   * The size of the result set can be retrieved by using the
   * [Get Historic Activity Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/activity-instance/get-activity-instance-query-count/) method.
   */
  getHistoricActivityInstances: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "activityInstanceId"
          | "instanceId"
          | "executionId"
          | "activityId"
          | "activityName"
          | "activityType"
          | "startTime"
          | "endTime"
          | "duration"
          | "definitionId"
          | "occurrence"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by activity instance id. */
        activityInstanceId?: string;
        /** Filter by process instance id. */
        processInstanceId?: string;
        /** Filter by process definition id. */
        processDefinitionId?: string;
        /** Filter by the id of the execution that executed the activity instance. */
        executionId?: string;
        /** Filter by the activity id (according to BPMN 2.0 XML). */
        activityId?: string;
        /** Filter by the activity name (according to BPMN 2.0 XML). */
        activityName?: string;
        /** Filter by activity type. */
        activityType?: string;
        /** Only include activity instances that are user tasks and assigned to a given user. */
        taskAssignee?: string;
        /**
         * Only include finished activity instances.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        finished?: boolean;
        /**
         * Only include unfinished activity instances.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        unfinished?: boolean;
        /**
         * Only include canceled activity instances.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        canceled?: boolean;
        /**
         * Only include activity instances which completed a scope.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        completeScope?: boolean;
        /**
         * Restrict to instances that were started before the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedBefore?: string;
        /**
         * Restrict to instances that were started after the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedAfter?: string;
        /**
         * Restrict to instances that were finished before the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedBefore?: string;
        /**
         * Restrict to instances that were finished after the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedAfter?: string;
        /** Filter by a comma-separated list of ids. An activity instance must have one of the given tenant ids. */
        tenantIdIn?: string;
        /** Only include historic activity instances that belong to no tenant. Value may only be `true`, as `false` is the default behavior. */
        withoutTenantId?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["HistoricActivityInstanceDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if a sortOrder parameter is supplied, but no sortBy.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for historic activity instances that fulfill the given parameters.
   * The size of the result set can be retrieved by using the
   * [Get Historic Activity Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/activity-instance/get-activity-instance-query-count/) method.
   */
  queryHistoricActivityInstances: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["HistoricActivityInstanceDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if a sortOrder parameter is supplied, but no sortBy.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoricActivityInstanceQueryDto"];
      };
    };
  };
  /**
   * Queries for the number of historic activity instances that fulfill the given parameters.
   * Takes the same parameters as the [Get Historic Activity Instance](https://docs.camunda.org/manual/latest/reference/rest/history/activity-instance/get-activity-instance-query/)  method.
   */
  getHistoricActivityInstancesCount: {
    parameters: {
      query: {
        /** Filter by activity instance id. */
        activityInstanceId?: string;
        /** Filter by process instance id. */
        processInstanceId?: string;
        /** Filter by process definition id. */
        processDefinitionId?: string;
        /** Filter by the id of the execution that executed the activity instance. */
        executionId?: string;
        /** Filter by the activity id (according to BPMN 2.0 XML). */
        activityId?: string;
        /** Filter by the activity name (according to BPMN 2.0 XML). */
        activityName?: string;
        /** Filter by activity type. */
        activityType?: string;
        /** Only include activity instances that are user tasks and assigned to a given user. */
        taskAssignee?: string;
        /**
         * Only include finished activity instances.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        finished?: boolean;
        /**
         * Only include unfinished activity instances.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        unfinished?: boolean;
        /**
         * Only include canceled activity instances.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        canceled?: boolean;
        /**
         * Only include activity instances which completed a scope.
         * Value may only be `true`, as `false` behaves the same as when the property is not set.
         */
        completeScope?: boolean;
        /**
         * Restrict to instances that were started before the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedBefore?: string;
        /**
         * Restrict to instances that were started after the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedAfter?: string;
        /**
         * Restrict to instances that were finished before the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedBefore?: string;
        /**
         * Restrict to instances that were finished after the given date. By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/),
         * the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedAfter?: string;
        /** Filter by a comma-separated list of ids. An activity instance must have one of the given tenant ids. */
        tenantIdIn?: string;
        /** Only include historic activity instances that belong to no tenant. Value may only be `true`, as `false` is the default behavior. */
        withoutTenantId?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Queries for the number of historic activity instances that fulfill the given parameters. */
  queryHistoricActivityInstancesCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoricActivityInstanceQueryDto"];
      };
    };
  };
  /** Retrieves a historic activity instance by id, according to the `HistoricActivityInstance` interface in the engine. */
  getHistoricActivityInstance: {
    parameters: {
      path: {
        /** The id of the historic activity instance to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["HistoricActivityInstanceDto"];
        };
      };
      /**
       * Not Found
       * Historic activity instance with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for historic process instances that fulfill the given parameters.
   * The size of the result set can be retrieved by using the
   * [Get Process Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query-count/) method.
   */
  getHistoricProcessInstances: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "instanceId"
          | "definitionId"
          | "definitionKey"
          | "definitionName"
          | "definitionVersion"
          | "businessKey"
          | "startTime"
          | "endTime"
          | "duration"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by process instance id. */
        processInstanceId?: string;
        /** Filter by process instance ids. Filter by a comma-separated list of `Strings`. */
        processInstanceIds?: string;
        /** Filter by the process definition the instances run on. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the instances run on. */
        processDefinitionKey?: string;
        /** Filter by a list of process definition keys. A process instance must have one of the given process definition keys. Filter by a comma-separated list of `Strings`. */
        processDefinitionKeyIn?: string;
        /** Filter by the name of the process definition the instances run on. */
        processDefinitionName?: string;
        /** Filter by process definition names that the parameter is a substring of. */
        processDefinitionNameLike?: string;
        /** Exclude instances that belong to a set of process definitions. Filter by a comma-separated list of `Strings`. */
        processDefinitionKeyNotIn?: string;
        /** Filter by process instance business key. */
        processInstanceBusinessKey?: string;
        /** Filter by process instance business key that the parameter is a substring of. */
        processInstanceBusinessKeyLike?: string;
        /** Restrict the query to all process instances that are top level process instances. */
        rootProcessInstances?: boolean;
        /**
         * Only include finished process instances. This flag includes all process instances
         * that are completed or terminated. Value may only be `true`, as `false` is the default behavior.
         */
        finished?: boolean;
        /** Only include unfinished process instances. Value may only be `true`, as `false` is the default behavior. */
        unfinished?: boolean;
        /** Only include process instances which have an incident. Value may only be `true`, as `false` is the default behavior. */
        withIncidents?: boolean;
        /** Only include process instances which have a root incident. Value may only be `true`, as `false` is the default behavior. */
        withRootIncidents?: boolean;
        /** Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident types. */
        incidentType?: string;
        /** Only include process instances which have an incident in status either open or resolved. To get all process instances, use the query parameter withIncidents. */
        incidentStatus?: "open" | "resolved";
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /**
         * Restrict to instances that were started before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedBefore?: string;
        /**
         * Restrict to instances that were started after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedAfter?: string;
        /**
         * Restrict to instances that were finished before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedBefore?: string;
        /**
         * Restrict to instances that were finished after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedAfter?: string;
        /**
         * Restrict to instances that executed an activity after the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedActivityAfter?: string;
        /**
         * Restrict to instances that executed an activity before the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedActivityBefore?: string;
        /**
         * Restrict to instances that executed an job after the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedJobAfter?: string;
        /**
         * Restrict to instances that executed an job before the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedJobBefore?: string;
        /** Only include process instances that were started by the given user. */
        startedBy?: string;
        /** Restrict query to all process instances that are sub process instances of the given process instance. Takes a process instance id. */
        superProcessInstanceId?: string;
        /** Restrict query to one process instance that has a sub process instance with the given id. */
        subProcessInstanceId?: string;
        /** Restrict query to all process instances that are sub process instances of the given case instance. Takes a case instance id. */
        superCaseInstanceId?: string;
        /** Restrict query to one process instance that has a sub case instance with the given id. */
        subCaseInstanceId?: string;
        /** Restrict query to all process instances that are sub process instances of the given case instance. Takes a case instance id. */
        caseInstanceId?: string;
        /** Filter by a list of tenant ids. A process instance must have one of the given tenant ids. Filter by a comma-separated list of `Strings` */
        tenantIdIn?: string;
        /** Only include historic process instances which belong to no tenant. Value may only be `true`, as `false` is the default behavior. */
        withoutTenantId?: boolean;
        /** Restrict to instances that executed an activity with one of given ids. Filter by a comma-separated list of `Strings` */
        executedActivityIdIn?: string;
        /** Restrict to instances that have an active activity with one of given ids. Filter by a comma-separated list of `Strings` */
        activeActivityIdIn?: string;
        /** Restrict to instances that are active. */
        active?: boolean;
        /** Restrict to instances that are suspended. */
        suspended?: boolean;
        /** Restrict to instances that are completed. */
        completed?: boolean;
        /** Restrict to instances that are externallyTerminated. */
        externallyTerminated?: boolean;
        /** Restrict to instances that are internallyTerminated. */
        internallyTerminated?: boolean;
        /**
         * Only include process instances that have/had variables with certain values.
         * Variable filtering expressions are comma-separated and are structured as follows:
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name, `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note:** Values are always treated as String objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` - greater than; `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or equal to; `like`.
         *
         * Key and value may not contain underscore or comma characters.
         */
        variables?: string;
        /** Match all variable names provided in variables case-insensitively. If set to `true` variableName and variablename are treated as equal. */
        variableNamesIgnoreCase?: boolean;
        /** Match all variable values provided in variables case-insensitively. If set to `true` variableValue and variablevalue are treated as equal. */
        variableValuesIgnoreCase?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["HistoricProcessInstanceDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if a sortOrder parameter is supplied, but no sortBy.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for historic process instances that fulfill the given parameters.
   * This method is slightly more powerful than the
   * [Get Process Instance](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query/)
   * because it allows filtering by multiple process variables of types `String`, `Number` or `Boolean`.
   */
  queryHistoricProcessInstances: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["HistoricProcessInstanceDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if a sortOrder parameter is supplied, but no sortBy.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoricProcessInstanceQueryDto"];
      };
    };
  };
  /**
   * Queries for the number of historic process instances that fulfill the given parameters.
   * Takes the same parameters as the [Get Process Instances](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query/) method.
   */
  getHistoricProcessInstancesCount: {
    parameters: {
      query: {
        /** Filter by process instance id. */
        processInstanceId?: string;
        /** Filter by process instance ids. Filter by a comma-separated list of `Strings`. */
        processInstanceIds?: string;
        /** Filter by the process definition the instances run on. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the instances run on. */
        processDefinitionKey?: string;
        /** Filter by a list of process definition keys. A process instance must have one of the given process definition keys. Filter by a comma-separated list of `Strings`. */
        processDefinitionKeyIn?: string;
        /** Filter by the name of the process definition the instances run on. */
        processDefinitionName?: string;
        /** Filter by process definition names that the parameter is a substring of. */
        processDefinitionNameLike?: string;
        /** Exclude instances that belong to a set of process definitions. Filter by a comma-separated list of `Strings`. */
        processDefinitionKeyNotIn?: string;
        /** Filter by process instance business key. */
        processInstanceBusinessKey?: string;
        /** Filter by process instance business key that the parameter is a substring of. */
        processInstanceBusinessKeyLike?: string;
        /** Restrict the query to all process instances that are top level process instances. */
        rootProcessInstances?: boolean;
        /**
         * Only include finished process instances. This flag includes all process instances
         * that are completed or terminated. Value may only be `true`, as `false` is the default behavior.
         */
        finished?: boolean;
        /** Only include unfinished process instances. Value may only be `true`, as `false` is the default behavior. */
        unfinished?: boolean;
        /** Only include process instances which have an incident. Value may only be `true`, as `false` is the default behavior. */
        withIncidents?: boolean;
        /** Only include process instances which have a root incident. Value may only be `true`, as `false` is the default behavior. */
        withRootIncidents?: boolean;
        /** Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident types. */
        incidentType?: string;
        /** Only include process instances which have an incident in status either open or resolved. To get all process instances, use the query parameter withIncidents. */
        incidentStatus?: "open" | "resolved";
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /**
         * Restrict to instances that were started before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedBefore?: string;
        /**
         * Restrict to instances that were started after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        startedAfter?: string;
        /**
         * Restrict to instances that were finished before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedBefore?: string;
        /**
         * Restrict to instances that were finished after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        finishedAfter?: string;
        /**
         * Restrict to instances that executed an activity after the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedActivityAfter?: string;
        /**
         * Restrict to instances that executed an activity before the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedActivityBefore?: string;
        /**
         * Restrict to instances that executed an job after the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedJobAfter?: string;
        /**
         * Restrict to instances that executed an job before the given date (inclusive).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        executedJobBefore?: string;
        /** Only include process instances that were started by the given user. */
        startedBy?: string;
        /** Restrict query to all process instances that are sub process instances of the given process instance. Takes a process instance id. */
        superProcessInstanceId?: string;
        /** Restrict query to one process instance that has a sub process instance with the given id. */
        subProcessInstanceId?: string;
        /** Restrict query to all process instances that are sub process instances of the given case instance. Takes a case instance id. */
        superCaseInstanceId?: string;
        /** Restrict query to one process instance that has a sub case instance with the given id. */
        subCaseInstanceId?: string;
        /** Restrict query to all process instances that are sub process instances of the given case instance. Takes a case instance id. */
        caseInstanceId?: string;
        /** Filter by a list of tenant ids. A process instance must have one of the given tenant ids. Filter by a comma-separated list of `Strings` */
        tenantIdIn?: string;
        /** Only include historic process instances which belong to no tenant. Value may only be `true`, as `false` is the default behavior. */
        withoutTenantId?: boolean;
        /** Restrict to instances that executed an activity with one of given ids. Filter by a comma-separated list of `Strings` */
        executedActivityIdIn?: string;
        /** Restrict to instances that have an active activity with one of given ids. Filter by a comma-separated list of `Strings` */
        activeActivityIdIn?: string;
        /** Restrict to instances that are active. */
        active?: boolean;
        /** Restrict to instances that are suspended. */
        suspended?: boolean;
        /** Restrict to instances that are completed. */
        completed?: boolean;
        /** Restrict to instances that are externallyTerminated. */
        externallyTerminated?: boolean;
        /** Restrict to instances that are internallyTerminated. */
        internallyTerminated?: boolean;
        /**
         * Only include process instances that have/had variables with certain values.
         * Variable filtering expressions are comma-separated and are structured as follows:
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name, `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note:** Values are always treated as String objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` - greater than; `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or equal to; `like`.
         *
         * Key and value may not contain underscore or comma characters.
         */
        variables?: string;
        /** Match all variable names provided in variables case-insensitively. If set to `true` variableName and variablename are treated as equal. */
        variableNamesIgnoreCase?: boolean;
        /** Match all variable values provided in variables case-insensitively. If set to `true` variableValue and variablevalue are treated as equal. */
        variableValuesIgnoreCase?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of historic process instances that fulfill the given parameters.
   * This method takes the same message body as the [Get Process Instances (POST)](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/get-process-instance-query/) method and
   * therefore it is slightly more powerful than the [Get Process Instance Count](https://docs.camunda.org/manual/latest/reference/rest/history/process-instance/post-process-instance-query-count/) method.
   */
  queryHistoricProcessInstancesCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoricProcessInstanceQueryDto"];
      };
    };
  };
  /**
   * Delete multiple historic process instances asynchronously (batch).
   * At least `historicProcessInstanceIds` or `historicProcessInstanceQuery` has to be provided.
   * If both are provided then all instances matching query criterion and instances from the list will be deleted.
   */
  deleteHistoricProcessInstancesAsync: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, i.e. neither historicProcessInstanceIds,
       * nor historicProcessInstanceQuery is present. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["DeleteHistoricProcessInstancesDto"];
      };
    };
  };
  /**
   * Retrieves a report about the duration of completed process instances, grouped by a period.
   * These reports include the maximum, minimum and average duration of all completed process instances which were started in a given period.
   *
   * **Note:** This only includes historic data.
   */
  getHistoricProcessInstanceDurationReport: {
    parameters: {
      query: {
        /**
         * **Mandatory.** Specifies the type of the report to retrieve.
         * To retrieve a report about the duration of process instances, the value must be set to `duration`.
         */
        reportType: string;
        /** **Mandatory.** Specifies the granularity of the report. Valid values are `month` and `quarter`. */
        periodUnit: "month" | "quarter";
        /** Filter by process definition ids. Must be a comma-separated list of process definition ids. */
        processDefinitionIdIn?: string;
        /** Filter by process definition keys. Must be a comma-separated list of process definition keys. */
        processDefinitionKeyIn?: string;
        /**
         * Restrict to instances that were started before the given date.
         * By [default](), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2016-01-23T14:42:45.000+0200`.
         */
        startedBefore?: string;
        /**
         * Restrict to instances that were started after the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2016-01-23T14:42:45.000+0200`.
         */
        startedAfter?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["DurationReportResultDto"][];
          "application/csv": { [key: string]: any };
          "text/csv": { [key: string]: any };
        };
      };
      /**
       * Returned if some of the query parameters are invalid or mandatory parameters are not supplied.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * If the authenticated user is unauthorized to read the history.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Sets the removal time to multiple historic process instances asynchronously (batch).
   *
   * At least `historicProcessInstanceIds` or `historicProcessInstanceQuery` has to be provided.
   * If both are provided, all instances matching query criterion and instances from the list will be updated with a removal time.
   */
  setRemovalTimeAsync: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * Request was unsuccessfull due to a bad user request. This occurs if some of the query parameters are invalid,
       * e. g. if neither `historicProcessInstances` nor `historicProcessInstanceQuery` is present or if no mode is specified.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetRemovalTimeToHistoricProcessInstancesDto"];
      };
    };
  };
  /** Retrieves a historic process instance by id, according to the `HistoricProcessInstance` interface in the engine. */
  getHistoricProcessInstance: {
    parameters: {
      path: {
        /** The id of the historic process instance to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["HistoricProcessInstanceDto"];
        };
      };
      /**
       * Not Found
       * Historic process instance with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes a process instance from the history by id. */
  deleteHistoricProcessInstance: {
    parameters: {
      path: {
        /** The id of the historic process instance to be deleted. */
        id: string;
      };
      query: {
        /** If set to `false`, the request will still be successful if the process id is not found. */
        failIfNotExists?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Not found
       * Historic process instance with given id does not exist.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes all variables of a process instance from the history by id. */
  deleteHistoricVariableInstancesOfHistoricProcessInstance: {
    parameters: {
      path: {
        /** The id of the process instance for which all historic variables are to be deleted. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Not found
       * Historic process instance with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#parse-exceptions) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Gets the groups of a user by id and includes all users that share a group with the
   * given user.
   */
  getGroupInfo: {
    parameters: {
      query: {
        /** The id of the user to get the groups for. */
        userId: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["IdentityServiceGroupInfoDto"];
        };
      };
      /**
       * If the `userId` query parameter is missing. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * A password policy consists of a list of rules that new passwords must follow to be
   * policy compliant. This end point returns a JSON representation of the
   * list of policy rules. More information on password policies in Camunda can be found in the password policy
   * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/password-policy/) and in
   * the [security instructions](https://docs.camunda.org/manual/latest/user-guide/security/).
   */
  getPasswordPolicy: {
    responses: {
      /**
       * Request successful. This example uses the built-in password policy that enforces a minimum password length,
       * and some complexity rules.
       */
      200: {
        content: {
          "application/json": components["schemas"]["PasswordPolicyDto"];
        };
      };
      /** No password policy was found. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * A password policy consists of a list of rules that new passwords must follow to be
   * policy compliant. A password can be checked for compliancy via this
   * end point. More information on password policies in Camunda can be found in the password policy
   * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/password-policy/) and in
   * the [security instructions](https://docs.camunda.org/manual/latest/user-guide/security/).
   */
  checkPassword: {
    responses: {
      /**
       * Request successful. This example uses the built-in password policy that enforces a minimum password length, and
       * some complexity rules. The checked password is myPassword which is not complex enough to match all of
       * the policy rules.
       */
      200: {
        content: {
          "application/json": components["schemas"]["CheckPasswordPolicyResultDto"];
        };
      };
      /** No password policy was found to check the password against. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PasswordPolicyRequestDto"];
      };
    };
  };
  /** Verifies that user credentials are valid. */
  verifyUser: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["AuthenticationResult"];
        };
      };
      /** If body does not contain username or password. */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["BasicUserCredentialsDto"];
      };
    };
  };
  /**
   * Queries for incidents that fulfill given parameters. The size of the result set can be retrieved by using
   * the [Get Incident Count](https://docs.camunda.org/manual/latest/reference/rest/incident/get-query-count/) method.
   */
  getIncidents: {
    parameters: {
      query: {
        /** Restricts to incidents that have the given id. */
        incidentId?: string;
        /**
         * Restricts to incidents that belong to the given incident type. See the
         * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident
         * types.
         */
        incidentType?: string;
        /** Restricts to incidents that have the given incident message. */
        incidentMessage?: string;
        /**
         * Restricts to incidents that incidents message is a substring of the given value. The string can include
         * the wildcard character '%' to express like-strategy: starts with (`string%`), ends with (`%string`) or
         * contains (`%string%`).
         */
        incidentMessageLike?: string;
        /** Restricts to incidents that belong to a process definition with the given id. */
        processDefinitionId?: string;
        /**
         * Restricts to incidents that belong to a process definition with the given keys. Must be a
         * comma-separated list.
         */
        processDefinitionKeyIn?: string;
        /** Restricts to incidents that belong to a process instance with the given id. */
        processInstanceId?: string;
        /** Restricts to incidents that belong to an execution with the given id. */
        executionId?: string;
        /**
         * Restricts to incidents that have an incidentTimestamp date before the given date. By default, the date
         * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        incidentTimestampBefore?: string;
        /**
         * Restricts to incidents that have an incidentTimestamp date after the given date. By default*, the date
         * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        incidentTimestampAfter?: string;
        /** Restricts to incidents that belong to an activity with the given id. */
        activityId?: string;
        /** Restricts to incidents that were created due to the failure of an activity with the given id. */
        failedActivityId?: string;
        /** Restricts to incidents that have the given incident id as cause incident. */
        causeIncidentId?: string;
        /** Restricts to incidents that have the given incident id as root cause incident. */
        rootCauseIncidentId?: string;
        /** Restricts to incidents that have the given parameter set as configuration. */
        configuration?: string;
        /** Restricts to incidents that have one of the given comma-separated tenant ids. */
        tenantIdIn?: string;
        /** Restricts to incidents that have one of the given comma-separated job definition ids. */
        jobDefinitionIdIn?: string;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "incidentId"
          | "incidentMessage"
          | "incidentTimestamp"
          | "incidentType"
          | "executionId"
          | "activityId"
          | "processInstanceId"
          | "processDefinitionId"
          | "causeIncidentId"
          | "rootCauseIncidentId"
          | "configuration"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["IncidentDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy`. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error
       * response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of incidents that fulfill given parameters. Takes the same parameters as the
   * [Get Incidents](https://docs.camunda.org/manual/latest/reference/rest/incident/get-query/) method.
   */
  getIncidentsCount: {
    parameters: {
      query: {
        /** Restricts to incidents that have the given id. */
        incidentId?: string;
        /**
         * Restricts to incidents that belong to the given incident type. See the
         * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) for a list of incident
         * types.
         */
        incidentType?: string;
        /** Restricts to incidents that have the given incident message. */
        incidentMessage?: string;
        /**
         * Restricts to incidents that incidents message is a substring of the given value. The string can include
         * the wildcard character '%' to express like-strategy: starts with (`string%`), ends with (`%string`) or
         * contains (`%string%`).
         */
        incidentMessageLike?: string;
        /** Restricts to incidents that belong to a process definition with the given id. */
        processDefinitionId?: string;
        /**
         * Restricts to incidents that belong to a process definition with the given keys. Must be a
         * comma-separated list.
         */
        processDefinitionKeyIn?: string;
        /** Restricts to incidents that belong to a process instance with the given id. */
        processInstanceId?: string;
        /** Restricts to incidents that belong to an execution with the given id. */
        executionId?: string;
        /**
         * Restricts to incidents that have an incidentTimestamp date before the given date. By default, the date
         * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        incidentTimestampBefore?: string;
        /**
         * Restricts to incidents that have an incidentTimestamp date after the given date. By default*, the date
         * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.000+0200`.
         */
        incidentTimestampAfter?: string;
        /** Restricts to incidents that belong to an activity with the given id. */
        activityId?: string;
        /** Restricts to incidents that were created due to the failure of an activity with the given id. */
        failedActivityId?: string;
        /** Restricts to incidents that have the given incident id as cause incident. */
        causeIncidentId?: string;
        /** Restricts to incidents that have the given incident id as root cause incident. */
        rootCauseIncidentId?: string;
        /** Restricts to incidents that have the given parameter set as configuration. */
        configuration?: string;
        /** Restricts to incidents that have one of the given comma-separated tenant ids. */
        tenantIdIn?: string;
        /** Restricts to incidents that have one of the given comma-separated job definition ids. */
        jobDefinitionIdIn?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error
       * response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves an incident by ID. */
  getIncident: {
    parameters: {
      path: {
        /** The id of the incident to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["IncidentDto"];
        };
      };
      /** Returned if an incident with given id does not exist. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Resolves an incident with given id. */
  resolveIncident: {
    parameters: {
      path: {
        /** The id of the incident to be resolved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if an incident is not related to any execution or an incident is of type `failedJob` or
       * `failedExternalTask`. To resolve such an incident, please refer to the
       * [Incident Types](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types) section.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** Returned if an incident with given id does not exist. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Sets the annotation of an incident with given id. */
  setIncidentAnnotation: {
    parameters: {
      path: {
        /** The id of the incident to clear the annotation at. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** Returned if no incident can be found for the given id. */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["AnnotationDto"];
      };
    };
  };
  /** Clears the annotation of an incident with given id. */
  clearIncidentAnnotation: {
    parameters: {
      path: {
        /** The id of the incident to clear the annotation at. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** Returned if no incident can be found for the given id. */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for jobs that fulfill given parameters.
   * The size of the result set can be retrieved by using the [Get Job
   * Count](https://docs.camunda.org/manual/latest/reference/rest/job/get-query-count/) method.
   */
  getJobs: {
    parameters: {
      query: {
        /** Filter by job id. */
        jobId?: string;
        /** Filter by a comma-separated list of job ids. */
        jobIds?: string;
        /** Only select jobs which exist for the given job definition. */
        jobDefinitionId?: string;
        /** Only select jobs which exist for the given process instance. */
        processInstanceId?: string;
        /** Only select jobs which exist for the given comma-separated list of process instance ids. */
        processInstanceIds?: string;
        /** Only select jobs which exist for the given execution. */
        executionId?: string;
        /** Filter by the id of the process definition the jobs run on. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the jobs run on. */
        processDefinitionKey?: string;
        /** Only select jobs which exist for an activity with the given id. */
        activityId?: string;
        /**
         * Only select jobs which have retries left. Value may only be `true`, as `false` is the
         * default behavior.
         */
        withRetriesLeft?: boolean;
        /**
         * Only select jobs which are executable, i.e., retries > 0 and due date is `null` or due
         * date is in the past. Value may only be `true`, as `false` is the default
         * behavior.
         */
        executable?: boolean;
        /**
         * Only select jobs that are timers. Cannot be used together with `messages`. Value may only
         * be `true`, as `false` is the default behavior.
         */
        timers?: boolean;
        /**
         * Only select jobs that are messages. Cannot be used together with `timers`. Value may only
         * be `true`, as `false` is the default behavior.
         */
        messages?: boolean;
        /**
         * Only select jobs where the due date is lower or higher than the given date.
         * Due date expressions are comma-separated and are structured as follows:
         *
         * A valid condition value has the form `operator_value`.
         * `operator` is the comparison operator to be used and `value` the date value
         * as string.
         *
         * Valid operator values are: `gt` - greater than; `lt` - lower than.
         * `value` may not contain underscore or comma characters.
         */
        dueDates?: string;
        /**
         * Only select jobs created before or after the given date.
         *
         * Create time expressions are comma-separated and are structured as
         * follows:
         *
         * A valid condition value has the form `operator_value`.
         * `operator` is the comparison operator to be used and `value` the date value
         * as string.
         *
         * Valid operator values are: `gt` - greater than; `lt` - lower than.
         * `value` may not contain underscore or comma characters.
         */
        createTimes?: string;
        /**
         * Only select jobs that failed due to an exception. Value may only be `true`, as `false` is
         * the default behavior.
         */
        withException?: boolean;
        /** Only select jobs that failed due to an exception with the given message. */
        exceptionMessage?: string;
        /** Only select jobs that failed due to an exception at an activity with the given id. */
        failedActivityId?: string;
        /**
         * Only select jobs which have no retries left. Value may only be `true`, as `false` is the
         * default behavior.
         */
        noRetriesLeft?: boolean;
        /** Only include active jobs. Value may only be `true`, as `false` is the default behavior. */
        active?: boolean;
        /** Only include suspended jobs. Value may only be `true`, as `false` is the default behavior. */
        suspended?: boolean;
        /**
         * Only include jobs with a priority lower than or equal to the given value. Value must be a
         * valid `long` value.
         */
        priorityLowerThanOrEquals?: number;
        /**
         * Only include jobs with a priority higher than or equal to the given value. Value must be a
         * valid `long` value.
         */
        priorityHigherThanOrEquals?: number;
        /** Only include jobs which belong to one of the passed comma-separated tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include jobs which belong to no tenant. Value may only be `true`, as `false` is the
         * default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include jobs which belong to no tenant. Can be used in combination with `tenantIdIn`.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeJobsWithoutTenantId?: boolean;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "jobId"
          | "executionId"
          | "processInstanceId"
          | "processDefinitionId"
          | "processDefinitionKey"
          | "jobPriority"
          | "jobRetries"
          | "jobDueDate"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["JobDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator
       * for due date comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for jobs that fulfill given parameters. This method is slightly more
   * powerful than the [Get Jobs](https://docs.camunda.org/manual/latest/reference/rest/job/get-query/)
   * method because it allows filtering by multiple jobs of types `String`,
   * `Number` or `Boolean`.
   */
  queryJobs: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["JobDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator
       * for due date comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["JobQueryDto"];
      };
    };
  };
  /**
   * Queries for the number of jobs that fulfill given parameters.
   * Takes the same parameters as the [Get
   * Jobs](https://docs.camunda.org/manual/latest/reference/rest/job/get-query/) method.
   */
  getJobsCount: {
    parameters: {
      query: {
        /** Filter by job id. */
        jobId?: string;
        /** Filter by a comma-separated list of job ids. */
        jobIds?: string;
        /** Only select jobs which exist for the given job definition. */
        jobDefinitionId?: string;
        /** Only select jobs which exist for the given process instance. */
        processInstanceId?: string;
        /** Only select jobs which exist for the given comma-separated list of process instance ids. */
        processInstanceIds?: string;
        /** Only select jobs which exist for the given execution. */
        executionId?: string;
        /** Filter by the id of the process definition the jobs run on. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the jobs run on. */
        processDefinitionKey?: string;
        /** Only select jobs which exist for an activity with the given id. */
        activityId?: string;
        /**
         * Only select jobs which have retries left. Value may only be `true`, as `false` is the
         * default behavior.
         */
        withRetriesLeft?: boolean;
        /**
         * Only select jobs which are executable, i.e., retries > 0 and due date is `null` or due
         * date is in the past. Value may only be `true`, as `false` is the default
         * behavior.
         */
        executable?: boolean;
        /**
         * Only select jobs that are timers. Cannot be used together with `messages`. Value may only
         * be `true`, as `false` is the default behavior.
         */
        timers?: boolean;
        /**
         * Only select jobs that are messages. Cannot be used together with `timers`. Value may only
         * be `true`, as `false` is the default behavior.
         */
        messages?: boolean;
        /**
         * Only select jobs where the due date is lower or higher than the given date.
         * Due date expressions are comma-separated and are structured as follows:
         *
         * A valid condition value has the form `operator_value`.
         * `operator` is the comparison operator to be used and `value` the date value
         * as string.
         *
         * Valid operator values are: `gt` - greater than; `lt` - lower than.
         * `value` may not contain underscore or comma characters.
         */
        dueDates?: string;
        /**
         * Only select jobs created before or after the given date.
         *
         * Create time expressions are comma-separated and are structured as
         * follows:
         *
         * A valid condition value has the form `operator_value`.
         * `operator` is the comparison operator to be used and `value` the date value
         * as string.
         *
         * Valid operator values are: `gt` - greater than; `lt` - lower than.
         * `value` may not contain underscore or comma characters.
         */
        createTimes?: string;
        /**
         * Only select jobs that failed due to an exception. Value may only be `true`, as `false` is
         * the default behavior.
         */
        withException?: boolean;
        /** Only select jobs that failed due to an exception with the given message. */
        exceptionMessage?: string;
        /** Only select jobs that failed due to an exception at an activity with the given id. */
        failedActivityId?: string;
        /**
         * Only select jobs which have no retries left. Value may only be `true`, as `false` is the
         * default behavior.
         */
        noRetriesLeft?: boolean;
        /** Only include active jobs. Value may only be `true`, as `false` is the default behavior. */
        active?: boolean;
        /** Only include suspended jobs. Value may only be `true`, as `false` is the default behavior. */
        suspended?: boolean;
        /**
         * Only include jobs with a priority lower than or equal to the given value. Value must be a
         * valid `long` value.
         */
        priorityLowerThanOrEquals?: number;
        /**
         * Only include jobs with a priority higher than or equal to the given value. Value must be a
         * valid `long` value.
         */
        priorityHigherThanOrEquals?: number;
        /** Only include jobs which belong to one of the passed comma-separated tenant ids. */
        tenantIdIn?: string;
        /**
         * Only include jobs which belong to no tenant. Value may only be `true`, as `false` is the
         * default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include jobs which belong to no tenant. Can be used in combination with `tenantIdIn`.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeJobsWithoutTenantId?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example, if an invalid operator
       * for due date comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for jobs that fulfill given parameters. This method takes the same message
   * body as the [Get Jobs POST](https://docs.camunda.org/manual/latest/reference/rest/job/post-
   * query/) method and therefore it is slightly more powerful than the
   * [Get Job Count](https://docs.camunda.org/manual/latest/reference/rest/job/get-query-count/)
   * method.
   */
  queryJobsCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example, if an invalid operator
       * for due date comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["JobQueryDto"];
      };
    };
  };
  /** Create a batch to set retries of jobs asynchronously. */
  setJobRetriesAsyncOperation: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if neither
       * processInstanceIds nor processInstanceQuery is present. Or if the
       * retry count is not specified. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetJobRetriesDto"];
      };
    };
  };
  /**
   * Activates or suspends jobs matching the given criterion.
   * This can only be on of:
   * * `jobDefinitionId`
   * * `processDefinitionId`
   * * `processInstanceId`
   * * `processDefinitionKey`
   */
  updateSuspensionStateBy: {
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * Returned if the request parameters are invalid, for example, if `jobDefinitionId` and
       * `processDefinitionId` are both specified.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["JobSuspensionStateDto"];
      };
    };
  };
  /** Retrieves a job by id, according to the `Job` interface in the engine. */
  getJob: {
    parameters: {
      path: {
        /** The id of the job to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["JobDto"];
        };
      };
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Updates the due date of a job by id. */
  setJobDuedate: {
    parameters: {
      path: {
        /** The id of the job to be updated. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The due date could not be set successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["JobDuedateDto"];
      };
    };
  };
  /** Recalculates the due date of a job by id. */
  recalculateDuedate: {
    parameters: {
      path: {
        /** The id of the job to be updated. */
        id: string;
      };
      query: {
        /**
         * Recalculate the due date based on the creation date of the job or the current date.
         * Value may only be `false`, as `true` is the default behavior.
         */
        creationDateBased?: boolean;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The due date could not be recalculated successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Executes a job by id. **Note:** The execution of the job happens synchronously in
   * the same thread.
   */
  executeJob: {
    parameters: {
      path: {
        /** The id of the job to be executed. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The job could not be executed successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Sets the execution priority of a job by id. */
  setJobPriority: {
    parameters: {
      path: {
        /** The id of the job to be updated. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The priority could not be set successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PriorityDto"];
      };
    };
  };
  /** Sets the retries of the job to the given number of retries by id. */
  setJobRetries: {
    parameters: {
      path: {
        /** The id of the job to be updated. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The retries could not be set successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["RetriesDto"];
      };
    };
  };
  /** Retrieves the exception stacktrace corresponding to the passed job id. */
  getStacktrace: {
    parameters: {
      path: {
        /** The id of the job to get the exception stacktrace for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "text/plain": { [key: string]: any };
        };
      };
      /**
       * Job with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Activates or suspends a given job by id. */
  updateJobSuspensionState: {
    parameters: {
      path: {
        /** The id of the job to activate or suspend. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SuspensionStateDto"];
      };
    };
  };
  /**
   * Correlates a message to the process engine to either trigger a message start event or an intermediate message
   * catching event. Internally this maps to the engine's message correlation builder methods
   * `MessageCorrelationBuilder#correlateWithResult()` and `MessageCorrelationBuilder#correlateAllWithResult()`.
   * For more information about the correlation behavior, see the [Message Events](https://docs.camunda.org/manual/latest/bpmn20/events/message-events/)
   * section of the [BPMN 2.0 Implementation Reference](https://docs.camunda.org/manual/latest/reference/bpmn20/).
   */
  deliverMessage: {
    responses: {
      /**
       * Request successful. The property `resultEnabled` in the request body was `true`.
       * The `variables` property is only returned, if the property variablesInResultEnable`
       * was set to `true` in the request.
       */
      200: {
        content: {
          "application/json": components["schemas"]["MessageCorrelationResultWithVariableDto"][];
        };
      };
      /** Request successful. The property `resultEnabled` in the request body was `false` (Default). */
      204: never;
      /**
       * Returned if:
       * * no `messageName` was supplied
       * * both `tenantId` and `withoutTenantId` are supplied
       * * the message has not been correlated to exactly one entity (execution or process definition)
       * * the variable value or type is invalid, for example if the value could not be parsed to an Integer value or the passed variable type is not supported.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CorrelationMessageDto"];
      };
    };
  };
  /** Retrieves a list of metrics, aggregated for a given interval. */
  interval: {
    parameters: {
      query: {
        /** The name of the metric. */
        name?:
          | "activity-instance-start"
          | "activity-instance-end"
          | "job-acquisition-attempt"
          | "job-acquired-success"
          | "job-acquired-failure"
          | "job-execution-rejected"
          | "job-successful"
          | "job-failed"
          | "job-locked-exclusive"
          | "executed-decision-elements"
          | "history-cleanup-removed-process-instances"
          | "history-cleanup-removed-case-instances"
          | "history-cleanup-removed-decision-instances"
          | "history-cleanup-removed-batch-operations"
          | "history-cleanup-removed-task-metrics";
        /**
         * The name of the reporter (host), on which the metrics was logged. This will have
         * value provided by the [hostname configuration property](https://docs.camunda.org/manual/latest/reference/deployment-descriptors/tags/process-engine/#hostname).
         */
        reporter?: string;
        /** The start date (inclusive). */
        startDate?: string;
        /** The end date (exclusive). */
        endDate?: string;
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /**
         * The interval for which the metrics should be aggregated. Time unit is seconds.
         * Default: The interval is set to 15 minutes (900 seconds).
         */
        interval?: string;
        /** Aggregate metrics by reporter. */
        aggregateByReporter?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["MetricsIntervalResultDto"][];
        };
      };
      /** Returned if some of the query parameters are invalid. */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes all task worker metrics prior to the given date or all if no date is provided. */
  deleteTaskMetrics: {
    parameters: {
      query: {
        /** The date prior to which all task worker metrics should be deleted. */
        date?: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** If the user who performs the operation is not a <b>camunda-admin</b> user. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the `sum` (count) for a given metric. */
  getMetrics: {
    parameters: {
      path: {
        /** The name of the metric. */
        "metrics-name":
          | "activity-instance-start"
          | "activity-instance-end"
          | "job-acquisition-attempt"
          | "job-acquired-success"
          | "job-acquired-failure"
          | "job-execution-rejected"
          | "job-successful"
          | "job-failed"
          | "job-locked-exclusive"
          | "executed-decision-elements"
          | "history-cleanup-removed-process-instances"
          | "history-cleanup-removed-case-instances"
          | "history-cleanup-removed-decision-instances"
          | "history-cleanup-removed-batch-operations"
          | "history-cleanup-removed-task-metrics"
          | "unique-task-workers";
      };
      query: {
        /** The start date (inclusive). */
        startDate?: string;
        /** The end date (exclusive). */
        endDate?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["MetricsResultDto"];
        };
      };
    };
  };
  /**
   * Queries for process definitions that fulfill given parameters. Parameters may be the properties of
   * process definitions, such as the name, key or version. The size of the result set can be retrieved
   * by using the [Get Definition Count](https://docs.camunda.org/manual/latest/reference/rest/process-definition/get-query-count/) method.
   */
  getProcessDefinitions: {
    parameters: {
      query: {
        /** Filter by process definition id. */
        processDefinitionId?: string;
        /** Filter by a comma-separated list of process definition ids. */
        processDefinitionIdIn?: string;
        /** Filter by process definition name. */
        name?: string;
        /** Filter by process definition names that the parameter is a substring of. */
        nameLike?: string;
        /** Filter by the deployment the id belongs to. */
        deploymentId?: string;
        /**
         * Filter by the deploy time of the deployment the process definition belongs to.
         * Only selects process definitions that have been deployed after (exclusive) a specific time.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.546+0200`.
         */
        deployedAfter?: string;
        /**
         * Filter by the deploy time of the deployment the process definition belongs to.
         * Only selects process definitions that have been deployed at a specific time (exact match).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.546+0200`.
         */
        deployedAt?: string;
        /** Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. */
        key?: string;
        /** Filter by a comma-separated list of process definition keys. */
        keysIn?: string;
        /** Filter by process definition keys that the parameter is a substring of. */
        keyLike?: string;
        /** Filter by process definition category. Exact match. */
        category?: string;
        /** Filter by process definition categories that the parameter is a substring of. */
        categoryLike?: string;
        /** Filter by process definition version. */
        version?: number;
        /**
         * Only include those process definitions that are latest versions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        latestVersion?: boolean;
        /** Filter by the name of the process definition resource. Exact match. */
        resourceName?: string;
        /** Filter by names of those process definition resources that the parameter is a substring of. */
        resourceNameLike?: string;
        /** Filter by a user name who is allowed to start the process. */
        startableBy?: string;
        /**
         * Only include active process definitions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        active?: boolean;
        /**
         * Only include suspended process definitions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        suspended?: boolean;
        /** Filter by the incident id. */
        incidentId?: string;
        /**
         * Filter by the incident type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentType?: string;
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /**
         * Filter by a comma-separated list of tenant ids.
         * A process definition must have one of the given tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include process definitions which belong to no tenant.
         * Value may only be true, as false is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include process definitions which belong to no tenant. Can be used in combination with `tenantIdIn`.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeProcessDefinitionsWithoutTenantId?: boolean;
        /** Filter by the version tag. */
        versionTag?: string;
        /** Filter by the version tag that the parameter is a substring of. */
        versionTagLike?: string;
        /** Only include process definitions without a `versionTag`. */
        withoutVersionTag?: boolean;
        /** Filter by process definitions which are startable in Tasklist.. */
        startableInTasklist?: boolean;
        /** Filter by process definitions which are not startable in Tasklist. */
        notStartableInTasklist?: boolean;
        /**
         * Filter by process definitions which the user is allowed to start in Tasklist.
         * If the user doesn't have these permissions the result will be empty list.
         * The permissions are:
         * * `CREATE` permission for all Process instances
         * * `CREATE_INSTANCE` and `READ` permission on Process definition level
         */
        startablePermissionCheck?: boolean;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "category"
          | "key"
          | "id"
          | "name"
          | "version"
          | "deploymentId"
          | "deployTime"
          | "tenantId "
          | "versionTag";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy`. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Requests the number of process definitions that fulfill the query criteria.
   * Takes the same filtering parameters as the [Get Definitions](https://docs.camunda.org/manual/latest/reference/rest/process-definition/get-query/) method.
   */
  getProcessDefinitionsCount: {
    parameters: {
      query: {
        /** Filter by process definition id. */
        processDefinitionId?: string;
        /** Filter by a comma-separated list of process definition ids. */
        processDefinitionIdIn?: string;
        /** Filter by process definition name. */
        name?: string;
        /** Filter by process definition names that the parameter is a substring of. */
        nameLike?: string;
        /** Filter by the deployment the id belongs to. */
        deploymentId?: string;
        /**
         * Filter by the deploy time of the deployment the process definition belongs to.
         * Only selects process definitions that have been deployed after (exclusive) a specific time.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.546+0200`.
         */
        deployedAfter?: string;
        /**
         * Filter by the deploy time of the deployment the process definition belongs to.
         * Only selects process definitions that have been deployed at a specific time (exact match).
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.546+0200`.
         */
        deployedAt?: string;
        /** Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. */
        key?: string;
        /** Filter by a comma-separated list of process definition keys. */
        keysIn?: string;
        /** Filter by process definition keys that the parameter is a substring of. */
        keyLike?: string;
        /** Filter by process definition category. Exact match. */
        category?: string;
        /** Filter by process definition categories that the parameter is a substring of. */
        categoryLike?: string;
        /** Filter by process definition version. */
        version?: number;
        /**
         * Only include those process definitions that are latest versions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        latestVersion?: boolean;
        /** Filter by the name of the process definition resource. Exact match. */
        resourceName?: string;
        /** Filter by names of those process definition resources that the parameter is a substring of. */
        resourceNameLike?: string;
        /** Filter by a user name who is allowed to start the process. */
        startableBy?: string;
        /**
         * Only include active process definitions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        active?: boolean;
        /**
         * Only include suspended process definitions.
         * Value may only be `true`, as `false` is the default behavior.
         */
        suspended?: boolean;
        /** Filter by the incident id. */
        incidentId?: string;
        /**
         * Filter by the incident type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentType?: string;
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /**
         * Filter by a comma-separated list of tenant ids.
         * A process definition must have one of the given tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include process definitions which belong to no tenant.
         * Value may only be true, as false is the default behavior.
         */
        withoutTenantId?: boolean;
        /**
         * Include process definitions which belong to no tenant. Can be used in combination with `tenantIdIn`.
         * Value may only be `true`, as `false` is the default behavior.
         */
        includeProcessDefinitionsWithoutTenantId?: boolean;
        /** Filter by the version tag. */
        versionTag?: string;
        /** Filter by the version tag that the parameter is a substring of. */
        versionTagLike?: string;
        /** Only include process definitions without a `versionTag`. */
        withoutVersionTag?: boolean;
        /** Filter by process definitions which are startable in Tasklist.. */
        startableInTasklist?: boolean;
        /** Filter by process definitions which are not startable in Tasklist. */
        notStartableInTasklist?: boolean;
        /**
         * Filter by process definitions which the user is allowed to start in Tasklist.
         * If the user doesn't have these permissions the result will be empty list.
         * The permissions are:
         * * `CREATE` permission for all Process instances
         * * `CREATE_INSTANCE` and `READ` permission on Process definition level
         */
        startablePermissionCheck?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the latest version of the process definition which belongs to no tenant according to the `ProcessDefinition` interface in the engine. */
  getProcessDefinitionByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDto"];
        };
      };
      /**
       * Process definition with given `key` does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes process definitions by a given key which belong to no tenant id. */
  deleteProcessDefinitionsByKey: {
    parameters: {
      path: {
        /** The key of the process definitions to be deleted. */
        key: string;
      };
      query: {
        /**
         * `true`, if all process instances, historic process instances and jobs
         * for this process definition should be deleted.
         */
        cascade?: boolean;
        /** `true`, if only the built-in ExecutionListeners should be notified with the end event. */
        skipCustomListeners?: boolean;
        /**
         * A boolean value to control whether input/output mappings should be executed during deletion.
         * `true`, if input/output mappings should not be invoked.
         */
        skipIoMappings?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Forbidden
       * The process definitions with the given `key` cannot be deleted due to missing permissions.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Not found
       * Process definition with given `key` does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the deployed form that can be referenced from a start event.
   * For further information please refer to [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
   */
  getDeployedStartFormByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
        };
      };
      /**
       * The form key has wrong format.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The deployed start form cannot be retrieved due to missing permissions on process definition resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * No deployed start form for a given process definition exists. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the diagram for the latest version of the process definition which belongs to no tenant.
   *
   * If the process definition's deployment contains an image resource with the same file name
   * as the process definition, the deployed image will be returned by the Get Diagram endpoint.
   * Example: `someProcess.bpmn` and `someProcess.png`.
   * Supported file extentions for the image are: `svg`, `png`, `jpg`, and `gif`.
   */
  getProcessDefinitionDiagramByKey: {
    parameters: {
      path: {
        /** The key of the process definition. */
        key: string;
      };
    };
    responses: {
      /** Request successful. The image diagram of this process. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /** The process definition doesn't have an associated diagram. */
      204: never;
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the start form variables for the latest process definition which belongs to no tenant
   * (only if they are defined via the
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms) approach).
   * The start form variables take form data specified on the start event into account.
   * If form fields are defined, the variable types and default values
   * of the form fields are taken into account.
   */
  getStartFormVariablesByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
      };
      query: {
        /**
         * A comma-separated list of variable names. Allows restricting the list of requested
         * variables to the variable names in the list. It is best practice to restrict the
         * list of variables to the variables actually required by the form in order to
         * minimize fetching of data. If the query parameter is ommitted all variables are
         * fetched. If the query parameter contains non-existent variable names, the variable
         * names are ignored.
         */
        variableNames?: string;
        /**
         * Determines whether serializable variable values (typically variables that store
         * custom Java objects) should be deserialized on server side (default true).
         *
         * If set to true, a serializable variable will be deserialized on server side and
         * transformed to JSON using [Jackson's](http://jackson.codehaus.org/) POJO/bean
         * property introspection feature. Note that this requires the Java classes of the
         * variable value to be on the REST API's classpath.
         *
         * If set to false, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string
         * containing XML.
         *
         * **Note**: While true is the default value for reasons of backward compatibility, we
         * recommend setting this parameter to false when developing web applications that are
         * independent of the Java process applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. A JSON object containing a property for each variable returned. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * The key is null or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates history time to live for the latest version of the process definition which belongs to no tenant.
   * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
   */
  updateHistoryTimeToLiveByProcessDefinitionKey: {
    parameters: {
      path: {
        /** The key of the process definition to change history time to live. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the request parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoryTimeToLiveDto"];
      };
    };
  };
  /**
   * Retrieves  the rendered form for the latest version of the process definition which belongs to no tenant.
   * This method can be used to get the HTML rendering of a
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  getRenderedStartFormByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
        };
      };
      /**
       * Process definition has no form field metadata defined. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Instantiates a given process definition, starts the latest version of the process definition
   * which belongs to no tenant.
   * Process variables and business key may be supplied in the request body.
   */
  startProcessInstanceByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceWithVariablesDto"];
        };
      };
      /**
       * The instance could not be created due to an invalid variable value,
       * for example if the value could not be parsed to an `Integer` value or
       * the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The instance could not be created successfully.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartProcessInstanceDto"];
      };
    };
  };
  /**
   * Retrieves the key of the start form for the latest version of the process definition
   * which belongs to no tenant.
   * The form key corresponds to the `FormData#formKey` property in the engine.
   */
  getStartFormByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) for which the form key is to be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["FormDto"];
        };
      };
      /**
       * Process definition has no start form defined. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves runtime statistics of the latest version of the given process definition
   * which belongs to no tenant, grouped by activities.
   * These statistics include the number of running activity instances, optionally the number of failed jobs
   * and also optionally the number of incidents either grouped by incident types or
   * for a specific incident type.
   * **Note**: This does not include historic data.
   */
  getActivityStatisticsByProcessDefinitionKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
      };
      query: {
        /** Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. */
        failedJobs?: boolean;
        /**
         * Valid values for this property are `true` or `false`.
         * If this property has been set to `true` the result will include the corresponding number of incidents
         * for each occurred incident type.
         * If it is set to `false`, the incidents will not be included in the result.
         * Cannot be used in combination with `incidentsForType`.
         */
        incidents?: boolean;
        /**
         * If this property has been set with any incident type (i.e., a string value) the result
         * will only include the number of incidents for the assigned incident type.
         * Cannot be used in combination with `incidents`.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentsForType?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ActivityStatisticsResultDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Starts the latest version of the process definition which belongs to no tenant
   * using a set of process variables and the business key.
   * If the start event has Form Field Metadata defined, the process engine will perform backend validation
   * for any form fields which have validators defined.
   * See [Documentation on Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  submitFormByKey: {
    parameters: {
      path: {
        /** The key of the process definition to submit the form for. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"];
        };
      };
      /**
       * The instance could not be created due to an invalid variable value,
       * for example if the value could not be parsed to an `Integer` value or
       * the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The instance could not be created successfully.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartProcessInstanceFormDto"];
      };
    };
  };
  /**
   * Activates or suspends a given process definition by latest version of process definition key
   * which belongs to no tenant.
   */
  updateProcessDefinitionSuspensionStateByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be activated/suspended. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the query parameters are invalid,
       * for example if the provided `executionDate` parameter doesn't have the expected format or
       * if the `processDefinitionKey` parameter is `null`. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessDefinitionSuspensionStateDto"];
      };
    };
  };
  /**
   * Retrieves the latest version of the process definition for tenant according to
   * the `ProcessDefinition` interface in the engine.
   */
  getLatestProcessDefinitionByTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDto"];
        };
      };
      /**
       * Process definition with given `key` does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes process definitions by a given key and which belong to a tenant id. */
  deleteProcessDefinitionsByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definitions to be deleted. */
        key: string;
        /** The id of the tenant the process definitions belong to. */
        "tenant-id": string;
      };
      query: {
        /**
         * `true`, if all process instances, historic process instances and jobs
         * for this process definition should be deleted.
         */
        cascade?: boolean;
        /** `true`, if only the built-in ExecutionListeners should be notified with the end event. */
        skipCustomListeners?: boolean;
        /**
         * A boolean value to control whether input/output mappings should be executed during deletion.
         * `true`, if input/output mappings should not be invoked.
         */
        skipIoMappings?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Forbidden
       * The process definitions with the given `key` cannot be deleted due to missing permissions.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Not found
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the deployed form that can be referenced from a start event.
   * For further information please refer to [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
   */
  getDeployedStartFormByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the process definitions belong to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
        };
      };
      /**
       * The form key has wrong format.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The deployed start form cannot be retrieved due to missing permissions on process definition resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * No deployed start form for a given process definition exists. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the diagram for the latest version of the process definition for tenant.
   *
   * If the process definition's deployment contains an image resource with the same file name
   * as the process definition, the deployed image will be returned by the Get Diagram endpoint.
   * Example: `someProcess.bpmn` and `someProcess.png`.
   * Supported file extentions for the image are: `svg`, `png`, `jpg`, and `gif`.
   */
  getProcessDefinitionDiagramByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. The image diagram of this process. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /** The process definition doesn't have an associated diagram. */
      204: never;
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the start form variables for the latest process definition for a tenant
   * (only if they are defined via the
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms) approach).
   * The start form variables take form data specified on the start event into account.
   * If form fields are defined, the variable types and default values
   * of the form fields are taken into account.
   */
  getStartFormVariablesByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
      query: {
        /**
         * A comma-separated list of variable names. Allows restricting the list of requested
         * variables to the variable names in the list. It is best practice to restrict the
         * list of variables to the variables actually required by the form in order to
         * minimize fetching of data. If the query parameter is ommitted all variables are
         * fetched. If the query parameter contains non-existent variable names, the variable
         * names are ignored.
         */
        variableNames?: string;
        /**
         * Determines whether serializable variable values (typically variables that store
         * custom Java objects) should be deserialized on server side (default true).
         *
         * If set to true, a serializable variable will be deserialized on server side and
         * transformed to JSON using [Jackson's](http://jackson.codehaus.org/) POJO/bean
         * property introspection feature. Note that this requires the Java classes of the
         * variable value to be on the REST API's classpath.
         *
         * If set to false, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string
         * containing XML.
         *
         * **Note**: While true is the default value for reasons of backward compatibility, we
         * recommend setting this parameter to false when developing web applications that are
         * independent of the Java process applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. A JSON object containing a property for each variable returned. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * The key is null or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates history time to live for the latest version of the process definition for a tenant.
   * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
   */
  updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition to change history time to live. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the request parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoryTimeToLiveDto"];
      };
    };
  };
  /**
   * Retrieves  the rendered form for the latest version of the process definition for a tenant.
   * This method can be used to get the HTML rendering of a
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  getRenderedStartFormByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
        };
      };
      /**
       * Process definition has no form field metadata defined. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Instantiates a given process definition, starts the latest version of the process definition for tenant.
   * Process variables and business key may be supplied in the request body.
   */
  startProcessInstanceByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceWithVariablesDto"];
        };
      };
      /**
       * The instance could not be created due to an invalid variable value,
       * for example if the value could not be parsed to an `Integer` value or
       * the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The instance could not be created successfully.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartProcessInstanceDto"];
      };
    };
  };
  /**
   * Retrieves the key of the start form for the latest version of the process definition for a tenant.
   * The form key corresponds to the `FormData#formKey` property in the engine.
   */
  getStartFormByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) for which the form key is to be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["FormDto"];
        };
      };
      /**
       * Process definition has no start form defined. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves runtime statistics of the latest version of the given process definition for a tenant,
   * grouped by activities.
   * These statistics include the number of running activity instances, optionally the number of failed jobs
   * and also optionally the number of incidents either grouped by incident types or
   * for a specific incident type.
   * **Note**: This does not include historic data.
   */
  getActivityStatisticsByProcessDefinitionKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
      query: {
        /** Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. */
        failedJobs?: boolean;
        /**
         * Valid values for this property are `true` or `false`.
         * If this property has been set to `true` the result will include the corresponding number of incidents
         * for each occurred incident type.
         * If it is set to `false`, the incidents will not be included in the result.
         * Cannot be used in combination with `incidentsForType`.
         */
        incidents?: boolean;
        /**
         * If this property has been set with any incident type (i.e., a string value) the result
         * will only include the number of incidents for the assigned incident type.
         * Cannot be used in combination with `incidents`.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentsForType?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ActivityStatisticsResultDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Starts the latest version of the process definition for a tenant
   * using a set of process variables and the business key.
   * If the start event has Form Field Metadata defined, the process engine will perform backend validation
   * for any form fields which have validators defined.
   * See [Documentation on Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  submitFormByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition to submit the form for. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"];
        };
      };
      /**
       * The instance could not be created due to an invalid variable value,
       * for example if the value could not be parsed to an `Integer` value or
       * the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The instance could not be created successfully.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartProcessInstanceFormDto"];
      };
    };
  };
  /**
   * Activates or suspends a given process definition by the latest version of
   * the process definition for tenant.
   */
  updateProcessDefinitionSuspensionStateByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) to be activated/suspended. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the query parameters are invalid,
       * for example if the provided `executionDate` parameter doesn't have the expected format or
       * if the `processDefinitionKey` parameter is `null`. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessDefinitionSuspensionStateDto"];
      };
    };
  };
  /**
   * Retrieves latest version the BPMN 2.0 XML of a process definition.
   * Returns the XML for the latest version of the process definition for tenant.
   */
  getProcessDefinitionBpmn20XmlByKeyAndTenantId: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) whose XML should be retrieved. */
        key: string;
        /** The id of the tenant the process definition belongs to. */
        "tenant-id": string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDiagramDto"];
        };
      };
      /**
       * The Process Definition xml cannot be retrieved due to missing permissions on the Process Definition resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves latest version the BPMN 2.0 XML of a process definition. */
  getProcessDefinitionBpmn20XmlByKey: {
    parameters: {
      path: {
        /** The key of the process definition (the latest version thereof) whose XML should be retrieved. */
        key: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDiagramDto"];
        };
      };
      /**
       * The Process Definition xml cannot be retrieved due to missing permissions on the Process Definition resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves runtime statistics of the process engine, grouped by process definitions.
   * These statistics include the number of running process instances, optionally the number of failed jobs
   * and also optionally the number of incidents either grouped by incident types or
   * for a specific incident type.
   * **Note**: This does not include historic data.
   */
  getProcessDefinitionStatistics: {
    parameters: {
      query: {
        /** Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. */
        failedJobs?: boolean;
        /**
         * Valid values for this property are `true` or `false`.
         * If this property has been set to `true` the result will include the corresponding number of incidents
         * for each occurred incident type.
         * If it is set to `false`, the incidents will not be included in the result.
         * Cannot be used in combination with `incidentsForType`.
         */
        incidents?: boolean;
        /**
         * If this property has been set with any incident type (i.e., a string value) the result
         * will only include the number of incidents for the assigned incident type.
         * Cannot be used in combination with `incidents`.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentsForType?: string;
        /**
         * Valid values for this property are `true` or `false`.
         * If this property has been set to `true` the result will include the corresponding number of
         * root incidents for each occurred incident type.
         * If it is set to `false`, the incidents will not be included in the result.
         * Cannot be used in combination with `incidentsForType` or `incidents`.
         */
        rootIncidents?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionStatisticsResultDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Activates or suspends process definitions with the given process definition key. */
  updateProcessDefinitionSuspensionState: {
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the query parameters are invalid,
       * for example if the provided `executionDate` parameter doesn't have the expected format or
       * if the `processDefinitionKey` parameter is `null`. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** **Note**: Unallowed property is `processDefinitionId`. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessDefinitionSuspensionStateDto"];
      };
    };
  };
  /** Retrieves a process definition according to the `ProcessDefinition` interface in the engine. */
  getProcessDefinition: {
    parameters: {
      path: {
        /** The id of the process definition to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDto"];
        };
      };
      /**
       * Process definition with given `id` does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes a running process instance by id. */
  deleteProcessDefinition: {
    parameters: {
      path: {
        /** The id of the process definition to be deleted. */
        id: string;
      };
      query: {
        /**
         * `true`, if all process instances, historic process instances and jobs
         * for this process definition should be deleted.
         */
        cascade?: boolean;
        /** `true`, if only the built-in ExecutionListeners should be notified with the end event. */
        skipCustomListeners?: boolean;
        /**
         * A boolean value to control whether input/output mappings should be executed during deletion.
         * `true`, if input/output mappings should not be invoked.
         */
        skipIoMappings?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Not found
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the deployed form that can be referenced from a start event.
   * For further information please refer to [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
   */
  getDeployedStartForm: {
    parameters: {
      path: {
        /** The id of the process definition to get the deployed start form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
          "application/json": string;
        };
      };
      /**
       * The form key has wrong format.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The deployed start form cannot be retrieved due to missing permissions on process definition resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * No deployed start form for a given process definition exists. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the diagram of a process definition.
   *
   * If the process definition's deployment contains an image resource with the same file name
   * as the process definition, the deployed image will be returned by the Get Diagram endpoint.
   * Example: `someProcess.bpmn` and `someProcess.png`.
   * Supported file extentions for the image are: `svg`, `png`, `jpg`, and `gif`.
   */
  getProcessDefinitionDiagram: {
    parameters: {
      path: {
        /** The id of the process definition. */
        id: string;
      };
    };
    responses: {
      /** Request successful. The image diagram of this process. */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /** The process definition doesn't have an associated diagram. */
      204: never;
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the start form variables for a process definition
   * (only if they are defined via the
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms) approach).
   * The start form variables take form data specified on the start event into account.
   * If form fields are defined, the variable types and default values
   * of the form fields are taken into account.
   */
  getStartFormVariables: {
    parameters: {
      path: {
        /** The id of the process definition to retrieve the variables for. */
        id: string;
      };
      query: {
        /**
         * A comma-separated list of variable names. Allows restricting the list of requested
         * variables to the variable names in the list. It is best practice to restrict the
         * list of variables to the variables actually required by the form in order to
         * minimize fetching of data. If the query parameter is ommitted all variables are
         * fetched. If the query parameter contains non-existent variable names, the variable
         * names are ignored.
         */
        variableNames?: string;
        /**
         * Determines whether serializable variable values (typically variables that store
         * custom Java objects) should be deserialized on server side (default true).
         *
         * If set to true, a serializable variable will be deserialized on server side and
         * transformed to JSON using [Jackson's](http://jackson.codehaus.org/) POJO/bean
         * property introspection feature. Note that this requires the Java classes of the
         * variable value to be on the REST API's classpath.
         *
         * If set to false, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string
         * containing XML.
         *
         * **Note**: While true is the default value for reasons of backward compatibility, we
         * recommend setting this parameter to false when developing web applications that are
         * independent of the Java process applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. A JSON object containing a property for each variable returned. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * The id is null or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates history time to live for process definition.
   * The field is used within [History cleanup](https://docs.camunda.org/manual/latest/user-guide/process-engine/history/#history-cleanup).
   */
  updateHistoryTimeToLiveByProcessDefinitionId: {
    parameters: {
      path: {
        /** The id of the process definition to change history time to live. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the request parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["HistoryTimeToLiveDto"];
      };
    };
  };
  /**
   * Retrieves the rendered form for a process definition.
   * This method can be used to get the HTML rendering of a
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  getRenderedStartForm: {
    parameters: {
      path: {
        /** The id of the process definition to get the rendered start form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
        };
      };
      /**
       * Process definition has no form field metadata defined. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Restarts process instances that were canceled or terminated synchronously.
   * Can also restart completed process instances.
   * It will create a new instance using the original instance information.
   * To execute the restart asynchronously, use the
   * [Restart Process Instance Async](https://docs.camunda.org/manual/latest/reference/rest/process-definition/post-restart-process-instance-async/) method.
   *
   * For more information about the difference between synchronous and asynchronous execution,
   * please refer to the related section of the
   * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-instance-restart/#execution).
   */
  restartProcessInstance: {
    parameters: {
      path: {
        /** The id of the process definition of the process instances to restart. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * In case following parameters are missing: `instructions`, `activityId` or `transitionId`,
       * `processInstanceIds` or `historicProcessInstanceQuery`, an exception of type `InvalidRequestException` is returned.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["RestartProcessInstanceDto"];
      };
    };
  };
  /**
   * Restarts process instances that were canceled or terminated asynchronously.
   * Can also restart completed process instances.
   * It will create a new instance using the original instance information.
   * To execute the restart asynchronously, use the
   * [Restart Process Instance](https://docs.camunda.org/manual/latest/reference/rest/process-definition/post-restart-process-instance-sync/) method.
   *
   * For more information about the difference between synchronous and asynchronous execution,
   * please refer to the related section of the
   * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-instance-restart/#execution).
   */
  restartProcessInstanceAsyncOperation: {
    parameters: {
      path: {
        /** The id of the process definition of the process instances to restart. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * In case following parameters are missing: `instructions`, `activityId` or `transitionId`,
       * `processInstanceIds` or `historicProcessInstanceQuery`,
       * an exception of type `InvalidRequestException` is returned.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["RestartProcessInstanceDto"];
      };
    };
  };
  /**
   * Instantiates a given process definition.
   * Process variables and business key may be supplied in the request body.
   */
  startProcessInstance: {
    parameters: {
      path: {
        /** The id of the process definition to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceWithVariablesDto"];
        };
      };
      /**
       * The instance could not be created due to an invalid variable value,
       * for example if the value could not be parsed to an `Integer` value or
       * the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The instance could not be created successfully.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartProcessInstanceDto"];
      };
    };
  };
  /**
   * Retrieves the key of the start form for a process definition.
   * The form key corresponds to the `FormData#formKey` property in the engine.
   */
  getStartForm: {
    parameters: {
      path: {
        /** The id of the process definition to get the start form key for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["FormDto"];
        };
      };
      /**
       * Process definition has no start form defined. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist.  See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves runtime statistics of a given process definition, grouped by activities.
   * These statistics include the number of running activity instances, optionally the number of failed jobs
   * and also optionally the number of incidents either grouped by incident types or for a specific incident type.
   * **Note**: This does not include historic data.
   */
  getActivityStatistics: {
    parameters: {
      path: {
        /** The id of the process definition. */
        id: string;
      };
      query: {
        /** Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. */
        failedJobs?: boolean;
        /**
         * Valid values for this property are `true` or `false`.
         * If this property has been set to `true` the result will include the corresponding number of incidents
         * for each occurred incident type.
         * If it is set to `false`, the incidents will not be included in the result.
         * Cannot be used in combination with `incidentsForType`.
         */
        incidents?: boolean;
        /**
         * If this property has been set with any incident type (i.e., a string value) the result
         * will only include the number of incidents for the assigned incident type.
         * Cannot be used in combination with `incidents`.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentsForType?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ActivityStatisticsResultDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Starts a process instance using a set of process variables and the business key.
   * If the start event has Form Field Metadata defined, the process engine will perform backend validation
   * for any form fields which have validators defined.
   * See [Documentation on Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  submitForm: {
    parameters: {
      path: {
        /** The id of the process definition to submit the form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"];
        };
      };
      /**
       * The instance could not be created due to an invalid variable value,
       * for example if the value could not be parsed to an `Integer` value or
       * the passed variable type is not supported.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The instance could not be created successfully.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartProcessInstanceFormDto"];
      };
    };
  };
  /** Activates or suspends a given process definition by id. */
  updateProcessDefinitionSuspensionStateById: {
    parameters: {
      path: {
        /** The id of the process definition to activate or suspend. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if some of the query parameters are invalid,
       * for example if the provided `executionDate` parameter doesn't have the expected format or
       * if the `processDefinitionKey` parameter is `null`. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Process definition with given key does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessDefinitionSuspensionStateDto"];
      };
    };
  };
  /** Retrieves the BPMN 2.0 XML of a process definition. */
  getProcessDefinitionBpmn20Xml: {
    parameters: {
      path: {
        /** The id of the process definition. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessDefinitionDiagramDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The Process Definition xml cannot be retrieved due to missing permissions on the Process Definition resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Process definition with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for process instances that fulfill given parameters.
   * Parameters may be static as well as dynamic runtime properties of process instances.
   * The size of the result set can be retrieved by using the Get Instance Count method.
   */
  getProcessInstances: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "instanceId"
          | "definitionKey"
          | "definitionId"
          | "tenantId"
          | "businessKey";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by a comma-separated list of process instance ids. */
        processInstanceIds?: string;
        /** Filter by process instance business key. */
        businessKey?: string;
        /** Filter by process instance business key that the parameter is a substring of. */
        businessKeyLike?: string;
        /** Filter by case instance id. */
        caseInstanceId?: string;
        /** Filter by the deployment the id belongs to. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the instances run on. */
        processDefinitionKey?: string;
        /**
         * Filter by a comma-separated list of process definition keys.
         * A process instance must have one of the given process definition keys.
         */
        processDefinitionKeyIn?: string;
        /**
         * Exclude instances by a comma-separated list of process definition keys.
         * A process instance must not have one of the given process definition keys.
         */
        processDefinitionKeyNotIn?: string;
        /** Filter by the deployment the id belongs to. */
        deploymentId?: string;
        /**
         * Restrict query to all process instances that are sub process instances of the given process instance.
         * Takes a process instance id.
         */
        superProcessInstance?: string;
        /**
         * Restrict query to all process instances that have the given process instance as a sub process instance.
         * Takes a process instance id.
         */
        subProcessInstance?: string;
        /**
         * Restrict query to all process instances that are sub process instances of the given case instance.
         * Takes a case instance id.
         */
        superCaseInstance?: string;
        /**
         * Restrict query to all process instances that have the given case instance as a sub case instance.
         * Takes a case instance id.
         */
        subCaseInstance?: string;
        /**
         * Only include active process instances. Value may only be true,
         * as false is the default behavior.
         */
        active?: boolean;
        /**
         * Only include suspended process instances. Value may only be true,
         * as false is the default behavior.
         */
        suspended?: boolean;
        /** Filter by presence of incidents. Selects only process instances that have an incident. */
        withIncident?: boolean;
        /** Filter by the incident id. */
        incidentId?: string;
        /**
         * Filter by the incident type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentType?: string;
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /** Filter by a comma-separated list of tenant ids. A process instance must have one of the given tenant ids. */
        tenantIdIn?: string;
        /** Only include process instances which belong to no tenant. */
        withoutTenantId?: boolean;
        /** Only include process instances which process definition has no tenant id. */
        processDefinitionWithoutTenantId?: boolean;
        /**
         * Filter by a comma-separated list of activity ids.
         * A process instance must currently wait in a leaf activity with one of the given activity ids.
         */
        activityIdIn?: string;
        /** Restrict the query to all process instances that are top level process instances. */
        rootProcessInstances?: boolean;
        /** Restrict the query to all process instances that are leaf instances. (i.e. don't have any sub instances). */
        leafProcessInstances?: boolean;
        /**
         * Only include process instances that have variables with certain values.
         * Variable filtering expressions are comma-separated and are structured as follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        variables?: string;
        /**
         * Match all variable names in this query case-insensitively.
         * If set to true variableName and variablename are treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values in this query case-insensitively.
         * If set to true variableValue and variablevalue are treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid,
       * for example if a sortOrder parameter is supplied, but no sortBy, or if an invalid operator for variable comparison is used.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for process instances that fulfill given parameters through a JSON object.
   * This method is slightly more powerful than the Get Instances method because
   * it allows filtering by multiple process variables of types `string`, `number` or `boolean`.
   */
  queryProcessInstances: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"][];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid,
       * for example if a sortOrder parameter is supplied, but no sortBy, or if an invalid operator for variable comparison is used.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessInstanceQueryDto"];
      };
    };
  };
  /** Queries for the number of process instances that fulfill given parameters. */
  getProcessInstancesCount: {
    parameters: {
      query: {
        /** Filter by a comma-separated list of process instance ids. */
        processInstanceIds?: string;
        /** Filter by process instance business key. */
        businessKey?: string;
        /** Filter by process instance business key that the parameter is a substring of. */
        businessKeyLike?: string;
        /** Filter by case instance id. */
        caseInstanceId?: string;
        /** Filter by the deployment the id belongs to. */
        processDefinitionId?: string;
        /** Filter by the key of the process definition the instances run on. */
        processDefinitionKey?: string;
        /**
         * Filter by a comma-separated list of process definition keys.
         * A process instance must have one of the given process definition keys.
         */
        processDefinitionKeyIn?: string;
        /**
         * Exclude instances by a comma-separated list of process definition keys.
         * A process instance must not have one of the given process definition keys.
         */
        processDefinitionKeyNotIn?: string;
        /** Filter by the deployment the id belongs to. */
        deploymentId?: string;
        /**
         * Restrict query to all process instances that are sub process instances of the given process instance.
         * Takes a process instance id.
         */
        superProcessInstance?: string;
        /**
         * Restrict query to all process instances that have the given process instance as a sub process instance.
         * Takes a process instance id.
         */
        subProcessInstance?: string;
        /**
         * Restrict query to all process instances that are sub process instances of the given case instance.
         * Takes a case instance id.
         */
        superCaseInstance?: string;
        /**
         * Restrict query to all process instances that have the given case instance as a sub case instance.
         * Takes a case instance id.
         */
        subCaseInstance?: string;
        /**
         * Only include active process instances. Value may only be true,
         * as false is the default behavior.
         */
        active?: boolean;
        /**
         * Only include suspended process instances. Value may only be true,
         * as false is the default behavior.
         */
        suspended?: boolean;
        /** Filter by presence of incidents. Selects only process instances that have an incident. */
        withIncident?: boolean;
        /** Filter by the incident id. */
        incidentId?: string;
        /**
         * Filter by the incident type.
         * See the [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/incidents/#incident-types)
         * for a list of incident types.
         */
        incidentType?: string;
        /** Filter by the incident message. Exact match. */
        incidentMessage?: string;
        /** Filter by the incident message that the parameter is a substring of. */
        incidentMessageLike?: string;
        /** Filter by a comma-separated list of tenant ids. A process instance must have one of the given tenant ids. */
        tenantIdIn?: string;
        /** Only include process instances which belong to no tenant. */
        withoutTenantId?: boolean;
        /** Only include process instances which process definition has no tenant id. */
        processDefinitionWithoutTenantId?: boolean;
        /**
         * Filter by a comma-separated list of activity ids.
         * A process instance must currently wait in a leaf activity with one of the given activity ids.
         */
        activityIdIn?: string;
        /** Restrict the query to all process instances that are top level process instances. */
        rootProcessInstances?: boolean;
        /** Restrict the query to all process instances that are leaf instances. (i.e. don't have any sub instances). */
        leafProcessInstances?: boolean;
        /**
         * Only include process instances that have variables with certain values.
         * Variable filtering expressions are comma-separated and are structured as follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        variables?: string;
        /**
         * Match all variable names in this query case-insensitively.
         * If set to true variableName and variablename are treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values in this query case-insensitively.
         * If set to true variableValue and variablevalue are treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example an invalid operator for variable comparison is used.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of process instances that fulfill the given parameters.
   * This method takes the same message body as the Get Instances (POST) method and
   * therefore it is slightly more powerful than the Get Instance Count method.
   */
  queryProcessInstancesCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if an invalid operator for variable comparison is used.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessInstanceQueryDto"];
      };
    };
  };
  /** Deletes multiple process instances asynchronously (batch). */
  deleteProcessInstancesAsyncOperation: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, i.e., neither processInstanceIds, nor processInstanceQuery is present
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** **Unallowed property**: `historicProcessInstanceQuery` */
    requestBody: {
      content: {
        "application/json": components["schemas"]["DeleteProcessInstancesDto"];
      };
    };
  };
  /** Deletes a set of process instances asynchronously (batch) based on a historic process instance query. */
  deleteAsyncHistoricQueryBased: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, i.e., neither processInstanceIds, nor historicProcessInstanceQuery is present
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** **Unallowed property**: `processInstanceQuery` */
    requestBody: {
      content: {
        "application/json": components["schemas"]["DeleteProcessInstancesDto"];
      };
    };
  };
  /** Create a batch to set retries of jobs associated with given processes asynchronously. */
  setRetriesByProcess: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if neither processInstanceIds, nor processInstanceQuery is present.
       * Or if the retry count is not specified.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /**
     * Please note that if both processInstances and processInstanceQuery are provided,
     * then the resulting execution will be performed on the union of these sets.
     * **Unallowed property**: `historicProcessInstanceQuery`
     */
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetJobRetriesByProcessDto"];
      };
    };
  };
  /** Create a batch to set retries of jobs asynchronously based on a historic process instance query. */
  setRetriesByProcessHistoricQueryBased: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the query parameters are invalid, for example if neither processInstanceIds, nor historicProcessInstanceQuery is present.
       * Or if the retry count is not specified.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /**
     * Please note that if both processInstances and historicProcessInstanceQuery are provided,
     * then the resulting execution will be performed on the union of these sets.
     * **Unallowed property**: `processInstanceQuery`
     */
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetJobRetriesByProcessDto"];
      };
    };
  };
  /**
   * Activates or suspends process instances by providing certain criteria:
   *
   * # Activate/Suspend Process Instance By Process Definition Id
   * * `suspend`
   * * `processDefinitionId`
   *
   * # Activate/Suspend Process Instance By Process Definition Key
   *
   * * `suspend`
   * * `processDefinitionKey`
   * * `processDefinitionTenantId`
   * * `processDefinitionWithoutTenantId`
   *
   * # Activate/Suspend Process Instance In Group
   * * `suspend`
   * * `processInstanceIds`
   * * `processInstanceQuery`
   * * `historicProcessInstanceQuery`
   */
  updateSuspensionState: {
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Bad Request
       * Returned if some of the request parameters are invalid,
       * for example if the provided processDefinitionId or processDefinitionKey parameter is null.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessInstanceSuspensionStateDto"];
      };
    };
  };
  /**
   * Activates or suspends process instances asynchronously with a list of process instance ids,
   * a process instance query, and/or a historical process instance query.
   */
  updateSuspensionStateAsyncOperation: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * Returned if some of the request parameters are invalid,
       * for example if the provided processDefinitionId or processDefinitionKey parameter is null.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessInstanceSuspensionStateAsyncDto"];
      };
    };
  };
  /** Update or create runtime process variables in the root scope of process instances. */
  setVariablesAsyncOperation: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * * The variable value or type is invalid, for example if the value could not be parsed to an Integer value or
       * the passed variable type is not supported
       * * If none of `processInstanceIds`, `processInstanceQuery` and `historicProcessInstanceQuery` is given
       * * If no or an empty array of `variables` is given
       * * If no process instance ids where found
       * * If a transient variable is set
       * * If the engine config flag `javaSerializationFormatEnabled` is `false` and a Java serialized variable is given
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the user is not allowed to create the batch.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the
       * error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SetVariablesAsyncDto"];
      };
    };
  };
  /** Retrieves a process instance by id, according to the `ProcessInstance` interface in the engine. */
  getProcessInstance: {
    parameters: {
      path: {
        /** The id of the process instance to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ProcessInstanceDto"];
        };
      };
      /**
       * Process instance with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes a running process instance by id. */
  deleteProcessInstance: {
    parameters: {
      path: {
        /** The id of the process instance to be deleted. */
        id: string;
      };
      query: {
        /** If set to true, the custom listeners will be skipped. */
        skipCustomListeners?: boolean;
        /** If set to true, the input/output mappings will be skipped. */
        skipIoMappings?: boolean;
        /** If set to true, subprocesses related to deleted processes will be skipped. */
        skipSubprocesses?: boolean;
        /** If set to false, the request will still be successful if the process id is not found. */
        failIfNotExists?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Not found
       * Process instance with given id does not exist.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves an Activity Instance (Tree) for a given process instance by id. */
  getActivityInstanceTree: {
    parameters: {
      path: {
        /** The id of the process instance for which the activity instance should be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ActivityInstanceDto"];
        };
      };
      /** Process instance with given id does not exist. */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Submits a list of modification instructions to change a process instance's execution state.
   * A modification instruction is one of the following:
   *
   * * Starting execution before an activity
   * * Starting execution after an activity on its single outgoing sequence flow
   * * Starting execution on a specific sequence flow
   * * Canceling an activity instance, transition instance, or all instances (activity or transition) for an activity
   *
   * Instructions are executed immediately and in the order they are provided in this request's body.
   * Variables can be provided with every starting instruction.
   *
   * The exact semantics of modification can be read about in the [User guide](https://docs.camunda.org/manual/develop/user-guide/process-engine/process-instance-modification/).
   */
  modifyProcessInstance: {
    parameters: {
      path: {
        /** The id of the process instance to modify. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** At least one modification instruction misses required parameters. */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** The modification cannot be performed, for example because it starts a failing activity. */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessInstanceModificationDto"];
      };
    };
  };
  /**
   * Submits a list of modification instructions to change a process instance's execution state async.
   * A modification instruction is one of the following:
   *
   * * Starting execution before an activity
   * * Starting execution after an activity on its single outgoing sequence flow
   * * Starting execution on a specific sequence flow
   * * Cancelling an activity instance, transition instance, or all instances (activity or transition) for an activity
   *
   * Instructions are executed asynchronous and in the order they are provided in this request's body.
   * Variables can be provided with every starting instruction.
   *
   * The exact semantics of modification can be read about in the
   * [User guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/process-instance-modification/).
   */
  modifyProcessInstanceAsyncOperation: {
    parameters: {
      path: {
        /** The id of the process instance to modify. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["BatchDto"];
        };
      };
      /**
       * Bad Request
       * At least one modification instruction misses required parameters.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Forbidden
       * If the user is not allowed to execute batches. See the Introduction for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /** The modification cannot be performed, for example because it starts a failing activity. */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["ProcessInstanceModificationDto"];
      };
    };
  };
  /** Activates or suspends a given process instance by id. */
  updateSuspensionStateById: {
    parameters: {
      path: {
        /** The id of the process instance to activate or suspend. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SuspensionStateDto"];
      };
    };
  };
  /** Retrieves all variables of a given process instance by id. */
  getProcessInstanceVariables: {
    parameters: {
      path: {
        /** The id of the process instance to retrieve the variables from. */
        id: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on server side (default true).
         *
         * If set to true, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to false, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * Note: While true is the default value for reasons of backward compatibility, we recommend setting this parameter to false
         * when developing web applications that are independent of the Java process applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /** Process instance with given id does not exist. */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates or deletes the variables of a process instance by id. Updates precede deletions.
   * So, if a variable is updated AND deleted, the deletion overrides the update.
   */
  modifyProcessInstanceVariables: {
    parameters: {
      path: {
        /** The id of the process instance to set variables for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Bad Request
       * The variable value or type is invalid, for example if the value could not be parsed to an Integer value or
       * the passed variable type is not supported.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** Update or delete could not be executed, for example because the process instance does not exist. */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PatchVariablesDto"];
      };
    };
  };
  /** Retrieves a variable of a given process instance by id. */
  getProcessInstanceVariable: {
    parameters: {
      path: {
        /** The id of the process instance to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on server side (default true).
         *
         * If set to true, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to false, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * Note: While true is the default value for reasons of backward compatibility, we recommend setting this parameter to false
         * when developing web applications that are independent of the Java process applications deployed to the engine.
         */
        deserializeValue?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableValueDto"];
        };
      };
      /**
       * Bad Request
       * Variable with given id does not exist.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Sets a variable of a given process instance by id. */
  setProcessInstanceVariable: {
    parameters: {
      path: {
        /** The id of the process instance to set the variable for. */
        id: string;
        /** The name of the variable to set. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Bad Request
       * The variable value or type is invalid, for example if the value could not be parsed to an Integer value or
       * the passed variable type is not supported.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["VariableValueDto"];
      };
    };
  };
  /** Deletes a variable of a process instance by id. */
  deleteProcessInstanceVariable: {
    parameters: {
      path: {
        /** The id of the process instance to delete the variable from. */
        id: string;
        /** The name of the variable to delete. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
    };
  };
  /**
   * Retrieves the content of a Process Variable by the Process Instance id and the Process Variable name.
   * Applicable for byte array or file Process Variables.
   */
  getProcessInstanceVariableBinary: {
    parameters: {
      path: {
        /** The id of the process instance to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
    };
    responses: {
      /**
       * Request successful.
       *         For binary variables or files without any MIME type information, a byte stream is returned.
       *         File variables with MIME type information are returned as the saved type.
       *         Additionally, for file variables the Content-Disposition header will be set.
       */
      200: {
        content: {
          "application/octet-stream": string;
          "text/plain": string;
        };
      };
      /**
       * Bad Request
       * A Process Variable with the given id exists but does not serialize as binary data.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Not Found
       * A Process Variable with the given id does not exist.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Sets the serialized value for a binary variable or the binary value for a file variable. */
  setProcessInstanceVariableBinary: {
    parameters: {
      path: {
        /** The id of the process instance to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Bad Request
       * The variable value or type is invalid, for example if no filename is set.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** For binary variables a multipart form submit with the following parts: */
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["MultiFormVariableBinaryDto"];
      };
    };
  };
  /** Queries for schema log entries that fulfill given parameters. */
  getSchemaLog: {
    parameters: {
      query: {
        /** Only return schema log entries with a specific version. */
        version?: string;
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /**
       * Request successful.
       * **Note**: In order to get any results a user of group `camunda-admin` must
       * be authenticated.
       */
      200: {
        content: {
          "application/json": components["schemas"]["SchemaLogEntryDto"][];
        };
      };
    };
  };
  /** Queries for schema log entries that fulfill given parameters. */
  querySchemaLog: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /**
       * Request successful.
       * **Note**: In order to get any results a user of group camunda-admin must be
       * authenticated.
       */
      200: {
        content: {
          "application/json": components["schemas"]["SchemaLogEntryDto"][];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SchemaLogQueryDto"];
      };
    };
  };
  /**
   * A signal is an event of global scope (broadcast semantics) and is delivered to all
   * active handlers. Internally this maps to the engine's signal event received builder
   * method `RuntimeService#createSignalEvent()`. For more information about the signal
   * behavior, see the [Signal Events](https://docs.camunda.org/manual/latest/reference/bpmn20/events/signal-events/)
   * section of the [BPMN 2.0 Implementation Reference](https://docs.camunda.org/manual/latest/reference/bpmn20/).
   */
  throwSignal: {
    parameters: {};
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if:
       *
       * * no name was given
       * * the variable value or type is invalid, for example if the value could not be
       * parsed to an integer value or the passed variable type is not supported
       * * a tenant id and an execution id is specified.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the
       * error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Returned if the user is not allowed to throw a signal event.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the
       * error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Returned if a single execution is specified and no such execution exists or has not
       * subscribed to the signal.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the
       * error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["SignalDto"];
      };
    };
  };
  /**
   * Queries for tasks that fulfill a given filter. The size of the result set can be
   * retrieved by using the Get Task Count method.
   *
   * **Security Consideration:** There are several query parameters (such as
   * assigneeExpression) for specifying an EL expression. These are disabled by default to
   * prevent remote code execution. See the section on
   * [security considerations](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
   * for custom code in the user guide for details.
   */
  getTasks: {
    parameters: {
      query: {
        /** Restrict to task with the given id. */
        taskId?: string;
        /** Restrict to tasks with any of the given ids. */
        taskIdIn?: string;
        /** Restrict to tasks that belong to process instances with the given id. */
        processInstanceId?: string;
        /** Restrict to tasks that belong to process instances with the given ids. */
        processInstanceIdIn?: string;
        /** Restrict to tasks that belong to process instances with the given business key. */
        processInstanceBusinessKey?: string;
        /**
         * Restrict to tasks that belong to process instances with the given business key which
         * is described by an expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        processInstanceBusinessKeyExpression?: string;
        /**
         * Restrict to tasks that belong to process instances with one of the give business keys.
         * The keys need to be in a comma-separated list.
         */
        processInstanceBusinessKeyIn?: string;
        /**
         * Restrict to tasks that have a process instance business key that has the parameter
         * value as a substring.
         */
        processInstanceBusinessKeyLike?: string;
        /**
         * Restrict to tasks that have a process instance business key that has the parameter
         * value as a substring and is described by an expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        processInstanceBusinessKeyLikeExpression?: string;
        /** Restrict to tasks that belong to a process definition with the given id. */
        processDefinitionId?: string;
        /** Restrict to tasks that belong to a process definition with the given key. */
        processDefinitionKey?: string;
        /**
         * Restrict to tasks that belong to a process definition with one of the given keys. The
         * keys need to be in a comma-separated list.
         */
        processDefinitionKeyIn?: string;
        /** Restrict to tasks that belong to a process definition with the given name. */
        processDefinitionName?: string;
        /**
         * Restrict to tasks that have a process definition name that has the parameter value as
         * a substring.
         */
        processDefinitionNameLike?: string;
        /** Restrict to tasks that belong to an execution with the given id. */
        executionId?: string;
        /** Restrict to tasks that belong to case instances with the given id. */
        caseInstanceId?: string;
        /** Restrict to tasks that belong to case instances with the given business key. */
        caseInstanceBusinessKey?: string;
        /**
         * Restrict to tasks that have a case instance business key that has the parameter value
         * as a substring.
         */
        caseInstanceBusinessKeyLike?: string;
        /** Restrict to tasks that belong to a case definition with the given id. */
        caseDefinitionId?: string;
        /** Restrict to tasks that belong to a case definition with the given key. */
        caseDefinitionKey?: string;
        /** Restrict to tasks that belong to a case definition with the given name. */
        caseDefinitionName?: string;
        /**
         * Restrict to tasks that have a case definition name that has the parameter value as a
         * substring.
         */
        caseDefinitionNameLike?: string;
        /** Restrict to tasks that belong to a case execution with the given id. */
        caseExecutionId?: string;
        /**
         * Only include tasks which belong to one of the passed and comma-separated activity
         * instance ids.
         */
        activityInstanceIdIn?: string;
        /**
         * Only include tasks which belong to one of the passed and comma-separated
         * tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include tasks which belong to no tenant. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /** Restrict to tasks that the given user is assigned to. */
        assignee?: string;
        /**
         * Restrict to tasks that the user described by the given expression is assigned to.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        assigneeExpression?: string;
        /**
         * Restrict to tasks that have an assignee that has the parameter
         * value as a substring.
         */
        assigneeLike?: string;
        /**
         * Restrict to tasks that have an assignee that has the parameter value described by the
         * given expression as a substring. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        assigneeLikeExpression?: string;
        /**
         * Only include tasks which are assigned to one of the passed and
         * comma-separated user ids.
         */
        assigneeIn?: string;
        /** Restrict to tasks that the given user owns. */
        owner?: string;
        /**
         * Restrict to tasks that the user described by the given expression owns. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        ownerExpression?: string;
        /** Only include tasks that are offered to the given group. */
        candidateGroup?: string;
        /**
         * Only include tasks that are offered to the group described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        candidateGroupExpression?: string;
        /** Only include tasks that are offered to the given user or to one of his groups. */
        candidateUser?: string;
        /**
         * Only include tasks that are offered to the user described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        candidateUserExpression?: string;
        /**
         * Also include tasks that are assigned to users in candidate queries. Default is to only
         * include tasks that are not assigned to any user if you query by candidate user or
         * group(s).
         */
        includeAssignedTasks?: boolean;
        /**
         * Only include tasks that the given user is involved in. A user is involved in a task if
         * an identity link exists between task and user (e.g., the user is the assignee).
         */
        involvedUser?: string;
        /**
         * Only include tasks that the user described by the given expression is involved in.
         * A user is involved in a task if an identity link exists between task and user
         * (e.g., the user is the assignee). See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        involvedUserExpression?: string;
        /** If set to `true`, restricts the query to all tasks that are assigned. */
        assigned?: boolean;
        /** If set to `true`, restricts the query to all tasks that are unassigned. */
        unassigned?: boolean;
        /** Restrict to tasks that have the given key. */
        taskDefinitionKey?: string;
        /**
         * Restrict to tasks that have one of the given keys. The keys need to be in a
         * comma-separated list.
         */
        taskDefinitionKeyIn?: string;
        /** Restrict to tasks that have a key that has the parameter value as a substring. */
        taskDefinitionKeyLike?: string;
        /** Restrict to tasks that have the given name. */
        name?: string;
        /** Restrict to tasks that do not have the given name. */
        nameNotEqual?: string;
        /** Restrict to tasks that have a name with the given parameter value as substring. */
        nameLike?: string;
        /**
         * Restrict to tasks that do not have a name with the given parameter
         * value as substring.
         */
        nameNotLike?: string;
        /** Restrict to tasks that have the given description. */
        description?: string;
        /**
         * Restrict to tasks that have a description that has the parameter
         * value as a substring.
         */
        descriptionLike?: string;
        /** Restrict to tasks that have the given priority. */
        priority?: number;
        /** Restrict to tasks that have a lower or equal priority. */
        maxPriority?: number;
        /** Restrict to tasks that have a higher or equal priority. */
        minPriority?: number;
        /**
         * Restrict to tasks that are due on the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.546+0200`.
         */
        dueDate?: string;
        /**
         * Restrict to tasks that are due on the date described by the given expression. See the
         * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        dueDateExpression?: string;
        /**
         * Restrict to tasks that are due after the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
         * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.435+0200`.
         */
        dueAfter?: string;
        /**
         * Restrict to tasks that are due after the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        dueAfterExpression?: string;
        /**
         * Restrict to tasks that are due before the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
         * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.243+0200`.
         */
        dueBefore?: string;
        /**
         * Restrict to tasks that are due before the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        dueBeforeExpression?: string;
        /**
         * Only include tasks which have no due date. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutDueDate?: boolean;
        /**
         * Restrict to tasks that have a followUp date on the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date
         * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.342+0200`.
         */
        followUpDate?: string;
        /**
         * Restrict to tasks that have a followUp date on the date described by the given
         * expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpDateExpression?: string;
        /**
         * Restrict to tasks that have a followUp date after the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the
         * date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.542+0200`.
         */
        followUpAfter?: string;
        /**
         * Restrict to tasks that have a followUp date after the date described by the given
         * expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpAfterExpression?: string;
        /**
         * Restrict to tasks that have a followUp date before the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the
         * date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.234+0200`.
         */
        followUpBefore?: string;
        /**
         * Restrict to tasks that have a followUp date before the date described by the given
         * expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpBeforeExpression?: string;
        /**
         * Restrict to tasks that have no followUp date or a followUp date before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.432+0200`. The
         * typical use case is to query all `active` tasks for a user for a given date.
         */
        followUpBeforeOrNotExistent?: string;
        /**
         * Restrict to tasks that have no followUp date or a followUp date before the date
         * described by the given expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpBeforeOrNotExistentExpression?: string;
        /**
         * Restrict to tasks that were created on the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
         * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.324+0200`.
         */
        createdOn?: string;
        /**
         * Restrict to tasks that were created on the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        createdOnExpression?: string;
        /**
         * Restrict to tasks that were created after the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.342+0200`.
         */
        createdAfter?: string;
        /**
         * Restrict to tasks that were created after the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        createdAfterExpression?: string;
        /**
         * Restrict to tasks that were created before the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.332+0200`.
         */
        createdBefore?: string;
        /**
         * Restrict to tasks that were created before the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        createdBeforeExpression?: string;
        /**
         * Restrict to tasks that are in the given delegation state. Valid values are
         * `PENDING` and `RESOLVED`.
         */
        delegationState?: "PENDING" | "RESOLVED";
        /**
         * Restrict to tasks that are offered to any of the given candidate groups. Takes a
         * comma-separated list of group names, so for example `developers,support,sales`.
         */
        candidateGroups?: string;
        /**
         * Restrict to tasks that are offered to any of the candidate groups described by the
         * given expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to
         * `java.util.List` of Strings.
         */
        candidateGroupsExpression?: string;
        /**
         * Only include tasks which have a candidate group. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withCandidateGroups?: boolean;
        /**
         * Only include tasks which have no candidate group. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutCandidateGroups?: boolean;
        /**
         * Only include tasks which have a candidate user. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withCandidateUsers?: boolean;
        /**
         * Only include tasks which have no candidate users. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutCandidateUsers?: boolean;
        /**
         * Only include active tasks. Value may only be `true`, as `false`
         * is the default behavior.
         */
        active?: boolean;
        /**
         * Only include suspended tasks. Value may only be `true`, as
         * `false` is the default behavior.
         */
        suspended?: boolean;
        /**
         * Only include tasks that have variables with certain values. Variable filtering
         * expressions are comma-separated and are structured as follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        taskVariables?: string;
        /**
         * Only include tasks that belong to process instances that have variables with certain
         * values. Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`;
         * `notLike`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        processVariables?: string;
        /**
         * Only include tasks that belong to case instances that have variables with certain
         * values. Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        caseInstanceVariables?: string;
        /**
         * Match all variable names in this query case-insensitively. If set
         * `variableName` and `variablename` are treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values in this query case-insensitively. If set
         * `variableValue` and `variablevalue` are treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
        /** Restrict query to all tasks that are sub tasks of the given task. Takes a task id. */
        parentTaskId?: string;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "instanceId"
          | "caseInstanceId"
          | "dueDate"
          | "executionId"
          | "caseExecutionId"
          | "assignee"
          | "created"
          | "description"
          | "id"
          | "name"
          | "nameCaseInsensitive"
          | "priority"
          | "processVariable"
          | "executionVariable"
          | "taskVariable"
          | "caseExecutionVariable"
          | "caseInstanceVariable";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["TaskDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator for variable
       * comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Queries for tasks that fulfill a given filter. This method is slightly more powerful
   * than the [Get Tasks](https://docs.camunda.org/manual/latest/reference/rest/task/get-query/) method because it
   * allows filtering by multiple process or task variables of types `String`, `Number`
   * or `Boolean`. The size of the result set can be retrieved by using the
   * [Get Task Count (POST)](https://docs.camunda.org/manual/latest/reference/rest/task/post-query-count/) method.
   *
   * **Security Consideration**:
   * There are several parameters (such as `assigneeExpression`) for specifying an EL
   * expression. These are disabled by default to prevent remote code execution. See the
   * section on
   * [security considerations for custom code](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
   * in the user guide for details.
   */
  queryTasks: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["TaskDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator for variable
       * comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TaskQueryDto"];
      };
    };
  };
  /**
   * Retrieves the number of tasks that fulfill a provided filter. Corresponds to the size
   * of the result set when using the [Get Tasks](https://docs.camunda.org/manual/latest/reference/rest/task/) method.
   *
   * **Security Consideration:** There are several query parameters (such as
   * assigneeExpression) for specifying an EL expression. These are disabled by default to
   * prevent remote code execution. See the section on
   * [security considerations](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
   * for custom code in the user guide for details.
   */
  getTasksCount: {
    parameters: {
      query: {
        /** Restrict to task with the given id. */
        taskId?: string;
        /** Restrict to tasks with any of the given ids. */
        taskIdIn?: string;
        /** Restrict to tasks that belong to process instances with the given id. */
        processInstanceId?: string;
        /** Restrict to tasks that belong to process instances with the given ids. */
        processInstanceIdIn?: string;
        /** Restrict to tasks that belong to process instances with the given business key. */
        processInstanceBusinessKey?: string;
        /**
         * Restrict to tasks that belong to process instances with the given business key which
         * is described by an expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        processInstanceBusinessKeyExpression?: string;
        /**
         * Restrict to tasks that belong to process instances with one of the give business keys.
         * The keys need to be in a comma-separated list.
         */
        processInstanceBusinessKeyIn?: string;
        /**
         * Restrict to tasks that have a process instance business key that has the parameter
         * value as a substring.
         */
        processInstanceBusinessKeyLike?: string;
        /**
         * Restrict to tasks that have a process instance business key that has the parameter
         * value as a substring and is described by an expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        processInstanceBusinessKeyLikeExpression?: string;
        /** Restrict to tasks that belong to a process definition with the given id. */
        processDefinitionId?: string;
        /** Restrict to tasks that belong to a process definition with the given key. */
        processDefinitionKey?: string;
        /**
         * Restrict to tasks that belong to a process definition with one of the given keys. The
         * keys need to be in a comma-separated list.
         */
        processDefinitionKeyIn?: string;
        /** Restrict to tasks that belong to a process definition with the given name. */
        processDefinitionName?: string;
        /**
         * Restrict to tasks that have a process definition name that has the parameter value as
         * a substring.
         */
        processDefinitionNameLike?: string;
        /** Restrict to tasks that belong to an execution with the given id. */
        executionId?: string;
        /** Restrict to tasks that belong to case instances with the given id. */
        caseInstanceId?: string;
        /** Restrict to tasks that belong to case instances with the given business key. */
        caseInstanceBusinessKey?: string;
        /**
         * Restrict to tasks that have a case instance business key that has the parameter value
         * as a substring.
         */
        caseInstanceBusinessKeyLike?: string;
        /** Restrict to tasks that belong to a case definition with the given id. */
        caseDefinitionId?: string;
        /** Restrict to tasks that belong to a case definition with the given key. */
        caseDefinitionKey?: string;
        /** Restrict to tasks that belong to a case definition with the given name. */
        caseDefinitionName?: string;
        /**
         * Restrict to tasks that have a case definition name that has the parameter value as a
         * substring.
         */
        caseDefinitionNameLike?: string;
        /** Restrict to tasks that belong to a case execution with the given id. */
        caseExecutionId?: string;
        /**
         * Only include tasks which belong to one of the passed and comma-separated activity
         * instance ids.
         */
        activityInstanceIdIn?: string;
        /**
         * Only include tasks which belong to one of the passed and comma-separated
         * tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include tasks which belong to no tenant. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutTenantId?: boolean;
        /** Restrict to tasks that the given user is assigned to. */
        assignee?: string;
        /**
         * Restrict to tasks that the user described by the given expression is assigned to.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        assigneeExpression?: string;
        /**
         * Restrict to tasks that have an assignee that has the parameter
         * value as a substring.
         */
        assigneeLike?: string;
        /**
         * Restrict to tasks that have an assignee that has the parameter value described by the
         * given expression as a substring. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        assigneeLikeExpression?: string;
        /**
         * Only include tasks which are assigned to one of the passed and
         * comma-separated user ids.
         */
        assigneeIn?: string;
        /** Restrict to tasks that the given user owns. */
        owner?: string;
        /**
         * Restrict to tasks that the user described by the given expression owns. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        ownerExpression?: string;
        /** Only include tasks that are offered to the given group. */
        candidateGroup?: string;
        /**
         * Only include tasks that are offered to the group described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        candidateGroupExpression?: string;
        /** Only include tasks that are offered to the given user or to one of his groups. */
        candidateUser?: string;
        /**
         * Only include tasks that are offered to the user described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        candidateUserExpression?: string;
        /**
         * Also include tasks that are assigned to users in candidate queries. Default is to only
         * include tasks that are not assigned to any user if you query by candidate user or
         * group(s).
         */
        includeAssignedTasks?: boolean;
        /**
         * Only include tasks that the given user is involved in. A user is involved in a task if
         * an identity link exists between task and user (e.g., the user is the assignee).
         */
        involvedUser?: string;
        /**
         * Only include tasks that the user described by the given expression is involved in.
         * A user is involved in a task if an identity link exists between task and user
         * (e.g., the user is the assignee). See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions.
         */
        involvedUserExpression?: string;
        /** If set to `true`, restricts the query to all tasks that are assigned. */
        assigned?: boolean;
        /** If set to `true`, restricts the query to all tasks that are unassigned. */
        unassigned?: boolean;
        /** Restrict to tasks that have the given key. */
        taskDefinitionKey?: string;
        /**
         * Restrict to tasks that have one of the given keys. The keys need to be in a
         * comma-separated list.
         */
        taskDefinitionKeyIn?: string;
        /** Restrict to tasks that have a key that has the parameter value as a substring. */
        taskDefinitionKeyLike?: string;
        /** Restrict to tasks that have the given name. */
        name?: string;
        /** Restrict to tasks that do not have the given name. */
        nameNotEqual?: string;
        /** Restrict to tasks that have a name with the given parameter value as substring. */
        nameLike?: string;
        /**
         * Restrict to tasks that do not have a name with the given parameter
         * value as substring.
         */
        nameNotLike?: string;
        /** Restrict to tasks that have the given description. */
        description?: string;
        /**
         * Restrict to tasks that have a description that has the parameter
         * value as a substring.
         */
        descriptionLike?: string;
        /** Restrict to tasks that have the given priority. */
        priority?: number;
        /** Restrict to tasks that have a lower or equal priority. */
        maxPriority?: number;
        /** Restrict to tasks that have a higher or equal priority. */
        minPriority?: number;
        /**
         * Restrict to tasks that are due on the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.546+0200`.
         */
        dueDate?: string;
        /**
         * Restrict to tasks that are due on the date described by the given expression. See the
         * [User Guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        dueDateExpression?: string;
        /**
         * Restrict to tasks that are due after the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
         * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.435+0200`.
         */
        dueAfter?: string;
        /**
         * Restrict to tasks that are due after the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        dueAfterExpression?: string;
        /**
         * Restrict to tasks that are due before the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
         * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.243+0200`.
         */
        dueBefore?: string;
        /**
         * Restrict to tasks that are due before the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        dueBeforeExpression?: string;
        /**
         * Only include tasks which have no due date. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutDueDate?: boolean;
        /**
         * Restrict to tasks that have a followUp date on the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date
         * must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.342+0200`.
         */
        followUpDate?: string;
        /**
         * Restrict to tasks that have a followUp date on the date described by the given
         * expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpDateExpression?: string;
        /**
         * Restrict to tasks that have a followUp date after the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the
         * date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.542+0200`.
         */
        followUpAfter?: string;
        /**
         * Restrict to tasks that have a followUp date after the date described by the given
         * expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpAfterExpression?: string;
        /**
         * Restrict to tasks that have a followUp date before the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the
         * date must have the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g.,
         * `2013-01-23T14:42:45.234+0200`.
         */
        followUpBefore?: string;
        /**
         * Restrict to tasks that have a followUp date before the date described by the given
         * expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpBeforeExpression?: string;
        /**
         * Restrict to tasks that have no followUp date or a followUp date before the given date.
         * By [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.432+0200`. The
         * typical use case is to query all `active` tasks for a user for a given date.
         */
        followUpBeforeOrNotExistent?: string;
        /**
         * Restrict to tasks that have no followUp date or a followUp date before the date
         * described by the given expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        followUpBeforeOrNotExistentExpression?: string;
        /**
         * Restrict to tasks that were created on the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have
         * the format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.324+0200`.
         */
        createdOn?: string;
        /**
         * Restrict to tasks that were created on the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        createdOnExpression?: string;
        /**
         * Restrict to tasks that were created after the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.342+0200`.
         */
        createdAfter?: string;
        /**
         * Restrict to tasks that were created after the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        createdAfterExpression?: string;
        /**
         * Restrict to tasks that were created before the given date. By
         * [default](https://docs.camunda.org/manual/latest/reference/rest/overview/date-format/), the date must have the
         * format `yyyy-MM-dd'T'HH:mm:ss.SSSZ`, e.g., `2013-01-23T14:42:45.332+0200`.
         */
        createdBefore?: string;
        /**
         * Restrict to tasks that were created before the date described by the given expression.
         * See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to a
         * `java.util.Date` or `org.joda.time.DateTime` object.
         */
        createdBeforeExpression?: string;
        /**
         * Restrict to tasks that are in the given delegation state. Valid values are
         * `PENDING` and `RESOLVED`.
         */
        delegationState?: "PENDING" | "RESOLVED";
        /**
         * Restrict to tasks that are offered to any of the given candidate groups. Takes a
         * comma-separated list of group names, so for example `developers,support,sales`.
         */
        candidateGroups?: string;
        /**
         * Restrict to tasks that are offered to any of the candidate groups described by the
         * given expression. See the
         * [user guide](https://docs.camunda.org/manual/latest/user-guide/process-engine/expression-language/#internal-context-functions)
         * for more information on available functions. The expression must evaluate to
         * `java.util.List` of Strings.
         */
        candidateGroupsExpression?: string;
        /**
         * Only include tasks which have a candidate group. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withCandidateGroups?: boolean;
        /**
         * Only include tasks which have no candidate group. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutCandidateGroups?: boolean;
        /**
         * Only include tasks which have a candidate user. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withCandidateUsers?: boolean;
        /**
         * Only include tasks which have no candidate users. Value may only be `true`,
         * as `false` is the default behavior.
         */
        withoutCandidateUsers?: boolean;
        /**
         * Only include active tasks. Value may only be `true`, as `false`
         * is the default behavior.
         */
        active?: boolean;
        /**
         * Only include suspended tasks. Value may only be `true`, as
         * `false` is the default behavior.
         */
        suspended?: boolean;
        /**
         * Only include tasks that have variables with certain values. Variable filtering
         * expressions are comma-separated and are structured as follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        taskVariables?: string;
        /**
         * Only include tasks that belong to process instances that have variables with certain
         * values. Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`;
         * `notLike`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        processVariables?: string;
        /**
         * Only include tasks that belong to case instances that have variables with certain
         * values. Variable filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`. `key` is the variable name,
         * `operator` is the comparison operator to be used and `value` the variable value.
         *
         * **Note**: Values are always treated as String objects on server side.
         *
         * Valid `operator` values are:
         * `eq` - equal to;
         * `neq` - not equal to;
         * `gt` - greater than;
         * `gteq` - greater than or equal to;
         * `lt` - lower than;
         * `lteq` - lower than or equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        caseInstanceVariables?: string;
        /**
         * Match all variable names in this query case-insensitively. If set
         * `variableName` and `variablename` are treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values in this query case-insensitively. If set
         * `variableValue` and `variablevalue` are treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
        /** Restrict query to all tasks that are sub tasks of the given task. Takes a task id. */
        parentTaskId?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the number of tasks that fulfill the given filter. Corresponds to the size
   * of the result set of the [Get Tasks (POST)](https://docs.camunda.org/manual/latest/reference/rest/task/post-query/)
   * method and takes the same parameters.
   *
   * **Security Consideration**:
   * There are several parameters (such as `assigneeExpression`) for specifying an EL
   * expression. These are disabled by default to prevent remote code execution. See the
   * section on
   * [security considerations for custom code](https://docs.camunda.org/manual/latest/user-guide/process-engine/securing-custom-code/)
   * in the user guide for details.
   */
  queryTasksCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TaskQueryDto"];
      };
    };
  };
  /** Creates a new task. */
  createTask: {
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if a not valid `delegationState` is supplied. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TaskDto"];
      };
    };
  };
  /** Retrieves a task by id. */
  getTask: {
    parameters: {
      path: {
        /** The id of the task to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["TaskDto"];
        };
      };
      /**
       * Task with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Updates a task. */
  updateTask: {
    parameters: {
      path: {
        /** The id of the task to be updated. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if a not valid `delegationState` is supplied. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** If the corresponding task cannot be found. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TaskDto"];
      };
    };
  };
  /** Removes a task by id. */
  deleteTask: {
    parameters: {
      path: {
        /** The id of the task to be removed. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Bad Request. The Task with the given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The Task with the given id cannot be deleted because it is part of a running process or case instance.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for
       * the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Changes the assignee of a task to a specific user.
   *
   * **Note:** The difference with the [Claim Task](https://docs.camunda.org/manual/latest/reference/rest/task/post-claim/)
   * method is that this method does not check if the task already has a user
   * assigned to it.
   */
  setAssignee: {
    parameters: {
      path: {
        /** The id of the task to set the assignee for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Task with given id does not exist or setting the assignee was not successful.
       * See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** Provide the id of the user that will be the assignee of the task. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["UserIdDto"];
      };
    };
  };
  /** Gets the attachments for a task. */
  getAttachments: {
    parameters: {
      path: {
        /** The id of the task to retrieve the attachments for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["AttachmentDto"][];
        };
      };
      /**
       * No task exists for the given task id. See the [Introduction](/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Creates an attachment for a task. */
  addAttachment: {
    parameters: {
      path: {
        /** The id of the task to add the attachment to. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["AttachmentDto"];
        };
      };
      /**
       * The task does not exists or task id is null. No content or url to remote content exists. See the
       * [Introduction](/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The history of the engine is disabled. See the [Introduction](/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["MultiFormAttachmentDto"];
      };
    };
  };
  /** Retrieves a task attachment by task id and attachment id. */
  getAttachment: {
    parameters: {
      path: {
        /** The id of the task. */
        id: string;
        /** The id of the attachment to be retrieved. */
        attachmentId: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["AttachmentDto"];
        };
      };
      /**
       * The attachment for the given task and attachment id does not exist or the history of the engine is
       * disabled.
       *
       * See the [Introduction](/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Removes an attachment from a task by id. */
  deleteAttachment: {
    parameters: {
      path: {
        /** The id of the task. */
        id: string;
        /** The id of the attachment to be removed. */
        attachmentId: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The history of the engine is disabled. See the [Introduction](/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * A Task Attachment for the given task id and attachment id does not exist. See the
       * [Introduction](/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the binary content of a task attachment by task id and attachment id. */
  getAttachmentData: {
    parameters: {
      path: {
        /** The id of the task. */
        id: string;
        /** The id of the attachment to be retrieved. */
        attachmentId: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/octet-stream": string;
          "text/plain": string;
        };
      };
      /**
       * The attachment content for the given task id and attachment id does not exist, or the history of the
       * engine is disabled.
       *
       * See the [Introduction](/reference/rest/overview/#error-handling) for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Reports a business error in the context of a running task by id. The error code must
   * be specified to identify the BPMN error handler. See the documentation for
   * [Reporting Bpmn Error](https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/#reporting-bpmn-error)
   * in User Tasks.
   */
  handleBpmnError: {
    parameters: {
      path: {
        /** The id of the task a BPMN error is reported for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the `errorCode` or `id` are not present in the request. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * If the authenticated user is unauthorized to update the task. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TaskBpmnErrorDto"];
      };
    };
  };
  /**
   * Reports an escalation in the context of a running task by id. The escalation code must
   * be specified to identify the escalation handler. See the documentation for
   * [Reporting Bpmn Escalation](https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/#reporting-bpmn-escalation)
   * in User Tasks.
   */
  handleEscalation: {
    parameters: {
      path: {
        /** The id of the task in which context a BPMN escalation is reported. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Returned if the <code>escalationCode</code> is not provided in
       * the request. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * If the authenticated user is unauthorized to update the process instance. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * Returned if the task does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TaskEscalationDto"];
      };
    };
  };
  /**
   * Claims a task for a specific user.
   *
   * **Note:** The difference with the
   * [Set Assignee](https://docs.camunda.org/manual/latest/reference/rest/task/post-assignee/)
   * method is that here a check is performed to see if the task already has a user
   * assigned to it.
   */
  claim: {
    parameters: {
      path: {
        /** The id of the task to claim. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Task with given id does not exist or claiming was not successful. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** Provide the id of the user that claims the task. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["UserIdDto"];
      };
    };
  };
  /** Gets the comments for a task by id. */
  getComments: {
    parameters: {
      path: {
        /** The id of the task to retrieve the comments for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CommentDto"][];
        };
      };
      /**
       * No task exists for the given task id. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Creates a comment for a task by id. */
  createComment: {
    parameters: {
      path: {
        /** The id of the task to add the comment to. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CommentDto"];
        };
      };
      /**
       * The task does not exist or no comment message was submitted. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The history of the engine is disabled. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
    };
    /** **Note:** Only the `message` property will be used. Every other property passed to this endpoint will be ignored. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["CommentDto"];
      };
    };
  };
  /** Retrieves a task comment by task id and comment id. */
  getComment: {
    parameters: {
      path: {
        /** The id of the task. */
        id: string;
        /** The id of the comment to be retrieved. */
        commentId: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CommentDto"];
        };
      };
      /**
       * The task or comment with given task and comment id does not exist, or the history of
       * the engine is disabled. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Completes a task and updates process variables. */
  complete: {
    parameters: {
      path: {
        /** The id of the task to complete. */
        id: string;
      };
    };
    responses: {
      /** Request successful. The response contains the process variables. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /** Request successful. The response contains no variables. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed
       * to an Integer value or the passed variable type is not supported. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * If the task does not exist or the corresponding process instance could not be
       * resumed successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CompleteTaskDto"];
      };
    };
  };
  /** Delegates a task to another user. */
  delegateTask: {
    parameters: {
      path: {
        /** The id of the task to delegate. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * If the task does not exist or delegation was not successful. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** Provide the id of the user that the task should be delegated to. */
    requestBody: {
      content: {
        "application/json": components["schemas"]["UserIdDto"];
      };
    };
  };
  /**
   * Retrieves the deployed form that is referenced from a given task. For further
   * information please refer to the
   * [User Guide](https://docs.camunda.org/manual/latest/user-guide/task-forms/#embedded-task-forms).
   */
  getDeployedForm: {
    parameters: {
      path: {
        /** The id of the task to get the deployed form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
          "application/json": string;
        };
      };
      /**
       * The form key has wrong format. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The deployed form cannot be retrieved due to missing permissions on task resource.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      403: {
        content: {
          "application/json": components["schemas"]["AuthorizationExceptionDto"];
        };
      };
      /**
       * No deployed form for a given task exists. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the form key for a task. The form key corresponds to the `FormData#formKey`
   * property in the engine. This key can be used to do task-specific form rendering in
   * client applications. Additionally, the context path of the containing process
   * application is returned.
   */
  getForm: {
    parameters: {
      path: {
        /** The id of the task to retrieve the form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["FormDto"];
        };
      };
      /**
       * Task with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the form variables for a task. The form variables take form data specified
   * on the task into account. If form fields are defined, the variable types and default
   * values of the form fields are taken into account.
   */
  getFormVariables: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variables for. */
        id: string;
      };
      query: {
        /**
         * A comma-separated list of variable names. Allows restricting the list of requested
         * variables to the variable names in the list. It is best practice to restrict the
         * list of variables to the variables actually required by the form in order to
         * minimize fetching of data. If the query parameter is ommitted all variables are
         * fetched. If the query parameter contains non-existent variable names, the variable
         * names are ignored.
         */
        variableNames?: string;
        /**
         * Determines whether serializable variable values (typically variables that store
         * custom Java objects) should be deserialized on server side (default true).
         *
         * If set to true, a serializable variable will be deserialized on server side and
         * transformed to JSON using [Jackson's](http://jackson.codehaus.org/) POJO/bean
         * property introspection feature. Note that this requires the Java classes of the
         * variable value to be on the REST API's classpath.
         *
         * If set to false, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string
         * containing XML.
         *
         * Note: While true is the default value for reasons of backward compatibility, we
         * recommend setting this parameter to false when developing web applications that are
         * independent of the Java process applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. A JSON object containing a property for each variable returned. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * id is null or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Gets the identity links for a task by id, which are the users and groups that are in
   * *some* relation to it (including assignee and owner).
   */
  getIdentityLinks: {
    parameters: {
      path: {
        /** The id of the task to retrieve the identity links for. */
        id: string;
      };
      query: {
        /** Filter by the type of links to include. */
        type?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["IdentityLinkDto"][];
        };
      };
      /**
       * Task with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Adds an identity link to a task by id. Can be used to link any user or group to a task
   * and specify a relation.
   */
  addIdentityLink: {
    parameters: {
      path: {
        /** The id of the task to add a link to. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Task with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["IdentityLinkDto"];
      };
    };
  };
  /** Removes an identity link from a task by id */
  deleteIdentityLink: {
    parameters: {
      path: {
        /** The id of the task to remove a link from. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Task with given id does not exist.
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for
       * the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["IdentityLinkDto"];
      };
    };
  };
  /** Retrieves all variables of a given task by id. */
  getTaskLocalVariables: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variables from. */
        id: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on the server side (default `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * **Note:** While `true` is the default value for reasons of backward compatibility, we recommend setting this
         * parameter to `false` when developing web applications that are independent of the Java process
         * applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates or deletes the variables in the context of a task. Updates precede deletions. So, if a variable is
   * updated AND deleted, the deletion overrides the update.
   */
  modifyTaskLocalVariables: {
    parameters: {
      path: {
        /** The id of the task to set variables for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable value or type is invalid. For example the value could not be parsed to an `Integer` value
       * or the passed variable type is not supported. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Update or delete could not be executed because the task is `null` or does not exist.. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PatchVariablesDto"];
      };
    };
  };
  /** Retrieves a variable from the context of a given task by id. */
  getTaskLocalVariable: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variable from. */
        id: string;
        /** The name of the variable to get */
        varName: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on the server side (default `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * Note: While `true` is the default value for reasons of backward compatibility, we recommend setting this
         * parameter to `false` when developing web applications that are independent of the Java process
         * applications deployed to the engine.
         */
        deserializeValue?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableValueDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Sets a variable in the context of a given task. */
  putTaskLocalVariable: {
    parameters: {
      path: {
        /** The id of the task to set the variable for. */
        id: string;
        /** The name of the variable to set. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable name, value or type is invalid, for example if the value could not be parsed to an `Integer`
       * value or the passed variable type is not supported or a new transient variable has the name that is
       * already persisted. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The variable name is `null`, or the Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["VariableValueDto"];
      };
    };
  };
  /** Removes a local variable from a task by id. */
  deleteTaskLocalVariable: {
    parameters: {
      path: {
        /** The id of the task to delete the variable from. */
        id: string;
        /** The name of the variable to be removed. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves a binary variable from the context of a given task by id. Applicable for byte array and file
   * variables.
   */
  getTaskLocalVariableBinary: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
    };
    responses: {
      /**
       * Request successful.
       *         For binary variables or files without any MIME type information, a byte stream is returned.
       *         File variables with MIME type information are returned as the saved type.
       *         Additionally, for file variables the Content-Disposition header will be set.
       */
      200: {
        content: {
          "application/octet-stream": string;
          "text/plain": string;
        };
      };
      /**
       * Variable with given id exists but is not a binary variable.See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Sets the serialized value for a binary variable or the binary value for a file variable. */
  setBinaryTaskLocalVariable: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable value or type is invalid, for example if no filename is set. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Variable name is `null`, or the Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** For binary variables a multipart form submit with the following parts: */
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["MultiFormVariableBinaryDto"];
      };
    };
  };
  /**
   * Retrieves the rendered form for a task. This method can be used to get the HTML
   * rendering of a
   * [Generated Task Form](https://docs.camunda.org/manual/latest/user-guide/task-forms/#generated-task-forms).
   */
  getRenderedForm: {
    parameters: {
      path: {
        /** The id of the task to get the rendered form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/xhtml+xml": string;
        };
      };
      /**
       * The task with the given id does not exist or has no form field metadata defined for
       * this task. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Resolves a task and updates execution variables.
   *
   * Resolving a task marks that the assignee is done with the task delegated to them, and
   * that it can be sent back to the owner. Can only be executed when the task has been
   * delegated. The assignee will be set to the owner, who performed the delegation.
   */
  resolve: {
    parameters: {
      path: {
        /** The id of the task to resolve. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed
       * to an Integer value or the passed variable type is not supported. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * If the task does not exist or the corresponding process instance could not be
       * resumed successfully. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CompleteTaskDto"];
      };
    };
  };
  /**
   * Completes a task and updates process variables using a form submit. There are two
   * difference between this method and the `complete` method:
   *
   * * If the task is in state `PENDING` - i.e., has been delegated before, it is not
   * completed but resolved. Otherwise it will be completed.
   * * If the task has Form Field Metadata defined, the process engine will perform backend
   * validation for any form fields which have validators defined.
   * See the
   * [Generated Task Forms](https://docs.camunda.org/manual/latest/user-guide/task-forms/_index/#generated-task-forms)
   * section of the [User Guide](https://docs.camunda.org/manual/latest/user-guide/) for more information.
   */
  submit: {
    parameters: {
      path: {
        /** The id of the task to submit the form for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. The response contains the process variables. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /** Request successful. The response contains no variables. */
      204: never;
      /**
       * The variable value or type is invalid, for example if the value could not be parsed to an Integer value
       * or the passed variable type is not supported.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for
       * the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * If the task does not exist or the corresponding process instance could not be resumed successfully.
       *
       * See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling) for
       * the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CompleteTaskDto"];
      };
    };
  };
  /** Resets a task's assignee. If successful, the task is not assigned to a user. */
  unclaim: {
    parameters: {
      path: {
        /** The id of the task to unclaim. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The Task with the given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves all variables visible from the task. A variable is visible from the task if it is a local task
   * variable or declared in a parent scope of the task. See documentation on
   * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
   */
  getTaskVariables: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variables from. */
        id: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on the server side (default `true`).
         * If set to `true`, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * Note: While `true` is the default value for reasons of backward compatibility, we recommend setting this
         * parameter to `false` when developing web applications that are independent of the Java process
         * applications deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": {
            [key: string]: components["schemas"]["VariableValueDto"];
          };
        };
      };
      /**
       * Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates or deletes the variables visible from the task. Updates precede deletions. So, if a variable is
   * updated AND deleted, the deletion overrides the update. A variable is visible from the task if it is a
   * local task variable or declared in a parent scope of the task. See documentation on
   * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
   */
  modifyTaskVariables: {
    parameters: {
      path: {
        /** The id of the task to set variables for. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable value or type is invalid. For example the value could not be parsed to an `Integer` value
       * or the passed variable type is not supported. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Update or delete could not be executed because the task is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["PatchVariablesDto"];
      };
    };
  };
  /**
   * Retrieves a variable from the context of a given task.
   * The variable must be visible from the task. It is visible from the task if it is a local task variable or
   * declared in a parent scope of the task. See documentation on
   * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
   */
  getTaskVariable: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variable from. */
        id: string;
        /** The name of the variable to get. */
        varName: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on the server side (default `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * Note: While `true` is the default value for reasons of backward compatibility, we recommend setting this
         * parameter to `false` when developing web applications that are independent of the Java process
         * applications deployed to the engine.
         */
        deserializeValue?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableValueDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Updates a process variable that is visible from the Task scope. A variable is visible from the task if it
   * is a local task variable, or declared in a parent scope of the task. See the documentation on
   * [variable scopes and visibility](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables#variable-scopes-and-variable-visibility).
   *
   * **Note**: If a variable doesn't exist, the variable is created in the top-most scope
   * visible from the task.
   */
  putTaskVariable: {
    parameters: {
      path: {
        /** The id of the task to set the variable for. */
        id: string;
        /** The name of the variable to set. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable name, value or type is invalid, for example if the value could not be parsed to an `Integer`
       * value or the passed variable type is not supported or a new transient variable has the name that is
       * already persisted. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The variable name is `null`, or the Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["VariableValueDto"];
      };
    };
  };
  /**
   * Removes a variable that is visible to a task. A variable is visible to a task if it is a local task
   * variable or declared in a parent scope of the task. See documentation on
   * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
   */
  deleteTaskVariable: {
    parameters: {
      path: {
        /** The id of the task to delete the variable from. */
        id: string;
        /** The name of the variable to be removed. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * Task id is null or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves a binary variable from the context of a given task. Applicable for byte array and file
   * variables. The variable must be visible from the task. It is visible from the task if it is a local task
   * variable or declared in a parent scope of the task. See documentation on
   * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
   */
  getTaskVariableBinary: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
    };
    responses: {
      /**
       * Request successful.
       *         For binary variables or files without any MIME type information, a byte stream is returned.
       *         File variables with MIME type information are returned as the saved type.
       *         Additionally, for file variables the Content-Disposition header will be set.
       */
      200: {
        content: {
          "application/octet-stream": string;
          "text/plain": string;
        };
      };
      /**
       * Variable with given id exists but is not a binary variable.See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Sets the serialized value for a binary variable or the binary value for a file variable visible from the
   * task. A variable is visible from the task if it is a local task variable or declared in a parent scope of
   * the task. See documentation on
   * [visiblity of variables](https://docs.camunda.org/manual/latest/user-guide/process-engine/variables/).
   */
  setBinaryTaskVariable: {
    parameters: {
      path: {
        /** The id of the task to retrieve the variable for. */
        id: string;
        /** The name of the variable to retrieve. */
        varName: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /**
       * The variable value or type is invalid, for example if no filename is set. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Variable name is `null`, or the Task id is `null` or does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    /** For binary variables a multipart form submit with the following parts: */
    requestBody: {
      content: {
        "multipart/form-data": components["schemas"]["MultiFormVariableBinaryDto"];
      };
    };
  };
  /** Fetches Telemetry Configuration. */
  getTelemetryConfiguration: {
    parameters: {};
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["TelemetryConfigurationDto"];
        };
      };
      /** If the user who perform the operation is not a <b>camunda-admin</b> user. */
      401: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Configures whether Camunda receives data collection of the process engine setup and usage. */
  configureTelemetry: {
    parameters: {};
    responses: {
      /** Request successful. */
      204: never;
      /** If the user who perform the operation is not a <b>camunda-admin</b> user. */
      401: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TelemetryConfigurationDto"];
      };
    };
  };
  /**
   * Query for a list of tenants using a list of parameters. The size of the result set
   * can be retrieved by using the [Get Tenant
   * Count](https://docs.camunda.org/manual/latest/reference/rest/tenant/get-query-count/) method.
   */
  queryTenants: {
    parameters: {
      query: {
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "id" | "name";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /** Filter by the id of the tenant. */
        id?: string;
        /** Filter by the name of the tenant. */
        name?: string;
        /** Filter by the name that the parameter is a substring of. */
        nameLike?: string;
        /** Select only tenants where the given user is a member of. */
        userMember?: string;
        /** Select only tenants where the given group is a member of. */
        groupMember?: string;
        /**
         * Select only tenants where the user or one of his groups is a member of.
         * Can only be used in combination with the `userMember` parameter. Value may only be `true`,
         * as `false` is the default behavior.
         */
        includingGroupsOfUser?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["TenantDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy` is specified. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * The `/tenant` resource supports two custom OPTIONS requests, this one for the resource
   * as such and one for individual tenant instances. The OPTIONS request
   * allows checking for the set of available operations that the currently
   * authenticated user can perform on the `/tenant` resource. If the user
   * can perform an operation or not may depend on various things,
   * including the users authorizations to interact with this resource and
   * the internal configuration of the process engine.
   */
  availableTenantResourceOperations: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /** Query for tenants using a list of parameters and retrieves the count. */
  getTenantCount: {
    parameters: {
      query: {
        /** Filter by the id of the tenant. */
        id?: string;
        /** Filter by the name of the tenant. */
        name?: string;
        /** Filter by the name that the parameter is a substring of. */
        nameLike?: string;
        /** Select only tenants where the given user is a member of. */
        userMember?: string;
        /** Select only tenants where the given group is a member of. */
        groupMember?: string;
        /**
         * Select only tenants where the user or one of his groups is a member of.
         * Can only be used in combination with the `userMember` parameter. Value may only be `true`,
         * as `false` is the default behavior.
         */
        includingGroupsOfUser?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Create a new tenant. */
  createTenant: {
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The tenant could not be created due to an internal server error. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TenantDto"];
      };
    };
  };
  /** Retrieves a tenant. */
  getTenant: {
    parameters: {
      path: {
        /** The id of the tenant to be retrieved. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["TenantDto"];
        };
      };
      /**
       * Tenant with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Updates a given tenant. */
  updateTenant: {
    parameters: {
      path: {
        /** The id of the tenant. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** If the tenant with the requested Id cannot be found. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The tenant could not be updated due to an internal server error. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["TenantDto"];
      };
    };
  };
  /** Deletes a tenant by id. */
  deleteTenant: {
    parameters: {
      path: {
        /** The id of the tenant to be deleted. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Tenant cannot be found. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * The `/tenant` resource supports two custom OPTIONS requests, one for the resource as such and this one for
   * individual tenant instances. The OPTIONS request allows checking for the set of available operations that
   * the currently authenticated user can perform on the `/tenant/{id}` resource. If the user can perform an
   * operation or not may depend on various things, including the users authorizations to interact with this
   * resource and the internal configuration of the process engine.
   */
  availableTenantInstanceOperations: {
    parameters: {
      path: {
        /** The id of the tenant */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /**
   * The OPTIONS request allows checking for the set of available operations that the
   * currently authenticated user can perform on the resource. If the user
   * can perform an operation or not may depend on various things,
   * including the users authorizations to interact with this resource and
   * the internal configuration of the process engine.
   */
  availableTenantGroupMembersOperations: {
    parameters: {
      path: {
        /** The id of the tenant */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /** Creates a membership between a tenant and a group. */
  createGroupMembership: {
    parameters: {
      path: {
        /** The id of the tenant. */
        id: string;
        /** The id of the group. */
        groupId: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case an internal error occurs. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Creates a membership between a tenant and a group. */
  deleteGroupMembership: {
    parameters: {
      path: {
        /** The id of the tenant. */
        id: string;
        /** The id of the group. */
        groupId: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case an internal error occurs. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * The OPTIONS request allows checking for the set of available operations that the
   * currently authenticated user can perform on the resource. If the user
   * can perform an operation or not may depend on various things,
   * including the users authorizations to interact with this resource and
   * the internal configuration of the process engine.
   */
  availableTenantUserMembersOperations: {
    parameters: {
      path: {
        /** The id of the tenant */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /** Creates a membership between a tenant and an user. */
  createUserMembership: {
    parameters: {
      path: {
        /** The id of the tenant. */
        id: string;
        /** The id of the user. */
        userId: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case an internal error occurs. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Deletes a membership between a tenant and an user. */
  deleteUserMembership: {
    parameters: {
      path: {
        /** The id of the tenant. */
        id: string;
        /** The id of the user. */
        userId: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only. */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * In case an error occurs. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Query for a list of users using a list of parameters.
   * The size of the result set can be retrieved by using the Get User Count method.
   * [Get User Count](https://docs.camunda.org/manual/latest/reference/rest/user/get-query-count/) method.
   */
  getUsers: {
    parameters: {
      query: {
        /** Filter by user id */
        id?: string;
        /** Filter by a comma-separated list of user ids. */
        idIn?: string;
        /** Filter by the first name of the user. Exact match. */
        firstName?: string;
        /** Filter by the first name that the parameter is a substring of. */
        firstNameLike?: string;
        /** Filter by the last name of the user. Exact match. */
        lastName?: string;
        /** Filter by the last name that the parameter is a substring of. */
        lastNameLike?: string;
        /** Filter by the email of the user. Exact match. */
        email?: string;
        /** Filter by the email that the parameter is a substring of. */
        emailLike?: string;
        /** Filter for users which are members of the given group. */
        memberOfGroup?: string;
        /** Filter for users which are members of the given tenant. */
        memberOfTenant?: string;
        /** Only select Users that are potential starter for the given process definition. */
        potentialStarter?: string;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?: "userId" | "firstName" | "lastName" | "email";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["UserProfileDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder` parameter is supplied,
       * but no `sortBy`, or if an invalid operator for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * The `/user` resource supports two custom `OPTIONS` requests, one for the resource as such
   * and one for individual user instances. The `OPTIONS` request allows checking for the set of
   * available operations that the currently authenticated user can perform on the /user resource.
   * If the user can perform an operation or not may depend on various things, including the user's
   * authorizations to interact with this resource and the internal configuration of the process
   * engine. `OPTIONS /user` returns available interactions on the resource.
   */
  availableOperations: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /**
   * Queries for the number of deployments that fulfill given parameters. Takes the same parameters as the
   * [Get Users](https://docs.camunda.org/manual/latest/reference/rest/user/get-query/) method.
   */
  getUserCount: {
    parameters: {
      query: {
        /** Filter by user id */
        id?: string;
        /** Filter by a comma-separated list of user ids. */
        idIn?: string;
        /** Filter by the first name of the user. Exact match. */
        firstName?: string;
        /** Filter by the first name that the parameter is a substring of. */
        firstNameLike?: string;
        /** Filter by the last name of the user. Exact match. */
        lastName?: string;
        /** Filter by the last name that the parameter is a substring of. */
        lastNameLike?: string;
        /** Filter by the email of the user. Exact match. */
        email?: string;
        /** Filter by the email that the parameter is a substring of. */
        emailLike?: string;
        /** Filter for users which are members of the given group. */
        memberOfGroup?: string;
        /** Filter for users which are members of the given tenant. */
        memberOfTenant?: string;
        /** Only select Users that are potential starter for the given process definition. */
        potentialStarter?: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example, if an invalid operator for variable
       * comparison is used. See the [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Create a new user. */
  createUser: {
    responses: {
      /** Request successful. */
      204: never;
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["UserDto"];
      };
    };
  };
  /** Deletes a user by id. */
  deleteUser: {
    parameters: {
      path: {
        /** The id of the user to be deleted. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
      /**
       * A Deployment with the provided id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * The `/user` resource supports two custom `OPTIONS` requests, one for the resource as such
   * and one for individual user instances. The `OPTIONS` request allows checking for the set of
   * available operations that the currently authenticated user can perform on the /user resource.
   * If the user can perform an operation or not may depend on various things, including the user's
   * authorizations to interact with this resource and the internal configuration of the process
   * engine. `OPTIONS /user/{id}` returns available interactions on a resource instance.
   */
  availableUserOperations: {
    parameters: {
      path: {
        /** The id of the user to be deleted. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["ResourceOptionsDto"];
        };
      };
    };
  };
  /** Updates a user's credentials (password) */
  updateCredentials: {
    parameters: {
      path: {
        /** The id of the user to be updated. */
        id: string;
      };
      query: {
        /** The users new password. */
        password: string;
        /**
         * The password of the authenticated user who changes the password of the user
         * (i.e., the user with passed id as path parameter).
         */
        authenticatedUserPassword: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
      /** The authenticated user password does not match */
      400: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
      /** If the corresponding user cannot be found */
      404: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
      /**
       * The user could not be updated due to an internal server error. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["UserCredentialsDto"];
      };
    };
  };
  /** Retrieves a user's profile. */
  getUserProfile: {
    parameters: {
      path: {
        /** The id of the user to retrieve. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["UserProfileDto"];
        };
      };
      /**
       * Execution with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Updates the profile information of an already existing user. */
  updateProfile: {
    parameters: {
      path: {
        /** The id of the user. */
        id: string;
      };
    };
    responses: {
      /** Request successful. This method returns no content. */
      204: never;
      /** Identity service is read-only (Cannot modify users / groups / memberships). */
      403: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /** If the user with the requested Id cannot be found. */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * The user could not be updated due to an internal server error. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      500: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["UserProfileDto"];
      };
    };
  };
  /** Unlocks a user by id. */
  unlockUser: {
    parameters: {
      path: {
        /** The id of the user to be unlocked. */
        id: string;
      };
    };
    responses: {
      /** Request successful. */
      204: never;
      /** The user who performed the operation is not a Camunda admin user. */
      403: {
        content: {
          "application/json": { [key: string]: any };
        };
      };
      /**
       * User cannot be found. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Query for variable instances that fulfill given parameters. Parameters may be the
   * properties of variable instances, such as the name or type. The size
   * of the result set can be retrieved by using the [Get Variable Instance
   * Count](https://docs.camunda.org/manual/latest/reference/rest/variable-instance/get-query-count/)
   * method.
   */
  getVariableInstances: {
    parameters: {
      query: {
        /** Filter by variable instance name. */
        variableName?: string;
        /**
         * Filter by the variable instance name. The parameter can include the wildcard `%` to
         * express like-strategy such as: starts with (`%`name), ends with (name`%`) or
         * contains (`%`name`%`).
         */
        variableNameLike?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * process instance ids.
         */
        processInstanceIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * execution ids.
         */
        executionIdIn?: string;
        /** Only include variable instances which belong to one of the passed and comma-separated case instance ids. */
        caseInstanceIdIn?: string;
        /** Only include variable instances which belong to one of the passed and comma-separated case execution ids. */
        caseExecutionIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated task
         * ids.
         */
        taskIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * batch ids.
         */
        batchIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * activity instance ids.
         */
        activityInstanceIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include variable instances that have the certain values.
         * Value filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`.
         * `key` is the variable name, `operator` is the comparison operator to be used
         * and `value` the variable value.
         *
         * **Note:** Values are always treated as `String` objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` -
         * greater than;
         * `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or
         * equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        variableValues?: string;
        /**
         * Match all variable names provided in `variableValues` case-insensitively. If set to `true`
         * **variableName** and **variablename** are treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values provided in `variableValues` case-insensitively. If set to
         * `true` **variableValue** and **variablevalue** are treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "variableName"
          | "variableType"
          | "activityInstanceId"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /**
         * Determines whether serializable variable values (typically variables that
         * store custom Java objects) should be deserialized on server side (default
         * `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on server side
         * and transformed to JSON using
         * [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property
         * introspection feature. Note that this requires the Java classes of the
         * variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized
         * format. For example, a variable that is serialized as XML will be returned as
         * a JSON string containing XML.
         *
         * **Note:** While `true` is the default value for reasons of backward
         * compatibility, we recommend setting this parameter to `false` when developing
         * web applications that are independent of the Java process applications
         * deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableInstanceDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator
       * for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Query for variable instances that fulfill given parameters through a JSON object.
   * This method is slightly more powerful than the
   * [Get Variable Instances](https://docs.camunda.org/manual/latest/reference/rest/variable-
   * instance/get-query/) method because it allows filtering by multiple
   * variable instances of types `String`, `Number` or `Boolean`.
   */
  queryVariableInstances: {
    parameters: {
      query: {
        /** Pagination of results. Specifies the index of the first result to return. */
        firstResult?: number;
        /**
         * Pagination of results. Specifies the maximum number of results to return.
         * Will return less results if there are no more results left.
         */
        maxResults?: number;
        /**
         * Determines whether serializable variable values (typically variables that
         * store custom Java objects) should be deserialized on server side (default
         * `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on server side
         * and transformed to JSON using
         * [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property
         * introspection feature. Note that this requires the Java classes of the
         * variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized
         * format. For example, a variable that is serialized as XML will be returned as
         * a JSON string containing XML.
         *
         * **Note:** While `true` is the default value for reasons of backward
         * compatibility, we recommend setting this parameter to `false` when developing
         * web applications that are independent of the Java process applications
         * deployed to the engine.
         */
        deserializeValues?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableInstanceDto"][];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if a `sortOrder`
       * parameter is supplied, but no `sortBy`, or if an invalid operator
       * for variable comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["VariableInstanceQueryDto"];
      };
    };
  };
  /**
   * Query for the number of variable instances that fulfill given parameters. Takes the
   * same parameters as the [Get Variable
   * Instances](https://docs.camunda.org/manual/latest/reference/rest/variable-instance/get-query/)
   * method.
   */
  getVariableInstancesCount: {
    parameters: {
      query: {
        /** Filter by variable instance name. */
        variableName?: string;
        /**
         * Filter by the variable instance name. The parameter can include the wildcard `%` to
         * express like-strategy such as: starts with (`%`name), ends with (name`%`) or
         * contains (`%`name`%`).
         */
        variableNameLike?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * process instance ids.
         */
        processInstanceIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * execution ids.
         */
        executionIdIn?: string;
        /** Only include variable instances which belong to one of the passed and comma-separated case instance ids. */
        caseInstanceIdIn?: string;
        /** Only include variable instances which belong to one of the passed and comma-separated case execution ids. */
        caseExecutionIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated task
         * ids.
         */
        taskIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * batch ids.
         */
        batchIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * activity instance ids.
         */
        activityInstanceIdIn?: string;
        /**
         * Only include variable instances which belong to one of the passed and comma-separated
         * tenant ids.
         */
        tenantIdIn?: string;
        /**
         * Only include variable instances that have the certain values.
         * Value filtering expressions are comma-separated and are structured as
         * follows:
         *
         * A valid parameter value has the form `key_operator_value`.
         * `key` is the variable name, `operator` is the comparison operator to be used
         * and `value` the variable value.
         *
         * **Note:** Values are always treated as `String` objects on server side.
         *
         * Valid operator values are: `eq` - equal to; `neq` - not equal to; `gt` -
         * greater than;
         * `gteq` - greater than or equal to; `lt` - lower than; `lteq` - lower than or
         * equal to;
         * `like`.
         * `key` and `value` may not contain underscore or comma characters.
         */
        variableValues?: string;
        /**
         * Match all variable names provided in `variableValues` case-insensitively. If set to `true`
         * **variableName** and **variablename** are treated as equal.
         */
        variableNamesIgnoreCase?: boolean;
        /**
         * Match all variable values provided in `variableValues` case-insensitively. If set to
         * `true` **variableValue** and **variablevalue** are treated as equal.
         */
        variableValuesIgnoreCase?: boolean;
        /**
         * Sort the results lexicographically by a given criterion.
         * Must be used in conjunction with the sortOrder parameter.
         */
        sortBy?:
          | "variableName"
          | "variableType"
          | "activityInstanceId"
          | "tenantId";
        /**
         * Sort the results in a given order. Values may be asc for ascending order or desc for descending order.
         * Must be used in conjunction with the sortBy parameter.
         */
        sortOrder?: "asc" | "desc";
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if an invalid operator for variable
       * comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Query for the number of variable instances that fulfill given parameters. This
   * method takes the same message body as the
   * [Get Variable Instances POST](https://docs.camunda.org/manual/latest/reference/rest/variable-
   * instance/post-query/) method and therefore it is slightly more
   * powerful than the [Get Variable Instance
   * Count](https://docs.camunda.org/manual/latest/reference/rest/variable-instance/get-query-count/)
   * method.
   */
  queryVariableInstancesCount: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["CountResultDto"];
        };
      };
      /**
       * Returned if some of the query parameters are invalid, for example if an invalid operator for variable
       * comparison is used. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["VariableInstanceQueryDto"];
      };
    };
  };
  /** Retrieves a variable by id. */
  getVariableInstance: {
    parameters: {
      path: {
        /** The id of the variable instance. */
        id: string;
      };
      query: {
        /**
         * Determines whether serializable variable values (typically variables that store custom Java objects)
         * should be deserialized on server side (default `true`).
         *
         * If set to `true`, a serializable variable will be deserialized on server side and transformed to JSON
         * using [Jackson's](https://github.com/FasterXML/jackson) POJO/bean property introspection feature.
         * Note that this requires the Java classes of the variable value to be on the REST API's classpath.
         *
         * If set to `false`, a serializable variable will be returned in its serialized format.
         * For example, a variable that is serialized as XML will be returned as a JSON string containing XML.
         *
         * **Note:**  While `true` is the default value for reasons of backward compatibility, we recommend setting this
         * parameter to `false` when developing web applications that are independent of the Java process
         * applications deployed to the engine.
         */
        deserializeValue?: boolean;
      };
    };
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VariableInstanceDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /**
   * Retrieves the content of a variable by id. Applicable for byte array and file
   * variables.
   */
  getVariableInstanceBinary: {
    parameters: {
      path: {
        /** The id of the variable instance. */
        id: string;
      };
    };
    responses: {
      /**
       * Request successful. For binary variables or files without any MIME type information, a byte stream is returned.
       *                       File variables with MIME type information are returned as the saved type. Additionally, for file
       *                       variables the Content-Disposition header will be set.
       */
      200: {
        content: {
          "application/octet-stream": string;
          "*/*": string;
        };
      };
      /**
       * Variable with given id exists but does not serialize as binary data. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      400: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
      /**
       * Variable with given id does not exist. See the
       * [Introduction](https://docs.camunda.org/manual/latest/reference/rest/overview/#error-handling)
       * for the error response format.
       */
      404: {
        content: {
          "application/json": components["schemas"]["ExceptionDto"];
        };
      };
    };
  };
  /** Retrieves the version of the Rest API. */
  getRestAPIVersion: {
    responses: {
      /** Request successful. */
      200: {
        content: {
          "application/json": components["schemas"]["VersionDto"];
        };
      };
    };
  };
}

export interface external {}