Package org.openapitools.client.api

Class ProcessDefinitionApi

  • public class ProcessDefinitionApi
extends Object

    • Constructor Detail

      • ProcessDefinitionApi

        public ProcessDefinitionApi()

      • ProcessDefinitionApi

        public ProcessDefinitionApi​(ApiClient apiClient)

    • Method Detail

      • getApiClient

        public ApiClient getApiClient()

      • setApiClient

        public void setApiClient​(ApiClient apiClient)

      • deleteProcessDefinitionCall

        public okhttp3.Call deleteProcessDefinitionCall​(String id,
                                                Boolean cascade,
                                                Boolean skipCustomListeners,
                                                Boolean skipIoMappings,
                                                ApiCallback _callback)
                                         throws ApiException
        Build call for deleteProcessDefinition
        Parameters:
        id - The id of the process definition to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • deleteProcessDefinition

        public void deleteProcessDefinition​(String id,
                                    Boolean cascade,
                                    Boolean skipCustomListeners,
                                    Boolean skipIoMappings)
                             throws ApiException
        Delete Deletes a running process instance by id.
        Parameters:
        id - The id of the process definition to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • deleteProcessDefinitionWithHttpInfo

        public ApiResponse<Void> deleteProcessDefinitionWithHttpInfo​(String id,
                                                             Boolean cascade,
                                                             Boolean skipCustomListeners,
                                                             Boolean skipIoMappings)
                                                      throws ApiException
        Delete Deletes a running process instance by id.
        Parameters:
        id - The id of the process definition to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • deleteProcessDefinitionAsync

        public okhttp3.Call deleteProcessDefinitionAsync​(String id,
                                                 Boolean cascade,
                                                 Boolean skipCustomListeners,
                                                 Boolean skipIoMappings,
                                                 ApiCallback<Void> _callback)
                                          throws ApiException
        Delete (asynchronously) Deletes a running process instance by id.
        Parameters:
        id - The id of the process definition to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • deleteProcessDefinitionsByKeyCall

        public okhttp3.Call deleteProcessDefinitionsByKeyCall​(String key,
                                                      Boolean cascade,
                                                      Boolean skipCustomListeners,
                                                      Boolean skipIoMappings,
                                                      ApiCallback _callback)
                                               throws ApiException
        Build call for deleteProcessDefinitionsByKey
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • deleteProcessDefinitionsByKey

        public void deleteProcessDefinitionsByKey​(String key,
                                          Boolean cascade,
                                          Boolean skipCustomListeners,
                                          Boolean skipIoMappings)
                                   throws ApiException
        Delete By Key Deletes process definitions by a given key which belong to no tenant id.
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • deleteProcessDefinitionsByKeyWithHttpInfo

        public ApiResponse<Void> deleteProcessDefinitionsByKeyWithHttpInfo​(String key,
                                                                   Boolean cascade,
                                                                   Boolean skipCustomListeners,
                                                                   Boolean skipIoMappings)
                                                            throws ApiException
        Delete By Key Deletes process definitions by a given key which belong to no tenant id.
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • deleteProcessDefinitionsByKeyAsync

        public okhttp3.Call deleteProcessDefinitionsByKeyAsync​(String key,
                                                       Boolean cascade,
                                                       Boolean skipCustomListeners,
                                                       Boolean skipIoMappings,
                                                       ApiCallback<Void> _callback)
                                                throws ApiException
        Delete By Key (asynchronously) Deletes process definitions by a given key which belong to no tenant id.
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • deleteProcessDefinitionsByKeyAndTenantIdCall

        public okhttp3.Call deleteProcessDefinitionsByKeyAndTenantIdCall​(String key,
                                                                 String tenantId,
                                                                 Boolean cascade,
                                                                 Boolean skipCustomListeners,
                                                                 Boolean skipIoMappings,
                                                                 ApiCallback _callback)
                                                          throws ApiException
        Build call for deleteProcessDefinitionsByKeyAndTenantId
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • deleteProcessDefinitionsByKeyAndTenantId

        public void deleteProcessDefinitionsByKeyAndTenantId​(String key,
                                                     String tenantId,
                                                     Boolean cascade,
                                                     Boolean skipCustomListeners,
                                                     Boolean skipIoMappings)
                                              throws ApiException
        Delete By Key Deletes process definitions by a given key and which belong to a tenant id.
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • deleteProcessDefinitionsByKeyAndTenantIdWithHttpInfo

        public ApiResponse<Void> deleteProcessDefinitionsByKeyAndTenantIdWithHttpInfo​(String key,
                                                                              String tenantId,
                                                                              Boolean cascade,
                                                                              Boolean skipCustomListeners,
                                                                              Boolean skipIoMappings)
                                                                       throws ApiException
        Delete By Key Deletes process definitions by a given key and which belong to a tenant id.
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • deleteProcessDefinitionsByKeyAndTenantIdAsync

        public okhttp3.Call deleteProcessDefinitionsByKeyAndTenantIdAsync​(String key,
                                                                  String tenantId,
                                                                  Boolean cascade,
                                                                  Boolean skipCustomListeners,
                                                                  Boolean skipIoMappings,
                                                                  ApiCallback<Void> _callback)
                                                           throws ApiException
        Delete By Key (asynchronously) Deletes process definitions by a given key and which belong to a tenant id.
        Parameters:
        key - The key of the process definitions to be deleted. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        cascade - `true`, if all process instances, historic process instances and jobs for this process definition should be deleted. (optional)
        skipCustomListeners - `true`, if only the built-in ExecutionListeners should be notified with the end event. (optional, default to false)
        skipIoMappings - A boolean value to control whether input/output mappings should be executed during deletion. `true`, if input/output mappings should not be invoked. (optional, default to false)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getActivityStatisticsCall

        public okhttp3.Call getActivityStatisticsCall​(String id,
                                              Boolean failedJobs,
                                              Boolean incidents,
                                              String incidentsForType,
                                              ApiCallback _callback)
                                       throws ApiException
        Build call for getActivityStatistics
        Parameters:
        id - The id of the process definition. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getActivityStatistics

        public List<ActivityStatisticsResultDto> getActivityStatistics​(String id,
                                                               Boolean failedJobs,
                                                               Boolean incidents,
                                                               String incidentsForType)
                                                        throws ApiException
        Get Activity Instance 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.
        Parameters:
        id - The id of the process definition. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        Returns:
        List<ActivityStatisticsResultDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getActivityStatisticsWithHttpInfo

        public ApiResponse<List<ActivityStatisticsResultDto>> getActivityStatisticsWithHttpInfo​(String id,
                                                                                        Boolean failedJobs,
                                                                                        Boolean incidents,
                                                                                        String incidentsForType)
                                                                                 throws ApiException
        Get Activity Instance 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.
        Parameters:
        id - The id of the process definition. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        Returns:
        ApiResponse<List<ActivityStatisticsResultDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getActivityStatisticsAsync

        public okhttp3.Call getActivityStatisticsAsync​(String id,
                                               Boolean failedJobs,
                                               Boolean incidents,
                                               String incidentsForType,
                                               ApiCallback<List<ActivityStatisticsResultDto>> _callback)
                                        throws ApiException
        Get Activity Instance Statistics (asynchronously) 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.
        Parameters:
        id - The id of the process definition. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getActivityStatisticsByProcessDefinitionKeyCall

        public okhttp3.Call getActivityStatisticsByProcessDefinitionKeyCall​(String key,
                                                                    Boolean failedJobs,
                                                                    Boolean incidents,
                                                                    String incidentsForType,
                                                                    ApiCallback _callback)
                                                             throws ApiException
        Build call for getActivityStatisticsByProcessDefinitionKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getActivityStatisticsByProcessDefinitionKey

        public List<ActivityStatisticsResultDto> getActivityStatisticsByProcessDefinitionKey​(String key,
                                                                                     Boolean failedJobs,
                                                                                     Boolean incidents,
                                                                                     String incidentsForType)
                                                                              throws ApiException
        Get Activity Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        Returns:
        List<ActivityStatisticsResultDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getActivityStatisticsByProcessDefinitionKeyWithHttpInfo

        public ApiResponse<List<ActivityStatisticsResultDto>> getActivityStatisticsByProcessDefinitionKeyWithHttpInfo​(String key,
                                                                                                              Boolean failedJobs,
                                                                                                              Boolean incidents,
                                                                                                              String incidentsForType)
                                                                                                       throws ApiException
        Get Activity Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        Returns:
        ApiResponse<List<ActivityStatisticsResultDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getActivityStatisticsByProcessDefinitionKeyAsync

        public okhttp3.Call getActivityStatisticsByProcessDefinitionKeyAsync​(String key,
                                                                     Boolean failedJobs,
                                                                     Boolean incidents,
                                                                     String incidentsForType,
                                                                     ApiCallback<List<ActivityStatisticsResultDto>> _callback)
                                                              throws ApiException
        Get Activity Instance Statistics (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getActivityStatisticsByProcessDefinitionKeyAndTenantIdCall

        public okhttp3.Call getActivityStatisticsByProcessDefinitionKeyAndTenantIdCall​(String key,
                                                                               String tenantId,
                                                                               Boolean failedJobs,
                                                                               Boolean incidents,
                                                                               String incidentsForType,
                                                                               ApiCallback _callback)
                                                                        throws ApiException
        Build call for getActivityStatisticsByProcessDefinitionKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getActivityStatisticsByProcessDefinitionKeyAndTenantId

        public List<ActivityStatisticsResultDto> getActivityStatisticsByProcessDefinitionKeyAndTenantId​(String key,
                                                                                                String tenantId,
                                                                                                Boolean failedJobs,
                                                                                                Boolean incidents,
                                                                                                String incidentsForType)
                                                                                         throws ApiException
        Get Activity Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        Returns:
        List<ActivityStatisticsResultDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getActivityStatisticsByProcessDefinitionKeyAndTenantIdWithHttpInfo

        public ApiResponse<List<ActivityStatisticsResultDto>> getActivityStatisticsByProcessDefinitionKeyAndTenantIdWithHttpInfo​(String key,
                                                                                                                         String tenantId,
                                                                                                                         Boolean failedJobs,
                                                                                                                         Boolean incidents,
                                                                                                                         String incidentsForType)
                                                                                                                  throws ApiException
        Get Activity Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        Returns:
        ApiResponse<List<ActivityStatisticsResultDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getActivityStatisticsByProcessDefinitionKeyAndTenantIdAsync

        public okhttp3.Call getActivityStatisticsByProcessDefinitionKeyAndTenantIdAsync​(String key,
                                                                                String tenantId,
                                                                                Boolean failedJobs,
                                                                                Boolean incidents,
                                                                                String incidentsForType,
                                                                                ApiCallback<List<ActivityStatisticsResultDto>> _callback)
                                                                         throws ApiException
        Get Activity Instance Statistics (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getDeployedStartFormCall

        public okhttp3.Call getDeployedStartFormCall​(String id,
                                             ApiCallback _callback)
                                      throws ApiException
        Build call for getDeployedStartForm
        Parameters:
        id - The id of the process definition to get the deployed start form for. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getDeployedStartForm

        public File getDeployedStartForm​(String id)
                          throws ApiException
        Get 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        id - The id of the process definition to get the deployed start form for. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getDeployedStartFormWithHttpInfo

        public ApiResponse<File> getDeployedStartFormWithHttpInfo​(String id)
                                                   throws ApiException
        Get 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        id - The id of the process definition to get the deployed start form for. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getDeployedStartFormAsync

        public okhttp3.Call getDeployedStartFormAsync​(String id,
                                              ApiCallback<File> _callback)
                                       throws ApiException
        Get Deployed Start Form (asynchronously) 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        id - The id of the process definition to get the deployed start form for. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getDeployedStartFormByKeyCall

        public okhttp3.Call getDeployedStartFormByKeyCall​(String key,
                                                  ApiCallback _callback)
                                           throws ApiException
        Build call for getDeployedStartFormByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getDeployedStartFormByKey

        public File getDeployedStartFormByKey​(String key)
                               throws ApiException
        Get 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getDeployedStartFormByKeyWithHttpInfo

        public ApiResponse<File> getDeployedStartFormByKeyWithHttpInfo​(String key)
                                                        throws ApiException
        Get 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getDeployedStartFormByKeyAsync

        public okhttp3.Call getDeployedStartFormByKeyAsync​(String key,
                                                   ApiCallback<File> _callback)
                                            throws ApiException
        Get Deployed Start Form (asynchronously) 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getDeployedStartFormByKeyAndTenantIdCall

        public okhttp3.Call getDeployedStartFormByKeyAndTenantIdCall​(String key,
                                                             String tenantId,
                                                             ApiCallback _callback)
                                                      throws ApiException
        Build call for getDeployedStartFormByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getDeployedStartFormByKeyAndTenantId

        public File getDeployedStartFormByKeyAndTenantId​(String key,
                                                 String tenantId)
                                          throws ApiException
        Get 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getDeployedStartFormByKeyAndTenantIdWithHttpInfo

        public ApiResponse<File> getDeployedStartFormByKeyAndTenantIdWithHttpInfo​(String key,
                                                                          String tenantId)
                                                                   throws ApiException
        Get 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getDeployedStartFormByKeyAndTenantIdAsync

        public okhttp3.Call getDeployedStartFormByKeyAndTenantIdAsync​(String key,
                                                              String tenantId,
                                                              ApiCallback<File> _callback)
                                                       throws ApiException
        Get Deployed Start Form (asynchronously) 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/7.18/user-guide/task-forms/#embedded-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definitions belong to. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getLatestProcessDefinitionByTenantIdCall

        public okhttp3.Call getLatestProcessDefinitionByTenantIdCall​(String key,
                                                             String tenantId,
                                                             ApiCallback _callback)
                                                      throws ApiException
        Build call for getLatestProcessDefinitionByTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getLatestProcessDefinitionByTenantId

        public ProcessDefinitionDto getLatestProcessDefinitionByTenantId​(String key,
                                                                 String tenantId)
                                                          throws ApiException
        Get Retrieves the latest version of the process definition for tenant according to the `ProcessDefinition` interface in the engine.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ProcessDefinitionDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getLatestProcessDefinitionByTenantIdWithHttpInfo

        public ApiResponse<ProcessDefinitionDto> getLatestProcessDefinitionByTenantIdWithHttpInfo​(String key,
                                                                                          String tenantId)
                                                                                   throws ApiException
        Get Retrieves the latest version of the process definition for tenant according to the `ProcessDefinition` interface in the engine.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ApiResponse<ProcessDefinitionDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getLatestProcessDefinitionByTenantIdAsync

        public okhttp3.Call getLatestProcessDefinitionByTenantIdAsync​(String key,
                                                              String tenantId,
                                                              ApiCallback<ProcessDefinitionDto> _callback)
                                                       throws ApiException
        Get (asynchronously) Retrieves the latest version of the process definition for tenant according to the `ProcessDefinition` interface in the engine.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionCall

        public okhttp3.Call getProcessDefinitionCall​(String id,
                                             ApiCallback _callback)
                                      throws ApiException
        Build call for getProcessDefinition
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinition

        public ProcessDefinitionDto getProcessDefinition​(String id)
                                          throws ApiException
        Get Retrieves a process definition according to the `ProcessDefinition` interface in the engine.
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        Returns:
        ProcessDefinitionDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionWithHttpInfo

        public ApiResponse<ProcessDefinitionDto> getProcessDefinitionWithHttpInfo​(String id)
                                                                   throws ApiException
        Get Retrieves a process definition according to the `ProcessDefinition` interface in the engine.
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        Returns:
        ApiResponse<ProcessDefinitionDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionAsync

        public okhttp3.Call getProcessDefinitionAsync​(String id,
                                              ApiCallback<ProcessDefinitionDto> _callback)
                                       throws ApiException
        Get (asynchronously) Retrieves a process definition according to the `ProcessDefinition` interface in the engine.
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionBpmn20XmlCall

        public okhttp3.Call getProcessDefinitionBpmn20XmlCall​(String id,
                                                      ApiCallback _callback)
                                               throws ApiException
        Build call for getProcessDefinitionBpmn20Xml
        Parameters:
        id - The id of the process definition. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionBpmn20Xml

        public ProcessDefinitionDiagramDto getProcessDefinitionBpmn20Xml​(String id)
                                                          throws ApiException
        Get XML Retrieves the BPMN 2.0 XML of a process definition.
        Parameters:
        id - The id of the process definition. (required)
        Returns:
        ProcessDefinitionDiagramDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionBpmn20XmlWithHttpInfo

        public ApiResponse<ProcessDefinitionDiagramDto> getProcessDefinitionBpmn20XmlWithHttpInfo​(String id)
                                                                                   throws ApiException
        Get XML Retrieves the BPMN 2.0 XML of a process definition.
        Parameters:
        id - The id of the process definition. (required)
        Returns:
        ApiResponse<ProcessDefinitionDiagramDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionBpmn20XmlAsync

        public okhttp3.Call getProcessDefinitionBpmn20XmlAsync​(String id,
                                                       ApiCallback<ProcessDefinitionDiagramDto> _callback)
                                                throws ApiException
        Get XML (asynchronously) Retrieves the BPMN 2.0 XML of a process definition.
        Parameters:
        id - The id of the process definition. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionBpmn20XmlByKeyCall

        public okhttp3.Call getProcessDefinitionBpmn20XmlByKeyCall​(String key,
                                                           ApiCallback _callback)
                                                    throws ApiException
        Build call for getProcessDefinitionBpmn20XmlByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionBpmn20XmlByKey

        public ProcessDefinitionDiagramDto getProcessDefinitionBpmn20XmlByKey​(String key)
                                                               throws ApiException
        Get XML Retrieves latest version the BPMN 2.0 XML of a process definition.
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        Returns:
        ProcessDefinitionDiagramDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionBpmn20XmlByKeyWithHttpInfo

        public ApiResponse<ProcessDefinitionDiagramDto> getProcessDefinitionBpmn20XmlByKeyWithHttpInfo​(String key)
                                                                                        throws ApiException
        Get XML Retrieves latest version the BPMN 2.0 XML of a process definition.
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        Returns:
        ApiResponse<ProcessDefinitionDiagramDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionBpmn20XmlByKeyAsync

        public okhttp3.Call getProcessDefinitionBpmn20XmlByKeyAsync​(String key,
                                                            ApiCallback<ProcessDefinitionDiagramDto> _callback)
                                                     throws ApiException
        Get XML (asynchronously) Retrieves latest version the BPMN 2.0 XML of a process definition.
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionBpmn20XmlByKeyAndTenantIdCall

        public okhttp3.Call getProcessDefinitionBpmn20XmlByKeyAndTenantIdCall​(String key,
                                                                      String tenantId,
                                                                      ApiCallback _callback)
                                                               throws ApiException
        Build call for getProcessDefinitionBpmn20XmlByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionBpmn20XmlByKeyAndTenantId

        public ProcessDefinitionDiagramDto getProcessDefinitionBpmn20XmlByKeyAndTenantId​(String key,
                                                                                 String tenantId)
                                                                          throws ApiException
        Get 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ProcessDefinitionDiagramDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionBpmn20XmlByKeyAndTenantIdWithHttpInfo

        public ApiResponse<ProcessDefinitionDiagramDto> getProcessDefinitionBpmn20XmlByKeyAndTenantIdWithHttpInfo​(String key,
                                                                                                          String tenantId)
                                                                                                   throws ApiException
        Get 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ApiResponse<ProcessDefinitionDiagramDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionBpmn20XmlByKeyAndTenantIdAsync

        public okhttp3.Call getProcessDefinitionBpmn20XmlByKeyAndTenantIdAsync​(String key,
                                                                       String tenantId,
                                                                       ApiCallback<ProcessDefinitionDiagramDto> _callback)
                                                                throws ApiException
        Get XML (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) whose XML should be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionByKeyCall

        public okhttp3.Call getProcessDefinitionByKeyCall​(String key,
                                                  ApiCallback _callback)
                                           throws ApiException
        Build call for getProcessDefinitionByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionByKey

        public ProcessDefinitionDto getProcessDefinitionByKey​(String key)
                                               throws ApiException
        Get Retrieves the latest version of the process definition which belongs to no tenant according to the `ProcessDefinition` interface in the engine.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        Returns:
        ProcessDefinitionDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionByKeyWithHttpInfo

        public ApiResponse<ProcessDefinitionDto> getProcessDefinitionByKeyWithHttpInfo​(String key)
                                                                        throws ApiException
        Get Retrieves the latest version of the process definition which belongs to no tenant according to the `ProcessDefinition` interface in the engine.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        Returns:
        ApiResponse<ProcessDefinitionDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionByKeyAsync

        public okhttp3.Call getProcessDefinitionByKeyAsync​(String key,
                                                   ApiCallback<ProcessDefinitionDto> _callback)
                                            throws ApiException
        Get (asynchronously) Retrieves the latest version of the process definition which belongs to no tenant according to the `ProcessDefinition` interface in the engine.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionDiagramCall

        public okhttp3.Call getProcessDefinitionDiagramCall​(String id,
                                                    ApiCallback _callback)
                                             throws ApiException
        Build call for getProcessDefinitionDiagram
        Parameters:
        id - The id of the process definition. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionDiagram

        public File getProcessDefinitionDiagram​(String id)
                                 throws ApiException
        Get 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`.
        Parameters:
        id - The id of the process definition. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionDiagramWithHttpInfo

        public ApiResponse<File> getProcessDefinitionDiagramWithHttpInfo​(String id)
                                                          throws ApiException
        Get 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`.
        Parameters:
        id - The id of the process definition. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionDiagramAsync

        public okhttp3.Call getProcessDefinitionDiagramAsync​(String id,
                                                     ApiCallback<File> _callback)
                                              throws ApiException
        Get Diagram (asynchronously) 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`.
        Parameters:
        id - The id of the process definition. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionDiagramByKeyCall

        public okhttp3.Call getProcessDefinitionDiagramByKeyCall​(String key,
                                                         ApiCallback _callback)
                                                  throws ApiException
        Build call for getProcessDefinitionDiagramByKey
        Parameters:
        key - The key of the process definition. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionDiagramByKey

        public File getProcessDefinitionDiagramByKey​(String key)
                                      throws ApiException
        Get 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`.
        Parameters:
        key - The key of the process definition. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionDiagramByKeyWithHttpInfo

        public ApiResponse<File> getProcessDefinitionDiagramByKeyWithHttpInfo​(String key)
                                                               throws ApiException
        Get 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`.
        Parameters:
        key - The key of the process definition. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionDiagramByKeyAsync

        public okhttp3.Call getProcessDefinitionDiagramByKeyAsync​(String key,
                                                          ApiCallback<File> _callback)
                                                   throws ApiException
        Get Diagram (asynchronously) 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`.
        Parameters:
        key - The key of the process definition. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionDiagramByKeyAndTenantIdCall

        public okhttp3.Call getProcessDefinitionDiagramByKeyAndTenantIdCall​(String key,
                                                                    String tenantId,
                                                                    ApiCallback _callback)
                                                             throws ApiException
        Build call for getProcessDefinitionDiagramByKeyAndTenantId
        Parameters:
        key - The key of the process definition. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionDiagramByKeyAndTenantId

        public File getProcessDefinitionDiagramByKeyAndTenantId​(String key,
                                                        String tenantId)
                                                 throws ApiException
        Get 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`.
        Parameters:
        key - The key of the process definition. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionDiagramByKeyAndTenantIdWithHttpInfo

        public ApiResponse<File> getProcessDefinitionDiagramByKeyAndTenantIdWithHttpInfo​(String key,
                                                                                 String tenantId)
                                                                          throws ApiException
        Get 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`.
        Parameters:
        key - The key of the process definition. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionDiagramByKeyAndTenantIdAsync

        public okhttp3.Call getProcessDefinitionDiagramByKeyAndTenantIdAsync​(String key,
                                                                     String tenantId,
                                                                     ApiCallback<File> _callback)
                                                              throws ApiException
        Get Diagram (asynchronously) 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`.
        Parameters:
        key - The key of the process definition. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionStatisticsCall

        public okhttp3.Call getProcessDefinitionStatisticsCall​(Boolean failedJobs,
                                                       Boolean incidents,
                                                       String incidentsForType,
                                                       Boolean rootIncidents,
                                                       ApiCallback _callback)
                                                throws ApiException
        Build call for getProcessDefinitionStatistics
        Parameters:
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        rootIncidents - 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`. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionStatistics

        public List<ProcessDefinitionStatisticsResultDto> getProcessDefinitionStatistics​(Boolean failedJobs,
                                                                                 Boolean incidents,
                                                                                 String incidentsForType,
                                                                                 Boolean rootIncidents)
                                                                          throws ApiException
        Get Process Instance 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.
        Parameters:
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        rootIncidents - 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`. (optional)
        Returns:
        List<ProcessDefinitionStatisticsResultDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionStatisticsWithHttpInfo

        public ApiResponse<List<ProcessDefinitionStatisticsResultDto>> getProcessDefinitionStatisticsWithHttpInfo​(Boolean failedJobs,
                                                                                                          Boolean incidents,
                                                                                                          String incidentsForType,
                                                                                                          Boolean rootIncidents)
                                                                                                   throws ApiException
        Get Process Instance 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.
        Parameters:
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        rootIncidents - 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`. (optional)
        Returns:
        ApiResponse<List<ProcessDefinitionStatisticsResultDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionStatisticsAsync

        public okhttp3.Call getProcessDefinitionStatisticsAsync​(Boolean failedJobs,
                                                        Boolean incidents,
                                                        String incidentsForType,
                                                        Boolean rootIncidents,
                                                        ApiCallback<List<ProcessDefinitionStatisticsResultDto>> _callback)
                                                 throws ApiException
        Get Process Instance Statistics (asynchronously) 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.
        Parameters:
        failedJobs - Whether to include the number of failed jobs in the result or not. Valid values are `true` or `false`. (optional)
        incidents - 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`. (optional)
        incidentsForType - 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/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        rootIncidents - 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`. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionsCall

        public okhttp3.Call getProcessDefinitionsCall​(String processDefinitionId,
                                              String processDefinitionIdIn,
                                              String name,
                                              String nameLike,
                                              String deploymentId,
                                              Date deployedAfter,
                                              Date deployedAt,
                                              String key,
                                              String keysIn,
                                              String keyLike,
                                              String category,
                                              String categoryLike,
                                              Integer version,
                                              Boolean latestVersion,
                                              String resourceName,
                                              String resourceNameLike,
                                              String startableBy,
                                              Boolean active,
                                              Boolean suspended,
                                              String incidentId,
                                              String incidentType,
                                              String incidentMessage,
                                              String incidentMessageLike,
                                              String tenantIdIn,
                                              Boolean withoutTenantId,
                                              Boolean includeProcessDefinitionsWithoutTenantId,
                                              String versionTag,
                                              String versionTagLike,
                                              Boolean withoutVersionTag,
                                              Boolean startableInTasklist,
                                              Boolean notStartableInTasklist,
                                              Boolean startablePermissionCheck,
                                              String sortBy,
                                              String sortOrder,
                                              Integer firstResult,
                                              Integer maxResults,
                                              ApiCallback _callback)
                                       throws ApiException
        Build call for getProcessDefinitions
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        sortBy - Sort the results lexicographically by a given criterion. Must be used in conjunction with the sortOrder parameter. (optional)
        sortOrder - 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. (optional)
        firstResult - Pagination of results. Specifies the index of the first result to return. (optional)
        maxResults - Pagination of results. Specifies the maximum number of results to return. Will return less results if there are no more results left. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitions

        public List<ProcessDefinitionDto> getProcessDefinitions​(String processDefinitionId,
                                                        String processDefinitionIdIn,
                                                        String name,
                                                        String nameLike,
                                                        String deploymentId,
                                                        Date deployedAfter,
                                                        Date deployedAt,
                                                        String key,
                                                        String keysIn,
                                                        String keyLike,
                                                        String category,
                                                        String categoryLike,
                                                        Integer version,
                                                        Boolean latestVersion,
                                                        String resourceName,
                                                        String resourceNameLike,
                                                        String startableBy,
                                                        Boolean active,
                                                        Boolean suspended,
                                                        String incidentId,
                                                        String incidentType,
                                                        String incidentMessage,
                                                        String incidentMessageLike,
                                                        String tenantIdIn,
                                                        Boolean withoutTenantId,
                                                        Boolean includeProcessDefinitionsWithoutTenantId,
                                                        String versionTag,
                                                        String versionTagLike,
                                                        Boolean withoutVersionTag,
                                                        Boolean startableInTasklist,
                                                        Boolean notStartableInTasklist,
                                                        Boolean startablePermissionCheck,
                                                        String sortBy,
                                                        String sortOrder,
                                                        Integer firstResult,
                                                        Integer maxResults)
                                                 throws ApiException
        Get List 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/7.18/reference/rest/process-definition/get-query-count/) method.
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        sortBy - Sort the results lexicographically by a given criterion. Must be used in conjunction with the sortOrder parameter. (optional)
        sortOrder - 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. (optional)
        firstResult - Pagination of results. Specifies the index of the first result to return. (optional)
        maxResults - Pagination of results. Specifies the maximum number of results to return. Will return less results if there are no more results left. (optional)
        Returns:
        List<ProcessDefinitionDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionsWithHttpInfo

        public ApiResponse<List<ProcessDefinitionDto>> getProcessDefinitionsWithHttpInfo​(String processDefinitionId,
                                                                                 String processDefinitionIdIn,
                                                                                 String name,
                                                                                 String nameLike,
                                                                                 String deploymentId,
                                                                                 Date deployedAfter,
                                                                                 Date deployedAt,
                                                                                 String key,
                                                                                 String keysIn,
                                                                                 String keyLike,
                                                                                 String category,
                                                                                 String categoryLike,
                                                                                 Integer version,
                                                                                 Boolean latestVersion,
                                                                                 String resourceName,
                                                                                 String resourceNameLike,
                                                                                 String startableBy,
                                                                                 Boolean active,
                                                                                 Boolean suspended,
                                                                                 String incidentId,
                                                                                 String incidentType,
                                                                                 String incidentMessage,
                                                                                 String incidentMessageLike,
                                                                                 String tenantIdIn,
                                                                                 Boolean withoutTenantId,
                                                                                 Boolean includeProcessDefinitionsWithoutTenantId,
                                                                                 String versionTag,
                                                                                 String versionTagLike,
                                                                                 Boolean withoutVersionTag,
                                                                                 Boolean startableInTasklist,
                                                                                 Boolean notStartableInTasklist,
                                                                                 Boolean startablePermissionCheck,
                                                                                 String sortBy,
                                                                                 String sortOrder,
                                                                                 Integer firstResult,
                                                                                 Integer maxResults)
                                                                          throws ApiException
        Get List 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/7.18/reference/rest/process-definition/get-query-count/) method.
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        sortBy - Sort the results lexicographically by a given criterion. Must be used in conjunction with the sortOrder parameter. (optional)
        sortOrder - 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. (optional)
        firstResult - Pagination of results. Specifies the index of the first result to return. (optional)
        maxResults - Pagination of results. Specifies the maximum number of results to return. Will return less results if there are no more results left. (optional)
        Returns:
        ApiResponse<List<ProcessDefinitionDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionsAsync

        public okhttp3.Call getProcessDefinitionsAsync​(String processDefinitionId,
                                               String processDefinitionIdIn,
                                               String name,
                                               String nameLike,
                                               String deploymentId,
                                               Date deployedAfter,
                                               Date deployedAt,
                                               String key,
                                               String keysIn,
                                               String keyLike,
                                               String category,
                                               String categoryLike,
                                               Integer version,
                                               Boolean latestVersion,
                                               String resourceName,
                                               String resourceNameLike,
                                               String startableBy,
                                               Boolean active,
                                               Boolean suspended,
                                               String incidentId,
                                               String incidentType,
                                               String incidentMessage,
                                               String incidentMessageLike,
                                               String tenantIdIn,
                                               Boolean withoutTenantId,
                                               Boolean includeProcessDefinitionsWithoutTenantId,
                                               String versionTag,
                                               String versionTagLike,
                                               Boolean withoutVersionTag,
                                               Boolean startableInTasklist,
                                               Boolean notStartableInTasklist,
                                               Boolean startablePermissionCheck,
                                               String sortBy,
                                               String sortOrder,
                                               Integer firstResult,
                                               Integer maxResults,
                                               ApiCallback<List<ProcessDefinitionDto>> _callback)
                                        throws ApiException
        Get List (asynchronously) 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/7.18/reference/rest/process-definition/get-query-count/) method.
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        sortBy - Sort the results lexicographically by a given criterion. Must be used in conjunction with the sortOrder parameter. (optional)
        sortOrder - 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. (optional)
        firstResult - Pagination of results. Specifies the index of the first result to return. (optional)
        maxResults - Pagination of results. Specifies the maximum number of results to return. Will return less results if there are no more results left. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getProcessDefinitionsCountCall

        public okhttp3.Call getProcessDefinitionsCountCall​(String processDefinitionId,
                                                   String processDefinitionIdIn,
                                                   String name,
                                                   String nameLike,
                                                   String deploymentId,
                                                   Date deployedAfter,
                                                   Date deployedAt,
                                                   String key,
                                                   String keysIn,
                                                   String keyLike,
                                                   String category,
                                                   String categoryLike,
                                                   Integer version,
                                                   Boolean latestVersion,
                                                   String resourceName,
                                                   String resourceNameLike,
                                                   String startableBy,
                                                   Boolean active,
                                                   Boolean suspended,
                                                   String incidentId,
                                                   String incidentType,
                                                   String incidentMessage,
                                                   String incidentMessageLike,
                                                   String tenantIdIn,
                                                   Boolean withoutTenantId,
                                                   Boolean includeProcessDefinitionsWithoutTenantId,
                                                   String versionTag,
                                                   String versionTagLike,
                                                   Boolean withoutVersionTag,
                                                   Boolean startableInTasklist,
                                                   Boolean notStartableInTasklist,
                                                   Boolean startablePermissionCheck,
                                                   ApiCallback _callback)
                                            throws ApiException
        Build call for getProcessDefinitionsCount
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getProcessDefinitionsCount

        public CountResultDto getProcessDefinitionsCount​(String processDefinitionId,
                                                 String processDefinitionIdIn,
                                                 String name,
                                                 String nameLike,
                                                 String deploymentId,
                                                 Date deployedAfter,
                                                 Date deployedAt,
                                                 String key,
                                                 String keysIn,
                                                 String keyLike,
                                                 String category,
                                                 String categoryLike,
                                                 Integer version,
                                                 Boolean latestVersion,
                                                 String resourceName,
                                                 String resourceNameLike,
                                                 String startableBy,
                                                 Boolean active,
                                                 Boolean suspended,
                                                 String incidentId,
                                                 String incidentType,
                                                 String incidentMessage,
                                                 String incidentMessageLike,
                                                 String tenantIdIn,
                                                 Boolean withoutTenantId,
                                                 Boolean includeProcessDefinitionsWithoutTenantId,
                                                 String versionTag,
                                                 String versionTagLike,
                                                 Boolean withoutVersionTag,
                                                 Boolean startableInTasklist,
                                                 Boolean notStartableInTasklist,
                                                 Boolean startablePermissionCheck)
                                          throws ApiException
        Get List 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/7.18/reference/rest/process-definition/get-query/) method.
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        Returns:
        CountResultDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionsCountWithHttpInfo

        public ApiResponse<CountResultDto> getProcessDefinitionsCountWithHttpInfo​(String processDefinitionId,
                                                                          String processDefinitionIdIn,
                                                                          String name,
                                                                          String nameLike,
                                                                          String deploymentId,
                                                                          Date deployedAfter,
                                                                          Date deployedAt,
                                                                          String key,
                                                                          String keysIn,
                                                                          String keyLike,
                                                                          String category,
                                                                          String categoryLike,
                                                                          Integer version,
                                                                          Boolean latestVersion,
                                                                          String resourceName,
                                                                          String resourceNameLike,
                                                                          String startableBy,
                                                                          Boolean active,
                                                                          Boolean suspended,
                                                                          String incidentId,
                                                                          String incidentType,
                                                                          String incidentMessage,
                                                                          String incidentMessageLike,
                                                                          String tenantIdIn,
                                                                          Boolean withoutTenantId,
                                                                          Boolean includeProcessDefinitionsWithoutTenantId,
                                                                          String versionTag,
                                                                          String versionTagLike,
                                                                          Boolean withoutVersionTag,
                                                                          Boolean startableInTasklist,
                                                                          Boolean notStartableInTasklist,
                                                                          Boolean startablePermissionCheck)
                                                                   throws ApiException
        Get List 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/7.18/reference/rest/process-definition/get-query/) method.
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        Returns:
        ApiResponse<CountResultDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getProcessDefinitionsCountAsync

        public okhttp3.Call getProcessDefinitionsCountAsync​(String processDefinitionId,
                                                    String processDefinitionIdIn,
                                                    String name,
                                                    String nameLike,
                                                    String deploymentId,
                                                    Date deployedAfter,
                                                    Date deployedAt,
                                                    String key,
                                                    String keysIn,
                                                    String keyLike,
                                                    String category,
                                                    String categoryLike,
                                                    Integer version,
                                                    Boolean latestVersion,
                                                    String resourceName,
                                                    String resourceNameLike,
                                                    String startableBy,
                                                    Boolean active,
                                                    Boolean suspended,
                                                    String incidentId,
                                                    String incidentType,
                                                    String incidentMessage,
                                                    String incidentMessageLike,
                                                    String tenantIdIn,
                                                    Boolean withoutTenantId,
                                                    Boolean includeProcessDefinitionsWithoutTenantId,
                                                    String versionTag,
                                                    String versionTagLike,
                                                    Boolean withoutVersionTag,
                                                    Boolean startableInTasklist,
                                                    Boolean notStartableInTasklist,
                                                    Boolean startablePermissionCheck,
                                                    ApiCallback<CountResultDto> _callback)
                                             throws ApiException
        Get List Count (asynchronously) 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/7.18/reference/rest/process-definition/get-query/) method.
        Parameters:
        processDefinitionId - Filter by process definition id. (optional)
        processDefinitionIdIn - Filter by a comma-separated list of process definition ids. (optional)
        name - Filter by process definition name. (optional)
        nameLike - Filter by process definition names that the parameter is a substring of. (optional)
        deploymentId - Filter by the deployment the id belongs to. (optional)
        deployedAfter - 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/7.18/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`. (optional)
        deployedAt - 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/7.18/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`. (optional)
        key - Filter by process definition key, i.e., the id in the BPMN 2.0 XML. Exact match. (optional)
        keysIn - Filter by a comma-separated list of process definition keys. (optional)
        keyLike - Filter by process definition keys that the parameter is a substring of. (optional)
        category - Filter by process definition category. Exact match. (optional)
        categoryLike - Filter by process definition categories that the parameter is a substring of. (optional)
        version - Filter by process definition version. (optional)
        latestVersion - Only include those process definitions that are latest versions. Value may only be `true`, as `false` is the default behavior. (optional)
        resourceName - Filter by the name of the process definition resource. Exact match. (optional)
        resourceNameLike - Filter by names of those process definition resources that the parameter is a substring of. (optional)
        startableBy - Filter by a user name who is allowed to start the process. (optional)
        active - Only include active process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        suspended - Only include suspended process definitions. Value may only be `true`, as `false` is the default behavior. (optional)
        incidentId - Filter by the incident id. (optional)
        incidentType - Filter by the incident type. See the [User Guide](https://docs.camunda.org/manual/7.18/user-guide/process-engine/incidents/#incident-types) for a list of incident types. (optional)
        incidentMessage - Filter by the incident message. Exact match. (optional)
        incidentMessageLike - Filter by the incident message that the parameter is a substring of. (optional)
        tenantIdIn - Filter by a comma-separated list of tenant ids. A process definition must have one of the given tenant ids. (optional)
        withoutTenantId - Only include process definitions which belong to no tenant. Value may only be true, as false is the default behavior. (optional)
        includeProcessDefinitionsWithoutTenantId - 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. (optional)
        versionTag - Filter by the version tag. (optional)
        versionTagLike - Filter by the version tag that the parameter is a substring of. (optional)
        withoutVersionTag - Only include process definitions without a `versionTag`. (optional)
        startableInTasklist - Filter by process definitions which are startable in Tasklist.. (optional)
        notStartableInTasklist - Filter by process definitions which are not startable in Tasklist. (optional)
        startablePermissionCheck - 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 (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getRenderedStartFormCall

        public okhttp3.Call getRenderedStartFormCall​(String id,
                                             ApiCallback _callback)
                                      throws ApiException
        Build call for getRenderedStartForm
        Parameters:
        id - The id of the process definition to get the rendered start form for. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getRenderedStartForm

        public File getRenderedStartForm​(String id)
                          throws ApiException
        Get Rendered Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        id - The id of the process definition to get the rendered start form for. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getRenderedStartFormWithHttpInfo

        public ApiResponse<File> getRenderedStartFormWithHttpInfo​(String id)
                                                   throws ApiException
        Get Rendered Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        id - The id of the process definition to get the rendered start form for. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getRenderedStartFormAsync

        public okhttp3.Call getRenderedStartFormAsync​(String id,
                                              ApiCallback<File> _callback)
                                       throws ApiException
        Get Rendered Start Form (asynchronously) 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        id - The id of the process definition to get the rendered start form for. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getRenderedStartFormByKeyCall

        public okhttp3.Call getRenderedStartFormByKeyCall​(String key,
                                                  ApiCallback _callback)
                                           throws ApiException
        Build call for getRenderedStartFormByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getRenderedStartFormByKey

        public File getRenderedStartFormByKey​(String key)
                               throws ApiException
        Get Rendered Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getRenderedStartFormByKeyWithHttpInfo

        public ApiResponse<File> getRenderedStartFormByKeyWithHttpInfo​(String key)
                                                        throws ApiException
        Get Rendered Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getRenderedStartFormByKeyAsync

        public okhttp3.Call getRenderedStartFormByKeyAsync​(String key,
                                                   ApiCallback<File> _callback)
                                            throws ApiException
        Get Rendered Start Form (asynchronously) 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getRenderedStartFormByKeyAndTenantIdCall

        public okhttp3.Call getRenderedStartFormByKeyAndTenantIdCall​(String key,
                                                             String tenantId,
                                                             ApiCallback _callback)
                                                      throws ApiException
        Build call for getRenderedStartFormByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getRenderedStartFormByKeyAndTenantId

        public File getRenderedStartFormByKeyAndTenantId​(String key,
                                                 String tenantId)
                                          throws ApiException
        Get Rendered Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        File
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getRenderedStartFormByKeyAndTenantIdWithHttpInfo

        public ApiResponse<File> getRenderedStartFormByKeyAndTenantIdWithHttpInfo​(String key,
                                                                          String tenantId)
                                                                   throws ApiException
        Get Rendered Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ApiResponse<File>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getRenderedStartFormByKeyAndTenantIdAsync

        public okhttp3.Call getRenderedStartFormByKeyAndTenantIdAsync​(String key,
                                                              String tenantId,
                                                              ApiCallback<File> _callback)
                                                       throws ApiException
        Get Rendered Start Form (asynchronously) 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStartFormCall

        public okhttp3.Call getStartFormCall​(String id,
                                     ApiCallback _callback)
                              throws ApiException
        Build call for getStartForm
        Parameters:
        id - The id of the process definition to get the start form key for. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStartForm

        public FormDto getStartForm​(String id)
                     throws ApiException
        Get Start Form Key Retrieves the key of the start form for a process definition. The form key corresponds to the `FormData#formKey` property in the engine.
        Parameters:
        id - The id of the process definition to get the start form key for. (required)
        Returns:
        FormDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormWithHttpInfo

        public ApiResponse<FormDto> getStartFormWithHttpInfo​(String id)
                                              throws ApiException
        Get Start Form Key Retrieves the key of the start form for a process definition. The form key corresponds to the `FormData#formKey` property in the engine.
        Parameters:
        id - The id of the process definition to get the start form key for. (required)
        Returns:
        ApiResponse<FormDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormAsync

        public okhttp3.Call getStartFormAsync​(String id,
                                      ApiCallback<FormDto> _callback)
                               throws ApiException
        Get Start Form Key (asynchronously) Retrieves the key of the start form for a process definition. The form key corresponds to the `FormData#formKey` property in the engine.
        Parameters:
        id - The id of the process definition to get the start form key for. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStartFormByKeyCall

        public okhttp3.Call getStartFormByKeyCall​(String key,
                                          ApiCallback _callback)
                                   throws ApiException
        Build call for getStartFormByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStartFormByKey

        public FormDto getStartFormByKey​(String key)
                          throws ApiException
        Get Start Form Key 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        Returns:
        FormDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormByKeyWithHttpInfo

        public ApiResponse<FormDto> getStartFormByKeyWithHttpInfo​(String key)
                                                   throws ApiException
        Get Start Form Key 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        Returns:
        ApiResponse<FormDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormByKeyAsync

        public okhttp3.Call getStartFormByKeyAsync​(String key,
                                           ApiCallback<FormDto> _callback)
                                    throws ApiException
        Get Start Form Key (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStartFormByKeyAndTenantIdCall

        public okhttp3.Call getStartFormByKeyAndTenantIdCall​(String key,
                                                     String tenantId,
                                                     ApiCallback _callback)
                                              throws ApiException
        Build call for getStartFormByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStartFormByKeyAndTenantId

        public FormDto getStartFormByKeyAndTenantId​(String key,
                                            String tenantId)
                                     throws ApiException
        Get Start Form Key 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        FormDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormByKeyAndTenantIdWithHttpInfo

        public ApiResponse<FormDto> getStartFormByKeyAndTenantIdWithHttpInfo​(String key,
                                                                     String tenantId)
                                                              throws ApiException
        Get Start Form Key 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        Returns:
        ApiResponse<FormDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormByKeyAndTenantIdAsync

        public okhttp3.Call getStartFormByKeyAndTenantIdAsync​(String key,
                                                      String tenantId,
                                                      ApiCallback<FormDto> _callback)
                                               throws ApiException
        Get Start Form Key (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) for which the form key is to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStartFormVariablesCall

        public okhttp3.Call getStartFormVariablesCall​(String id,
                                              String variableNames,
                                              Boolean deserializeValues,
                                              ApiCallback _callback)
                                       throws ApiException
        Build call for getStartFormVariables
        Parameters:
        id - The id of the process definition to retrieve the variables for. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStartFormVariables

        public Map<String,​VariableValueDto> getStartFormVariables​(String id,
                                                                String variableNames,
                                                                Boolean deserializeValues)
                                                         throws ApiException
        Get Start 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/7.18/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.
        Parameters:
        id - The id of the process definition to retrieve the variables for. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        Returns:
        Map<String, VariableValueDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormVariablesWithHttpInfo

        public ApiResponse<Map<String,​VariableValueDto>> getStartFormVariablesWithHttpInfo​(String id,
                                                                                         String variableNames,
                                                                                         Boolean deserializeValues)
                                                                                  throws ApiException
        Get Start 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/7.18/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.
        Parameters:
        id - The id of the process definition to retrieve the variables for. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        Returns:
        ApiResponse<Map<String, VariableValueDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormVariablesAsync

        public okhttp3.Call getStartFormVariablesAsync​(String id,
                                               String variableNames,
                                               Boolean deserializeValues,
                                               ApiCallback<Map<String,​VariableValueDto>> _callback)
                                        throws ApiException
        Get Start Form Variables (asynchronously) Retrieves the start form variables for a process definition (only if they are defined via the [Generated Task Form](https://docs.camunda.org/manual/7.18/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.
        Parameters:
        id - The id of the process definition to retrieve the variables for. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStartFormVariablesByKeyCall

        public okhttp3.Call getStartFormVariablesByKeyCall​(String key,
                                                   String variableNames,
                                                   Boolean deserializeValues,
                                                   ApiCallback _callback)
                                            throws ApiException
        Build call for getStartFormVariablesByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStartFormVariablesByKey

        public Map<String,​VariableValueDto> getStartFormVariablesByKey​(String key,
                                                                     String variableNames,
                                                                     Boolean deserializeValues)
                                                              throws ApiException
        Get Start 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/7.18/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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        Returns:
        Map<String, VariableValueDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormVariablesByKeyWithHttpInfo

        public ApiResponse<Map<String,​VariableValueDto>> getStartFormVariablesByKeyWithHttpInfo​(String key,
                                                                                              String variableNames,
                                                                                              Boolean deserializeValues)
                                                                                       throws ApiException
        Get Start 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/7.18/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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        Returns:
        ApiResponse<Map<String, VariableValueDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormVariablesByKeyAsync

        public okhttp3.Call getStartFormVariablesByKeyAsync​(String key,
                                                    String variableNames,
                                                    Boolean deserializeValues,
                                                    ApiCallback<Map<String,​VariableValueDto>> _callback)
                                             throws ApiException
        Get Start Form Variables (asynchronously) 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/7.18/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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStartFormVariablesByKeyAndTenantIdCall

        public okhttp3.Call getStartFormVariablesByKeyAndTenantIdCall​(String key,
                                                              String tenantId,
                                                              String variableNames,
                                                              Boolean deserializeValues,
                                                              ApiCallback _callback)
                                                       throws ApiException
        Build call for getStartFormVariablesByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStartFormVariablesByKeyAndTenantId

        public Map<String,​VariableValueDto> getStartFormVariablesByKeyAndTenantId​(String key,
                                                                                String tenantId,
                                                                                String variableNames,
                                                                                Boolean deserializeValues)
                                                                         throws ApiException
        Get Start 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/7.18/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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        Returns:
        Map<String, VariableValueDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormVariablesByKeyAndTenantIdWithHttpInfo

        public ApiResponse<Map<String,​VariableValueDto>> getStartFormVariablesByKeyAndTenantIdWithHttpInfo​(String key,
                                                                                                         String tenantId,
                                                                                                         String variableNames,
                                                                                                         Boolean deserializeValues)
                                                                                                  throws ApiException
        Get Start 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/7.18/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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        Returns:
        ApiResponse<Map<String, VariableValueDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStartFormVariablesByKeyAndTenantIdAsync

        public okhttp3.Call getStartFormVariablesByKeyAndTenantIdAsync​(String key,
                                                               String tenantId,
                                                               String variableNames,
                                                               Boolean deserializeValues,
                                                               ApiCallback<Map<String,​VariableValueDto>> _callback)
                                                        throws ApiException
        Get Start Form Variables (asynchronously) 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/7.18/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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        variableNames - 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. (optional)
        deserializeValues - 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. (optional, default to true)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • getStaticCalledProcessDefinitionsCall

        public okhttp3.Call getStaticCalledProcessDefinitionsCall​(String id,
                                                          ApiCallback _callback)
                                                   throws ApiException
        Build call for getStaticCalledProcessDefinitions
        Parameters:
        id - The id of the process definition. (required)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • getStaticCalledProcessDefinitions

        public List<CalledProcessDefinitionDto> getStaticCalledProcessDefinitions​(String id)
                                                                   throws ApiException
        Get Static Called Process Definitions For the given process, returns a list of called process definitions corresponding to the `CalledProcessDefinition` interface in the engine. The list contains all process definitions that are referenced statically by call activities in the given process. This endpoint does not resolve process definitions that are referenced with expressions. Each called process definition contains a list of call activity ids, which specifies the call activities that are calling that process. This endpoint does not resolve references to case definitions.
        Parameters:
        id - The id of the process definition. (required)
        Returns:
        List<CalledProcessDefinitionDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStaticCalledProcessDefinitionsWithHttpInfo

        public ApiResponse<List<CalledProcessDefinitionDto>> getStaticCalledProcessDefinitionsWithHttpInfo​(String id)
                                                                                            throws ApiException
        Get Static Called Process Definitions For the given process, returns a list of called process definitions corresponding to the `CalledProcessDefinition` interface in the engine. The list contains all process definitions that are referenced statically by call activities in the given process. This endpoint does not resolve process definitions that are referenced with expressions. Each called process definition contains a list of call activity ids, which specifies the call activities that are calling that process. This endpoint does not resolve references to case definitions.
        Parameters:
        id - The id of the process definition. (required)
        Returns:
        ApiResponse<List<CalledProcessDefinitionDto>>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • getStaticCalledProcessDefinitionsAsync

        public okhttp3.Call getStaticCalledProcessDefinitionsAsync​(String id,
                                                           ApiCallback<List<CalledProcessDefinitionDto>> _callback)
                                                    throws ApiException
        Get Static Called Process Definitions (asynchronously) For the given process, returns a list of called process definitions corresponding to the `CalledProcessDefinition` interface in the engine. The list contains all process definitions that are referenced statically by call activities in the given process. This endpoint does not resolve process definitions that are referenced with expressions. Each called process definition contains a list of call activity ids, which specifies the call activities that are calling that process. This endpoint does not resolve references to case definitions.
        Parameters:
        id - The id of the process definition. (required)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • restartProcessInstanceCall

        public okhttp3.Call restartProcessInstanceCall​(String id,
                                               RestartProcessInstanceDto restartProcessInstanceDto,
                                               ApiCallback _callback)
                                        throws ApiException
        Build call for restartProcessInstance
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • restartProcessInstance

        public void restartProcessInstance​(String id,
                                   RestartProcessInstanceDto restartProcessInstanceDto)
                            throws ApiException
        Restart Process Instance 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/7.18/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/7.18/user-guide/process-engine/process-instance-restart/#execution).
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • restartProcessInstanceWithHttpInfo

        public ApiResponse<Void> restartProcessInstanceWithHttpInfo​(String id,
                                                            RestartProcessInstanceDto restartProcessInstanceDto)
                                                     throws ApiException
        Restart Process Instance 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/7.18/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/7.18/user-guide/process-engine/process-instance-restart/#execution).
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • restartProcessInstanceAsync

        public okhttp3.Call restartProcessInstanceAsync​(String id,
                                                RestartProcessInstanceDto restartProcessInstanceDto,
                                                ApiCallback<Void> _callback)
                                         throws ApiException
        Restart Process Instance (asynchronously) 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/7.18/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/7.18/user-guide/process-engine/process-instance-restart/#execution).
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • restartProcessInstanceAsyncOperationCall

        public okhttp3.Call restartProcessInstanceAsyncOperationCall​(String id,
                                                             RestartProcessInstanceDto restartProcessInstanceDto,
                                                             ApiCallback _callback)
                                                      throws ApiException
        Build call for restartProcessInstanceAsyncOperation
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • restartProcessInstanceAsyncOperation

        public BatchDto restartProcessInstanceAsyncOperation​(String id,
                                                     RestartProcessInstanceDto restartProcessInstanceDto)
                                              throws ApiException
        Restart Process Instance 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/7.18/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/7.18/user-guide/process-engine/process-instance-restart/#execution).
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        Returns:
        BatchDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • restartProcessInstanceAsyncOperationWithHttpInfo

        public ApiResponse<BatchDto> restartProcessInstanceAsyncOperationWithHttpInfo​(String id,
                                                                              RestartProcessInstanceDto restartProcessInstanceDto)
                                                                       throws ApiException
        Restart Process Instance 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/7.18/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/7.18/user-guide/process-engine/process-instance-restart/#execution).
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        Returns:
        ApiResponse<BatchDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • restartProcessInstanceAsyncOperationAsync

        public okhttp3.Call restartProcessInstanceAsyncOperationAsync​(String id,
                                                              RestartProcessInstanceDto restartProcessInstanceDto,
                                                              ApiCallback<BatchDto> _callback)
                                                       throws ApiException
        Restart Process Instance Async (asynchronously) 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/7.18/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/7.18/user-guide/process-engine/process-instance-restart/#execution).
        Parameters:
        id - The id of the process definition of the process instances to restart. (required)
        restartProcessInstanceDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • startProcessInstanceCall

        public okhttp3.Call startProcessInstanceCall​(String id,
                                             StartProcessInstanceDto startProcessInstanceDto,
                                             ApiCallback _callback)
                                      throws ApiException
        Build call for startProcessInstance
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        startProcessInstanceDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • startProcessInstance

        public ProcessInstanceWithVariablesDto startProcessInstance​(String id,
                                                            StartProcessInstanceDto startProcessInstanceDto)
                                                     throws ApiException
        Start Instance Instantiates a given process definition. Process variables and business key may be supplied in the request body.
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        startProcessInstanceDto - (optional)
        Returns:
        ProcessInstanceWithVariablesDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • startProcessInstanceWithHttpInfo

        public ApiResponse<ProcessInstanceWithVariablesDto> startProcessInstanceWithHttpInfo​(String id,
                                                                                     StartProcessInstanceDto startProcessInstanceDto)
                                                                              throws ApiException
        Start Instance Instantiates a given process definition. Process variables and business key may be supplied in the request body.
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        startProcessInstanceDto - (optional)
        Returns:
        ApiResponse<ProcessInstanceWithVariablesDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • startProcessInstanceAsync

        public okhttp3.Call startProcessInstanceAsync​(String id,
                                              StartProcessInstanceDto startProcessInstanceDto,
                                              ApiCallback<ProcessInstanceWithVariablesDto> _callback)
                                       throws ApiException
        Start Instance (asynchronously) Instantiates a given process definition. Process variables and business key may be supplied in the request body.
        Parameters:
        id - The id of the process definition to be retrieved. (required)
        startProcessInstanceDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • startProcessInstanceByKeyCall

        public okhttp3.Call startProcessInstanceByKeyCall​(String key,
                                                  StartProcessInstanceDto startProcessInstanceDto,
                                                  ApiCallback _callback)
                                           throws ApiException
        Build call for startProcessInstanceByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        startProcessInstanceDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • startProcessInstanceByKey

        public ProcessInstanceWithVariablesDto startProcessInstanceByKey​(String key,
                                                                 StartProcessInstanceDto startProcessInstanceDto)
                                                          throws ApiException
        Start Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        startProcessInstanceDto - (optional)
        Returns:
        ProcessInstanceWithVariablesDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • startProcessInstanceByKeyWithHttpInfo

        public ApiResponse<ProcessInstanceWithVariablesDto> startProcessInstanceByKeyWithHttpInfo​(String key,
                                                                                          StartProcessInstanceDto startProcessInstanceDto)
                                                                                   throws ApiException
        Start Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        startProcessInstanceDto - (optional)
        Returns:
        ApiResponse<ProcessInstanceWithVariablesDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • startProcessInstanceByKeyAsync

        public okhttp3.Call startProcessInstanceByKeyAsync​(String key,
                                                   StartProcessInstanceDto startProcessInstanceDto,
                                                   ApiCallback<ProcessInstanceWithVariablesDto> _callback)
                                            throws ApiException
        Start Instance (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        startProcessInstanceDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • startProcessInstanceByKeyAndTenantIdCall

        public okhttp3.Call startProcessInstanceByKeyAndTenantIdCall​(String key,
                                                             String tenantId,
                                                             StartProcessInstanceDto startProcessInstanceDto,
                                                             ApiCallback _callback)
                                                      throws ApiException
        Build call for startProcessInstanceByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • startProcessInstanceByKeyAndTenantId

        public ProcessInstanceWithVariablesDto startProcessInstanceByKeyAndTenantId​(String key,
                                                                            String tenantId,
                                                                            StartProcessInstanceDto startProcessInstanceDto)
                                                                     throws ApiException
        Start Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceDto - (optional)
        Returns:
        ProcessInstanceWithVariablesDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • startProcessInstanceByKeyAndTenantIdWithHttpInfo

        public ApiResponse<ProcessInstanceWithVariablesDto> startProcessInstanceByKeyAndTenantIdWithHttpInfo​(String key,
                                                                                                     String tenantId,
                                                                                                     StartProcessInstanceDto startProcessInstanceDto)
                                                                                              throws ApiException
        Start Instance 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceDto - (optional)
        Returns:
        ApiResponse<ProcessInstanceWithVariablesDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • startProcessInstanceByKeyAndTenantIdAsync

        public okhttp3.Call startProcessInstanceByKeyAndTenantIdAsync​(String key,
                                                              String tenantId,
                                                              StartProcessInstanceDto startProcessInstanceDto,
                                                              ApiCallback<ProcessInstanceWithVariablesDto> _callback)
                                                       throws ApiException
        Start Instance (asynchronously) 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.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be retrieved. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • submitFormCall

        public okhttp3.Call submitFormCall​(String id,
                                   StartProcessInstanceFormDto startProcessInstanceFormDto,
                                   ApiCallback _callback)
                            throws ApiException
        Build call for submitForm
        Parameters:
        id - The id of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • submitForm

        public ProcessInstanceDto submitForm​(String id,
                                     StartProcessInstanceFormDto startProcessInstanceFormDto)
                              throws ApiException
        Submit Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        id - The id of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        Returns:
        ProcessInstanceDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • submitFormWithHttpInfo

        public ApiResponse<ProcessInstanceDto> submitFormWithHttpInfo​(String id,
                                                              StartProcessInstanceFormDto startProcessInstanceFormDto)
                                                       throws ApiException
        Submit Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        id - The id of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        Returns:
        ApiResponse<ProcessInstanceDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • submitFormAsync

        public okhttp3.Call submitFormAsync​(String id,
                                    StartProcessInstanceFormDto startProcessInstanceFormDto,
                                    ApiCallback<ProcessInstanceDto> _callback)
                             throws ApiException
        Submit Start Form (asynchronously) 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        id - The id of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • submitFormByKeyCall

        public okhttp3.Call submitFormByKeyCall​(String key,
                                        StartProcessInstanceFormDto startProcessInstanceFormDto,
                                        ApiCallback _callback)
                                 throws ApiException
        Build call for submitFormByKey
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • submitFormByKey

        public ProcessInstanceDto submitFormByKey​(String key,
                                          StartProcessInstanceFormDto startProcessInstanceFormDto)
                                   throws ApiException
        Submit Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        Returns:
        ProcessInstanceDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • submitFormByKeyWithHttpInfo

        public ApiResponse<ProcessInstanceDto> submitFormByKeyWithHttpInfo​(String key,
                                                                   StartProcessInstanceFormDto startProcessInstanceFormDto)
                                                            throws ApiException
        Submit Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        Returns:
        ApiResponse<ProcessInstanceDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • submitFormByKeyAsync

        public okhttp3.Call submitFormByKeyAsync​(String key,
                                         StartProcessInstanceFormDto startProcessInstanceFormDto,
                                         ApiCallback<ProcessInstanceDto> _callback)
                                  throws ApiException
        Submit Start Form (asynchronously) 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        startProcessInstanceFormDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • submitFormByKeyAndTenantIdCall

        public okhttp3.Call submitFormByKeyAndTenantIdCall​(String key,
                                                   String tenantId,
                                                   StartProcessInstanceFormDto startProcessInstanceFormDto,
                                                   ApiCallback _callback)
                                            throws ApiException
        Build call for submitFormByKeyAndTenantId
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceFormDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • submitFormByKeyAndTenantId

        public ProcessInstanceDto submitFormByKeyAndTenantId​(String key,
                                                     String tenantId,
                                                     StartProcessInstanceFormDto startProcessInstanceFormDto)
                                              throws ApiException
        Submit Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceFormDto - (optional)
        Returns:
        ProcessInstanceDto
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • submitFormByKeyAndTenantIdWithHttpInfo

        public ApiResponse<ProcessInstanceDto> submitFormByKeyAndTenantIdWithHttpInfo​(String key,
                                                                              String tenantId,
                                                                              StartProcessInstanceFormDto startProcessInstanceFormDto)
                                                                       throws ApiException
        Submit Start 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceFormDto - (optional)
        Returns:
        ApiResponse<ProcessInstanceDto>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • submitFormByKeyAndTenantIdAsync

        public okhttp3.Call submitFormByKeyAndTenantIdAsync​(String key,
                                                    String tenantId,
                                                    StartProcessInstanceFormDto startProcessInstanceFormDto,
                                                    ApiCallback<ProcessInstanceDto> _callback)
                                             throws ApiException
        Submit Start Form (asynchronously) 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/7.18/user-guide/task-forms/#generated-task-forms).
        Parameters:
        key - The key of the process definition to submit the form for. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        startProcessInstanceFormDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateHistoryTimeToLiveByProcessDefinitionIdCall

        public okhttp3.Call updateHistoryTimeToLiveByProcessDefinitionIdCall​(String id,
                                                                     HistoryTimeToLiveDto historyTimeToLiveDto,
                                                                     ApiCallback _callback)
                                                              throws ApiException
        Build call for updateHistoryTimeToLiveByProcessDefinitionId
        Parameters:
        id - The id of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateHistoryTimeToLiveByProcessDefinitionId

        public void updateHistoryTimeToLiveByProcessDefinitionId​(String id,
                                                         HistoryTimeToLiveDto historyTimeToLiveDto)
                                                  throws ApiException
        Update History Time to Live Updates history time to live for process definition. The field is used within [History cleanup](https://docs.camunda.org/manual/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        id - The id of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateHistoryTimeToLiveByProcessDefinitionIdWithHttpInfo

        public ApiResponse<Void> updateHistoryTimeToLiveByProcessDefinitionIdWithHttpInfo​(String id,
                                                                                  HistoryTimeToLiveDto historyTimeToLiveDto)
                                                                           throws ApiException
        Update History Time to Live Updates history time to live for process definition. The field is used within [History cleanup](https://docs.camunda.org/manual/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        id - The id of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateHistoryTimeToLiveByProcessDefinitionIdAsync

        public okhttp3.Call updateHistoryTimeToLiveByProcessDefinitionIdAsync​(String id,
                                                                      HistoryTimeToLiveDto historyTimeToLiveDto,
                                                                      ApiCallback<Void> _callback)
                                                               throws ApiException
        Update History Time to Live (asynchronously) Updates history time to live for process definition. The field is used within [History cleanup](https://docs.camunda.org/manual/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        id - The id of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateHistoryTimeToLiveByProcessDefinitionKeyCall

        public okhttp3.Call updateHistoryTimeToLiveByProcessDefinitionKeyCall​(String key,
                                                                      HistoryTimeToLiveDto historyTimeToLiveDto,
                                                                      ApiCallback _callback)
                                                               throws ApiException
        Build call for updateHistoryTimeToLiveByProcessDefinitionKey
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateHistoryTimeToLiveByProcessDefinitionKey

        public void updateHistoryTimeToLiveByProcessDefinitionKey​(String key,
                                                          HistoryTimeToLiveDto historyTimeToLiveDto)
                                                   throws ApiException
        Update 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/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateHistoryTimeToLiveByProcessDefinitionKeyWithHttpInfo

        public ApiResponse<Void> updateHistoryTimeToLiveByProcessDefinitionKeyWithHttpInfo​(String key,
                                                                                   HistoryTimeToLiveDto historyTimeToLiveDto)
                                                                            throws ApiException
        Update 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/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateHistoryTimeToLiveByProcessDefinitionKeyAsync

        public okhttp3.Call updateHistoryTimeToLiveByProcessDefinitionKeyAsync​(String key,
                                                                       HistoryTimeToLiveDto historyTimeToLiveDto,
                                                                       ApiCallback<Void> _callback)
                                                                throws ApiException
        Update History Time to Live (asynchronously) 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/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        historyTimeToLiveDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantIdCall

        public okhttp3.Call updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantIdCall​(String key,
                                                                                 String tenantId,
                                                                                 HistoryTimeToLiveDto historyTimeToLiveDto,
                                                                                 ApiCallback _callback)
                                                                          throws ApiException
        Build call for updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantId
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        historyTimeToLiveDto - (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantId

        public void updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantId​(String key,
                                                                     String tenantId,
                                                                     HistoryTimeToLiveDto historyTimeToLiveDto)
                                                              throws ApiException
        Update 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/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        historyTimeToLiveDto - (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantIdWithHttpInfo

        public ApiResponse<Void> updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantIdWithHttpInfo​(String key,
                                                                                              String tenantId,
                                                                                              HistoryTimeToLiveDto historyTimeToLiveDto)
                                                                                       throws ApiException
        Update 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/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        historyTimeToLiveDto - (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantIdAsync

        public okhttp3.Call updateHistoryTimeToLiveByProcessDefinitionKeyAndTenantIdAsync​(String key,
                                                                                  String tenantId,
                                                                                  HistoryTimeToLiveDto historyTimeToLiveDto,
                                                                                  ApiCallback<Void> _callback)
                                                                           throws ApiException
        Update History Time to Live (asynchronously) 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/7.18/user-guide/process-engine/history/#history-cleanup).
        Parameters:
        key - The key of the process definition to change history time to live. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        historyTimeToLiveDto - (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateProcessDefinitionSuspensionStateCall

        public okhttp3.Call updateProcessDefinitionSuspensionStateCall​(ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                               ApiCallback _callback)
                                                        throws ApiException
        Build call for updateProcessDefinitionSuspensionState
        Parameters:
        processDefinitionSuspensionStateDto - **Note**: Unallowed property is `processDefinitionId`. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateProcessDefinitionSuspensionState

        public void updateProcessDefinitionSuspensionState​(ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                            throws ApiException
        Activate/Suspend By Key Activates or suspends process definitions with the given process definition key.
        Parameters:
        processDefinitionSuspensionStateDto - **Note**: Unallowed property is `processDefinitionId`. (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateWithHttpInfo

        public ApiResponse<Void> updateProcessDefinitionSuspensionStateWithHttpInfo​(ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                                     throws ApiException
        Activate/Suspend By Key Activates or suspends process definitions with the given process definition key.
        Parameters:
        processDefinitionSuspensionStateDto - **Note**: Unallowed property is `processDefinitionId`. (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateAsync

        public okhttp3.Call updateProcessDefinitionSuspensionStateAsync​(ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                ApiCallback<Void> _callback)
                                                         throws ApiException
        Activate/Suspend By Key (asynchronously) Activates or suspends process definitions with the given process definition key.
        Parameters:
        processDefinitionSuspensionStateDto - **Note**: Unallowed property is `processDefinitionId`. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateProcessDefinitionSuspensionStateByIdCall

        public okhttp3.Call updateProcessDefinitionSuspensionStateByIdCall​(String id,
                                                                   ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                   ApiCallback _callback)
                                                            throws ApiException
        Build call for updateProcessDefinitionSuspensionStateById
        Parameters:
        id - The id of the process definition to activate or suspend. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateProcessDefinitionSuspensionStateById

        public void updateProcessDefinitionSuspensionStateById​(String id,
                                                       ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                throws ApiException
        Activate/Suspend By Id Activates or suspends a given process definition by id.
        Parameters:
        id - The id of the process definition to activate or suspend. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateByIdWithHttpInfo

        public ApiResponse<Void> updateProcessDefinitionSuspensionStateByIdWithHttpInfo​(String id,
                                                                                ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                                         throws ApiException
        Activate/Suspend By Id Activates or suspends a given process definition by id.
        Parameters:
        id - The id of the process definition to activate or suspend. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateByIdAsync

        public okhttp3.Call updateProcessDefinitionSuspensionStateByIdAsync​(String id,
                                                                    ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                    ApiCallback<Void> _callback)
                                                             throws ApiException
        Activate/Suspend By Id (asynchronously) Activates or suspends a given process definition by id.
        Parameters:
        id - The id of the process definition to activate or suspend. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateProcessDefinitionSuspensionStateByKeyCall

        public okhttp3.Call updateProcessDefinitionSuspensionStateByKeyCall​(String key,
                                                                    ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                    ApiCallback _callback)
                                                             throws ApiException
        Build call for updateProcessDefinitionSuspensionStateByKey
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateProcessDefinitionSuspensionStateByKey

        public void updateProcessDefinitionSuspensionStateByKey​(String key,
                                                        ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                 throws ApiException
        Activate/Suspend by Id Activates or suspends a given process definition by latest version of process definition key which belongs to no tenant.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateByKeyWithHttpInfo

        public ApiResponse<Void> updateProcessDefinitionSuspensionStateByKeyWithHttpInfo​(String key,
                                                                                 ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                                          throws ApiException
        Activate/Suspend by Id Activates or suspends a given process definition by latest version of process definition key which belongs to no tenant.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateByKeyAsync

        public okhttp3.Call updateProcessDefinitionSuspensionStateByKeyAsync​(String key,
                                                                     ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                     ApiCallback<Void> _callback)
                                                              throws ApiException
        Activate/Suspend by Id (asynchronously) Activates or suspends a given process definition by latest version of process definition key which belongs to no tenant.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object

      • updateProcessDefinitionSuspensionStateByKeyAndTenantIdCall

        public okhttp3.Call updateProcessDefinitionSuspensionStateByKeyAndTenantIdCall​(String key,
                                                                               String tenantId,
                                                                               ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                               ApiCallback _callback)
                                                                        throws ApiException
        Build call for updateProcessDefinitionSuspensionStateByKeyAndTenantId
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        _callback - Callback for upload/download progress
        Returns:
        Call to execute
        Throws:
        ApiException - If fail to serialize the request body object

      • updateProcessDefinitionSuspensionStateByKeyAndTenantId

        public void updateProcessDefinitionSuspensionStateByKeyAndTenantId​(String key,
                                                                   String tenantId,
                                                                   ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                            throws ApiException
        Activate/Suspend by Id Activates or suspends a given process definition by the latest version of the process definition for tenant.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateByKeyAndTenantIdWithHttpInfo

        public ApiResponse<Void> updateProcessDefinitionSuspensionStateByKeyAndTenantIdWithHttpInfo​(String key,
                                                                                            String tenantId,
                                                                                            ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto)
                                                                                     throws ApiException
        Activate/Suspend by Id Activates or suspends a given process definition by the latest version of the process definition for tenant.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        Returns:
        ApiResponse<Void>
        Throws:
        ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body

      • updateProcessDefinitionSuspensionStateByKeyAndTenantIdAsync

        public okhttp3.Call updateProcessDefinitionSuspensionStateByKeyAndTenantIdAsync​(String key,
                                                                                String tenantId,
                                                                                ProcessDefinitionSuspensionStateDto processDefinitionSuspensionStateDto,
                                                                                ApiCallback<Void> _callback)
                                                                         throws ApiException
        Activate/Suspend by Id (asynchronously) Activates or suspends a given process definition by the latest version of the process definition for tenant.
        Parameters:
        key - The key of the process definition (the latest version thereof) to be activated/suspended. (required)
        tenantId - The id of the tenant the process definition belongs to. (required)
        processDefinitionSuspensionStateDto - **Note**: Unallowed properties are `processDefinitionId` and `processDefinitionKey`. (optional)
        _callback - The callback to be executed when the API call finishes
        Returns:
        The request call
        Throws:
        ApiException - If fail to process the API call, e.g. serializing the request body object