@aerokit/sdk 12.44.0

package/dist/cjs/bpm/tasks.js

@@ -0,0 +1,973 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tasks_exports = {};
+__export(tasks_exports, {
+  DelegationState: () => DelegationState,
+  NullHandlingOnOrder: () => NullHandlingOnOrder,
+  TaskService: () => TaskService,
+  Tasks: () => Tasks
+});
+module.exports = __toCommonJS(tasks_exports);
+var import_io = require("@aerokit/sdk/io");
+var import_values = require("@aerokit/sdk/bpm/values");
+const BpmFacade = Java.type("org.eclipse.dirigible.components.api.bpm.BpmFacade");
+class Tasks {
+  static list() {
+    const tasks = JSON.parse(BpmFacade.getTasks());
+    return tasks.map((e) => new TaskData(e));
+  }
+  static getVariable(taskId, variableName) {
+    return import_values.Values.parseValue(BpmFacade.getTaskVariable(taskId, variableName));
+  }
+  /**
+   * Returns all variables. This will include all variables of parent scopes too.
+   */
+  static getVariables(taskId) {
+    return import_values.Values.parseValuesMap(BpmFacade.getTaskVariables(taskId));
+  }
+  static setVariable(taskId, variableName, value) {
+    BpmFacade.setTaskVariable(taskId, variableName, import_values.Values.stringifyValue(value));
+  }
+  static setVariables(taskId, variables) {
+    BpmFacade.setTaskVariables(taskId, import_values.Values.stringifyValuesMap(variables));
+  }
+  static complete(taskId, variables = {}) {
+    BpmFacade.completeTask(taskId, JSON.stringify(variables));
+  }
+  static getTaskService() {
+    return new TaskService(BpmFacade.getBpmProviderFlowable().getTaskService());
+  }
+}
+class TaskService {
+  constructor(taskService) {
+    this.taskService = taskService;
+  }
+  /**
+   * Creates a new task that is not related to any process instance.
+   * 
+   * The returned task is transient and must be saved with {@link #saveTask(Task)} 'manually'.
+   */
+  newTask(taskId) {
+    if (this.isNotNull(taskId)) {
+      return this.taskService.newTask(taskId);
+    }
+    return this.taskService.newTask();
+  }
+  /**
+   * Create a builder for the task
+   * 
+   * @return task builder
+   */
+  createTaskBuilder() {
+    return this.taskService.createTaskBuilder();
+  }
+  /**
+   * Saves the given task to the persistent data store. If the task is already present in the persistent store, it is updated. After a new task has been saved, the task instance passed into this
+   * method is updated with the id of the newly created task.
+   * 
+   * @param task
+   *            the task, cannot be null.
+   */
+  saveTask(task) {
+    this.taskService.saveTask(task);
+  }
+  /**
+   * Saves the given tasks to the persistent data store. If the tasks are already present in the persistent store, it is updated. After a new task has been saved, the task instance passed into this
+   * method is updated with the id of the newly created task.
+   *
+   * @param taskList the list of task instances, cannot be null.
+   */
+  bulkSaveTasks(taskList) {
+    this.taskService.bulkSaveTasks(taskList);
+  }
+  /**
+   * Deletes the given task, not deleting historic information that is related to this task.
+   * 
+   * @param taskId
+   *            The id of the task that will be deleted, cannot be null. If no task exists with the given taskId, the operation is ignored.
+   * @param cascade
+   *            If cascade is true, also the historic information related to this task is deleted.
+   * @throws FlowableObjectNotFoundException
+   *             when the task with given id does not exist.
+   * @throws FlowableException
+   *             when an error occurs while deleting the task or in case the task is part of a running process.
+   */
+  deleteTask(taskId, cascade) {
+    if (this.isNotNull(cascade)) {
+      this.taskService.deleteTask(taskId, cascade);
+    } else {
+      this.taskService.deleteTask(taskId);
+    }
+  }
+  /**
+   * Deletes all tasks of the given collection, not deleting historic information that is related to these tasks.
+   * 
+   * @param taskIds
+   *            The id's of the tasks that will be deleted, cannot be null. All id's in the list that don't have an existing task will be ignored.
+   * @param cascade
+   *            If cascade is true, also the historic information related to this task is deleted.
+   * @throws FlowableObjectNotFoundException
+   *             when one of the task does not exist.
+   * @throws FlowableException
+   *             when an error occurs while deleting the tasks or in case one of the tasks is part of a running process.
+   */
+  deleteTasks(taskIds, cascade) {
+    if (this.isNotNull(cascade)) {
+      this.taskService.deleteTasks(taskIds, cascade);
+    } else {
+      this.taskService.deleteTasks(taskIds);
+    }
+  }
+  /**
+   * Deletes the given task, not deleting historic information that is related to this task..
+   * 
+   * @param taskId
+   *            The id of the task that will be deleted, cannot be null. If no task exists with the given taskId, the operation is ignored.
+   * @param deleteReason
+   *            reason the task is deleted. Is recorded in history, if enabled.
+   * @throws FlowableObjectNotFoundException
+   *             when the task with given id does not exist.
+   * @throws FlowableException
+   *             when an error occurs while deleting the task or in case the task is part of a running process
+   */
+  deleteTaskWithReason(taskId, deleteReason) {
+    this.taskService.deleteTask(taskId, deleteReason);
+  }
+  /**
+   * Deletes all tasks of the given collection, not deleting historic information that is related to these tasks.
+   * 
+   * @param taskIds
+   *            The id's of the tasks that will be deleted, cannot be null. All id's in the list that don't have an existing task will be ignored.
+   * @param deleteReason
+   *            reason the task is deleted. Is recorded in history, if enabled.
+   * @throws FlowableObjectNotFoundException
+   *             when one of the tasks does not exist.
+   * @throws FlowableException
+   *             when an error occurs while deleting the tasks or in case one of the tasks is part of a running process.
+   */
+  deleteTasksWithReason(taskIds, deleteReason) {
+    this.taskService.deleteTasks(taskIds, deleteReason);
+  }
+  /**
+   * Claim responsibility for a task: the given user is made assignee for the task. The difference with {@link #setAssignee(String, String)} is that here a check is done if the task already has a
+   * user assigned to it. No check is done whether the user is known by the identity component.
+   * 
+   * @param taskId
+   *            task to claim, cannot be null.
+   * @param userId
+   *            user that claims the task. When userId is null the task is unclaimed, assigned to no one.
+   * @throws FlowableObjectNotFoundException
+   *             when the task doesn't exist.
+   * @throws org.flowable.common.engine.api.FlowableTaskAlreadyClaimedException
+   *             when the task is already claimed by another user
+   */
+  claim(taskId, userId) {
+    this.taskService.claim(taskId, userId);
+  }
+  /**
+   * A shortcut to {@link #claim} with null user in order to unclaim the task
+   * 
+   * @param taskId
+   *            task to unclaim, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task doesn't exist.
+   */
+  unclaim(taskId) {
+    this.taskService.unclaim(taskId);
+  }
+  /**
+   * Set the task state to in progress. No check is done whether the user is known by the identity component.
+   * 
+   * @param taskId
+   *            task to change the state, cannot be null.
+   * @param userId
+   *            user that puts the task in progress.
+   * @throws FlowableObjectNotFoundException
+   *             when the task doesn't exist.
+   */
+  startProgress(taskId, userId) {
+    this.taskService.startProgress(taskId, userId);
+  }
+  /**
+   * Suspends the task. No check is done whether the user is known by the identity component.
+   * 
+   * @param taskId
+   *            task to suspend, cannot be null.
+   * @param userId
+   *            user that suspends the task.
+   * @throws FlowableObjectNotFoundException
+   *             when the task doesn't exist.
+   */
+  suspendTask(taskId, userId) {
+    this.taskService.suspendTask(taskId, userId);
+  }
+  /**
+   * Activates the task. No check is done whether the user is known by the identity component.
+   * 
+   * @param taskId
+   *            task to activate, cannot be null.
+   * @param userId
+   *            user that activates the task.
+   * @throws FlowableObjectNotFoundException
+   *             when the task doesn't exist.
+   */
+  activateTask(taskId, userId) {
+    this.taskService.activateTask(taskId, userId);
+  }
+  /**
+   * Delegates the task to another user. This means that the assignee is set and the delegation state is set to {@link DelegationState#PENDING}. If no owner is set on the task, the owner is set to
+   * the current assignee of the task.
+   * 
+   * @param taskId
+   *            The id of the task that will be delegated.
+   * @param userId
+   *            The id of the user that will be set as assignee.
+   * @throws FlowableObjectNotFoundException
+   *             when no task exists with the given id.
+   */
+  delegateTask(taskId, userId) {
+    this.taskService.delegateTask(taskId, userId);
+  }
+  /**
+   * Marks that the assignee is done with this task and that it can be send back to the owner. Can only be called when this task is {@link DelegationState#PENDING} delegation. After this method
+   * returns, the {@link Task#getDelegationState() delegationState} is set to {@link DelegationState#RESOLVED}.
+   * 
+   * @param taskId
+   *            the id of the task to resolve, cannot be null.
+   * @param variables
+   * @param transientVariables
+   * @throws FlowableObjectNotFoundException
+   *             when no task exists with the given id.
+   */
+  resolveTask(taskId, variables, transientVariables) {
+    if (this.isNotNull(variables) && this.isNotNull(transientVariables)) {
+      this.taskService.resolveTask(taskId, variables, transientVariables);
+    } else if (this.isNotNull(variables)) {
+      this.taskService.resolveTask(taskId, variables);
+    } else {
+      this.taskService.resolveTask(taskId);
+    }
+  }
+  /**
+   * Called when the task is successfully executed.
+   * 
+   * @param taskId
+   *            the id of the task to complete, cannot be null.
+   * @param userId
+   *            user that completes the task.
+   * @param variables
+   *            task parameters. May be null or empty.
+   * @param transientVariables
+   *            task parameters. May be null or empty.
+   * @param localScope
+   *            If true, the provided variables will be stored task-local, instead of process instance wide (which is the default behaviour).
+   * @throws FlowableObjectNotFoundException
+   *             when no task exists with the given id.
+   * @throws FlowableException
+   *             when this task is {@link DelegationState#PENDING} delegation.
+   */
+  complete(taskId, userId, variables, transientVariables, localScope) {
+    if (this.isNotNull(userId) && this.isNotNull(variables) && this.isNotNull(localScope)) {
+      this.taskService.complete(taskId, userId, variables, localScope);
+    } else if (this.isNotNull(variables) && this.isNotNull(localScope)) {
+      this.taskService.complete(taskId, variables, localScope);
+    } else if (this.isNotNull(userId) && this.isNotNull(variables) && this.isNotNull(transientVariables)) {
+      this.taskService.complete(taskId, userId, variables, transientVariables);
+    } else if (this.isNotNull(variables) && this.isNotNull(transientVariables)) {
+      this.taskService.complete(taskId, variables, transientVariables);
+    } else if (this.isNotNull(userId) && this.isNotNull(variables)) {
+      this.taskService.complete(taskId, userId, variables);
+    } else if (this.isNotNull(variables)) {
+      this.taskService.complete(taskId, variables);
+    } else if (this.isNotNull(userId)) {
+      this.taskService.complete(taskId, userId);
+    } else {
+      this.taskService.complete(taskId);
+    }
+  }
+  /**
+   * Called when the task is successfully executed, and the task form has been submitted.
+   * 
+   * @param taskId
+   *            the id of the task to complete, cannot be null.
+   * @param formDefinitionId
+   *            the id of the form definition that is filled-in to complete the task, cannot be null.
+   * @param outcome
+   *            the outcome of the completed form, can be null.
+   * @param variables
+   *            values of the completed form. May be null or empty.
+   * @param userId
+   *            user that completes the task.
+   * @param transientVariables
+   *            additional transient values that need to added to the process instance transient variables. May be null or empty.
+   * @param localScope
+   *            If true, the provided variables will be stored task-local, instead of process instance wide (which is the default for {@link #complete(String, Map)}).
+   * @throws FlowableObjectNotFoundException
+   *             when no task exists with the given id.
+   */
+  completeTaskWithForm(taskId, formDefinitionId, outcome, variables, userId, transientVariables, localScope) {
+    if (this.isNotNull(userId) && this.isNotNull(localScope)) {
+      this.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, userId, variables, localScope);
+    } else if (this.isNotNull(localScope)) {
+      this.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, variables, localScope);
+    } else if (this.isNotNull(userId) && this.isNotNull(transientVariables)) {
+      this.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, userId, variables, transientVariables);
+    } else if (this.isNotNull(transientVariables)) {
+      this.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, variables, transientVariables);
+    } else if (this.isNotNull(userId)) {
+      this.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, userId, variables);
+    } else {
+      this.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, variables);
+    }
+  }
+  /**
+   * Gets a Form model instance of the task form of a specific task
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param ignoreVariables
+   *            should the variables be ignored when fetching the form model?
+   * @throws FlowableObjectNotFoundException
+   *             when the task or form definition doesn't exist.
+   */
+  getTaskFormModel(taskId, ignoreVariables) {
+    if (this.isNotNull(ignoreVariables)) {
+      return this.taskService.getTaskFormModel(taskId, ignoreVariables);
+    } else {
+      return this.taskService.getTaskFormModel(taskId);
+    }
+  }
+  /**
+   * Changes the assignee of the given task to the given userId. No check is done whether the user is known by the identity component.
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param userId
+   *            id of the user to use as assignee.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  setAssignee(taskId, userId) {
+    this.taskService.setAssignee(taskId, userId);
+  }
+  /**
+   * Transfers ownership of this task to another user. No check is done whether the user is known by the identity component.
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param userId
+   *            of the person that is receiving ownership.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  setOwner(taskId, userId) {
+    this.taskService.setOwner(taskId, userId);
+  }
+  /**
+   * Retrieves the {@link IdentityLink}s associated with the given task. Such an {@link IdentityLink} informs how a certain identity (eg. group or user) is associated with a certain task (eg. as
+   * candidate, assignee, etc.)
+   */
+  getIdentityLinksForTask(taskId) {
+    return this.taskService.getIdentityLinksForTask(taskId);
+  }
+  /**
+   * Convenience shorthand for {@link #addUserIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param userId
+   *            id of the user to use as candidate, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  addCandidateUser(taskId, userId) {
+    this.taskService.addCandidateUser(taskId, userId);
+  }
+  /**
+   * Convenience shorthand for {@link #addGroupIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param groupId
+   *            id of the group to use as candidate, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or group doesn't exist.
+   */
+  addCandidateGroup(taskId, groupId) {
+    this.taskService.addCandidateGroup(taskId, groupId);
+  }
+  /**
+   * Involves a user with a task. The type of identity link is defined by the given identityLinkType.
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param userId
+   *            id of the user involve, cannot be null.
+   * @param identityLinkType
+   *            type of identityLink, cannot be null (@see {@link IdentityLinkType}).
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  addUserIdentityLink(taskId, userId, identityLinkType) {
+    this.taskService.addUserIdentityLink(taskId, userId, identityLinkType);
+  }
+  /**
+   * Involves a group with a task. The type of identityLink is defined by the given identityLink.
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param groupId
+   *            id of the group to involve, cannot be null.
+   * @param identityLinkType
+   *            type of identity, cannot be null (@see {@link IdentityLinkType}).
+   * @throws FlowableObjectNotFoundException
+   *             when the task or group doesn't exist.
+   */
+  addGroupIdentityLink(taskId, groupId, identityLinkType) {
+    this.taskService.addGroupIdentityLink(taskId, groupId, identityLinkType);
+  }
+  /**
+   * Convenience shorthand for {@link #deleteUserIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param userId
+   *            id of the user to use as candidate, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  deleteCandidateUser(taskId, userId) {
+    this.taskService.deleteCandidateUser(taskId, userId);
+  }
+  /**
+   * Convenience shorthand for {@link #deleteGroupIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param groupId
+   *            id of the group to use as candidate, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or group doesn't exist.
+   */
+  deleteCandidateGroup(taskId, groupId) {
+    this.taskService.deleteCandidateGroup(taskId, groupId);
+  }
+  /**
+   * Removes the association between a user and a task for the given identityLinkType.
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param userId
+   *            id of the user involve, cannot be null.
+   * @param identityLinkType
+   *            type of identityLink, cannot be null (@see {@link IdentityLinkType}).
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  deleteUserIdentityLink(taskId, userId, identityLinkType) {
+    this.taskService.deleteUserIdentityLink(taskId, userId, identityLinkType);
+  }
+  /**
+   * Removes the association between a group and a task for the given identityLinkType.
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param groupId
+   *            id of the group to involve, cannot be null.
+   * @param identityLinkType
+   *            type of identity, cannot be null (@see {@link IdentityLinkType}).
+   * @throws FlowableObjectNotFoundException
+   *             when the task or group doesn't exist.
+   */
+  deleteGroupIdentityLink(taskId, groupId, identityLinkType) {
+    this.taskService.deleteGroupIdentityLink(taskId, groupId, identityLinkType);
+  }
+  /**
+   * Changes the priority of the task.
+   * 
+   * Authorization: actual owner / business admin
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param priority
+   *            the new priority for the task.
+   * @throws FlowableObjectNotFoundException
+   *             when the task doesn't exist.
+   */
+  setPriority(taskId, priority) {
+    this.taskService.setPriority(taskId, priority);
+  }
+  /**
+   * Changes the due date of the task
+   * 
+   * @param taskId
+   *            id of the task, cannot be null.
+   * @param dueDate
+   *            the new due date for the task
+   * @throws FlowableException
+   *             when the task doesn't exist.
+   */
+  setDueDate(taskId, dueDate) {
+    this.taskService.setDueDate(taskId, dueDate);
+  }
+  /**
+   * set variable on a task. If the variable is not already existing, it will be created in the most outer scope. This means the process instance in case this task is related to an execution.
+   */
+  setVariable(taskId, variableName, value) {
+    this.taskService.setVariable(taskId, variableName, import_values.Values.stringifyValue(value));
+  }
+  /**
+   * set variables on a task. If the variable is not already existing, it will be created in the most outer scope. This means the process instance in case this task is related to an execution.
+   */
+  setVariables(taskId, variables) {
+    this.taskService.setVariables(taskId, import_values.Values.stringifyValuesMap(variables));
+  }
+  /**
+   * set variable on a task. If the variable is not already existing, it will be created in the task.
+   */
+  setVariableLocal(taskId, variableName, value) {
+    this.taskService.setVariableLocal(taskId, variableName, import_values.Values.stringifyValue(value));
+  }
+  /**
+   * set variables on a task. If the variable is not already existing, it will be created in the task.
+   */
+  setVariablesLocal(taskId, variables) {
+    this.taskService.setVariablesLocal(taskId, import_values.Values.stringifyValuesMap(variables));
+  }
+  /**
+   * get a variables and search in the task scope and if available also the execution scopes.
+   */
+  getVariable(taskId, variableName) {
+    return import_values.Values.parseValue(this.taskService.getVariable(taskId, variableName));
+  }
+  /**
+   * The variable. Searching for the variable is done in all scopes that are visible to the given task (including parent scopes). Returns null when no variable value is found with the given name.
+   *
+   * @param taskId
+   *            id of task, cannot be null.
+   * @param variableName
+   *            name of variable, cannot be null.
+   * @return the variable or null if the variable is undefined.
+   * @throws FlowableObjectNotFoundException
+   *             when no execution is found for the given taskId.
+   */
+  getVariableInstance(taskId, variableName) {
+    return this.taskService.getVariableInstance(taskId, variableName);
+  }
+  /**
+   * checks whether or not the task has a variable defined with the given name, in the task scope and if available also the execution scopes.
+   */
+  hasVariable(taskId, variableName) {
+    return this.taskService.hasVariable(taskId, variableName);
+  }
+  /**
+   * checks whether or not the task has a variable defined with the given name.
+   */
+  getVariableLocal(taskId, variableName) {
+    return import_values.Values.parseValue(this.taskService.getVariableLocal(taskId, variableName));
+  }
+  /**
+   * The variable for a task. Returns the variable when it is set for the task (and not searching parent scopes). Returns null when no variable is found with the given name.
+   *
+   * @param taskId
+   *            id of task, cannot be null.
+   * @param variableName
+   *            name of variable, cannot be null.
+   * @return the variable or null if the variable is undefined.
+   * @throws FlowableObjectNotFoundException
+   *             when no task is found for the given taskId.
+   */
+  getVariableInstanceLocal(taskId, variableName) {
+    return this.taskService.getVariableInstanceLocal(taskId, variableName);
+  }
+  /**
+   * checks whether or not the task has a variable defined with the given name, local task scope only.
+   */
+  hasVariableLocal(taskId, variableName) {
+    return this.taskService.hasVariableLocal(taskId, variableName);
+  }
+  /**
+   * get all variables and search in the task scope and if available also the execution scopes. If you have many variables and you only need a few, consider using
+   * {@link #getVariables(String, Collection)} for better performance.
+   */
+  getVariables(taskId, variableNames) {
+    if (this.isNotNull(variableNames)) {
+      return import_values.Values.parseValuesMap(this.taskService.getVariables(taskId, variableNames));
+    } else {
+      return import_values.Values.parseValuesMap(this.taskService.getVariables(taskId));
+    }
+  }
+  /**
+   * All variables visible from the given task scope (including parent scopes).
+   *
+   * @param taskId
+   *            id of task, cannot be null.
+   * @param variableNames
+   *            the collection of variable names that should be retrieved.
+   * @return the variable instances or an empty map if no such variables are found.
+   * @throws FlowableObjectNotFoundException
+   *             when no task is found for the given taskId.
+   */
+  getVariableInstances(taskId, variableNames) {
+    if (this.isNotNull(variableNames)) {
+      return this.taskService.getVariableInstances(taskId, variableNames);
+    } else {
+      return this.taskService.getVariableInstances(taskId);
+    }
+  }
+  /**
+   * get all variables and search only in the task scope. If you have many task local variables and you only need a few, consider using {@link #getVariablesLocal(String, Collection)} for better
+   * performance.
+   */
+  getVariablesLocal(taskId, variableNames) {
+    if (this.isNotNull(variableNames)) {
+      return import_values.Values.parseValuesMap(this.taskService.getVariablesLocal(taskId, variableNames));
+    } else {
+      return import_values.Values.parseValuesMap(this.taskService.getVariablesLocal(taskId));
+    }
+  }
+  /** get all variables and search only in the task scope. */
+  getVariableInstancesLocalByTaskIds(taskIds) {
+    return this.taskService.getVariableInstancesLocalByTaskIds(taskIds);
+  }
+  /**
+   * All variable values that are defined in the task scope, without taking outer scopes into account. If you have many task local variables and you only need a few, consider using
+   * {@link #getVariableInstancesLocal(String, Collection)} for better performance.
+   *
+   * @param taskId
+   *            id of task, cannot be null.
+   * @return the variables or an empty map if no such variables are found.
+   * @throws FlowableObjectNotFoundException
+   *             when no task is found for the given taskId.
+   */
+  getVariableInstancesLocal(taskId, variableNames) {
+    if (this.isNotNull(variableNames)) {
+      return this.taskService.getVariableInstancesLocal(taskId, variableNames);
+    } else {
+      return this.taskService.getVariableInstancesLocal(taskId);
+    }
+  }
+  /**
+   * Removes the variable from the task. When the variable does not exist, nothing happens.
+   */
+  removeVariable(taskId, variableName) {
+    this.taskService.removeVariable(taskId, variableName);
+  }
+  /**
+   * Removes the variable from the task (not considering parent scopes). When the variable does not exist, nothing happens.
+   */
+  removeVariableLocal(taskId, variableName) {
+    this.taskService.removeVariableLocal(taskId, variableName);
+  }
+  /**
+   * Removes all variables in the given collection from the task. Non existing variable names are simply ignored.
+   */
+  removeVariables(taskId, variableNames) {
+    this.taskService.removeVariables(taskId, variableNames);
+  }
+  /**
+   * Removes all variables in the given collection from the task (not considering parent scopes). Non existing variable names are simply ignored.
+   */
+  removeVariablesLocal(taskId, variableNames) {
+    this.taskService.removeVariablesLocal(taskId, variableNames);
+  }
+  /**
+   * All DataObjects visible from the given execution scope (including parent scopes).
+   *
+   * @param taskId
+   *            id of task, cannot be null.
+   * @param dataObjectNames
+   *            the collection of DataObject names that should be retrieved.
+   * @param locale
+   *            locale the DataObject name and description should be returned in (if available).
+   * @param withLocalizationFallback
+   *            When true localization will fallback to more general locales if the specified locale is not found.
+   * @return the DataObjects or an empty map if no such variables are found.
+   * @throws FlowableObjectNotFoundException
+   *             when no task is found for the given taskId.
+   */
+  getDataObjects(taskId, dataObjectNames, locale, withLocalizationFallback) {
+    if (this.isNotNull(dataObjectNames) && this.isNotNull(locale) && this.isNotNull(withLocalizationFallback)) {
+      return this.taskService.getDataObjects(taskId, dataObjectNames, locale, withLocalizationFallback);
+    } else if (this.isNotNull(dataObjectNames)) {
+      return this.taskService.getDataObjects(taskId, dataObjectNames);
+    } else if (this.isNotNull(locale) && this.isNotNull(withLocalizationFallback)) {
+      return this.taskService.getDataObjects(taskId, locale, withLocalizationFallback);
+    } else {
+      return this.taskService.getDataObjects(taskId);
+    }
+  }
+  /**
+   * The DataObject. Searching for the DataObject is done in all scopes that are visible to the given task (including parent scopes). Returns null when no DataObject value is found with the given
+   * name.
+   *
+   * @param taskId
+   *            id of task, cannot be null.
+   * @param dataObject
+   *            name of DataObject, cannot be null.
+   * @param locale
+   *            locale the DataObject name and description should be returned in (if available).
+   * @param withLocalizationFallback
+   *            When true localization will fallback to more general locales including the default locale of the JVM if the specified locale is not found.
+   * @return the DataObject or null if the variable is undefined.
+   * @throws FlowableObjectNotFoundException
+   *             when no task is found for the given taskId.
+   */
+  getDataObject(taskId, dataObject, locale, withLocalizationFallback) {
+    if (this.isNotNull(locale) && this.isNotNull(withLocalizationFallback)) {
+      return this.taskService.getDataObject(taskId, dataObject, locale, withLocalizationFallback);
+    } else {
+      return this.taskService.getDataObject(taskId, dataObject);
+    }
+  }
+  /** Add a comment to a task and/or process instance. */
+  addComment(taskId, processInstanceId, message, type) {
+    if (this.isNotNull(type)) {
+      return this.taskService.addComment(taskId, processInstanceId, type, message);
+    } else {
+      return this.taskService.addComment(taskId, processInstanceId, message);
+    }
+  }
+  /** Update a comment to a task and/or process instance. */
+  saveComment(comment) {
+    this.taskService.saveComment(comment);
+  }
+  /**
+   * Returns an individual comment with the given id. Returns null if no comment exists with the given id.
+   */
+  getComment(commentId) {
+    return this.taskService.getComment(commentId);
+  }
+  /** Removes all comments from the provided task and/or process instance */
+  deleteComments(taskId, processInstanceId) {
+    this.taskService.deleteComments(taskId, processInstanceId);
+  }
+  /**
+   * Removes an individual comment with the given id.
+   * 
+   * @throws FlowableObjectNotFoundException
+   *             when no comment exists with the given id.
+   */
+  deleteComment(commentId) {
+    this.taskService.deleteComment(commentId);
+  }
+  /** The comments related to the given task. */
+  getTaskComments(taskId, type) {
+    if (this.isNotNull(type)) {
+      return this.taskService.getTaskComments(taskId, type);
+    } else {
+      return this.taskService.getTaskComments(taskId);
+    }
+  }
+  /** All comments of a given type. */
+  getCommentsByType(type) {
+    return this.taskService.getCommentsByType(type);
+  }
+  /** The all events related to the given task. */
+  getTaskEvents(taskId) {
+    return this.taskService.getTaskEvents(taskId);
+  }
+  /**
+   * Returns an individual event with the given id. Returns null if no event exists with the given id.
+   */
+  getEvent(eventId) {
+    return this.taskService.getEvent(eventId);
+  }
+  /** The comments related to the given process instance. */
+  getProcessInstanceComments(processInstanceId, type) {
+    if (this.isNotNull(type)) {
+      return this.taskService.getProcessInstanceComments(processInstanceId, type);
+    } else {
+      return this.taskService.getProcessInstanceComments(processInstanceId);
+    }
+  }
+  /**
+   * Add a new attachment to a task and/or a process instance and use an input stream to provide the content
+   */
+  createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription, content, url) {
+    if (this.isNotNull(url)) {
+      return this.taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription, url);
+    } else {
+      return this.taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription, import_io.Streams.createByteArrayInputStream(content));
+    }
+  }
+  /** Update the name and description of an attachment */
+  saveAttachment(attachment) {
+    this.taskService.saveAttachment(attachment);
+  }
+  /** Retrieve a particular attachment */
+  getAttachment(attachmentId) {
+    return this.taskService.getAttachment(attachmentId);
+  }
+  /** Retrieve stream content of a particular attachment */
+  getAttachmentContent(attachmentId) {
+    const content = this.taskService.getAttachmentContent(attachmentId);
+    const baos = import_io.Streams.createByteArrayOutputStream();
+    import_io.Streams.copyLarge(content, baos);
+    return baos.getBytes();
+  }
+  /** The list of attachments associated to a task */
+  getTaskAttachments(taskId) {
+    return this.taskService.getTaskAttachments(taskId);
+  }
+  /** The list of attachments associated to a process instance */
+  getProcessInstanceAttachments(processInstanceId) {
+    return this.taskService.getProcessInstanceAttachments(processInstanceId);
+  }
+  /** Delete an attachment */
+  deleteAttachment(attachmentId) {
+    this.taskService.deleteAttachment(attachmentId);
+  }
+  /** The list of subtasks for this parent task */
+  getSubTasks(parentTaskId) {
+    return this.taskService.getSubTasks(parentTaskId);
+  }
+  isNotNull(property) {
+    return property !== null && property !== void 0;
+  }
+}
+class TaskData {
+  constructor(data) {
+    this.data = data;
+  }
+  getId() {
+    return this.data.id ?? void 0;
+  }
+  getRevision() {
+    return this.data.revision;
+  }
+  getOwner() {
+    return this.data.owner ?? void 0;
+  }
+  getAssigneeUpdatedCount() {
+    return this.data.assigneeUpdatedCount;
+  }
+  getOriginalAssignee() {
+    return this.data.originalAssignee ?? void 0;
+  }
+  getAssignee() {
+    return this.data.assignee ?? void 0;
+  }
+  getDelegationState() {
+    return this.data.delegationState ?? void 0;
+  }
+  getParentTaskId() {
+    return this.data.parentTaskId ?? void 0;
+  }
+  getName() {
+    return this.data.name ?? void 0;
+  }
+  getLocalizedName() {
+    return this.data.localizedName ?? void 0;
+  }
+  getDescription() {
+    return this.data.description ?? void 0;
+  }
+  getLocalizedDescription() {
+    return this.data.localizedDescription ?? void 0;
+  }
+  getPriority() {
+    return this.data.priority;
+  }
+  getCreateTime() {
+    return this.data.createTime ?? void 0;
+  }
+  getDueDate() {
+    return this.data.dueDate ?? void 0;
+  }
+  getSuspensionState() {
+    return this.data.suspensionState ?? void 0;
+  }
+  getCategory() {
+    return this.data.category ?? void 0;
+  }
+  isIdentityLinksInitialized() {
+    return this.data.isIdentityLinksInitialized;
+  }
+  getExecutionId() {
+    return this.data.executionId ?? void 0;
+  }
+  getProcessInstanceId() {
+    return this.data.processInstanceId ?? void 0;
+  }
+  getProcessDefinitionId() {
+    return this.data.processDefinitionId ?? void 0;
+  }
+  getScopeId() {
+    return this.data.scopeId ?? void 0;
+  }
+  getSubScopeId() {
+    return this.data.subScopeId ?? void 0;
+  }
+  getScopeType() {
+    return this.data.scopeType ?? void 0;
+  }
+  getScopeDefinitionId() {
+    return this.data.scopeDefinitionId ?? void 0;
+  }
+  getTaskDefinitionKey() {
+    return this.data.taskDefinitionKey ?? void 0;
+  }
+  getFormKey() {
+    return this.data.formKey ?? void 0;
+  }
+  isDeleted() {
+    return this.data.isDeleted;
+  }
+  isCanceled() {
+    return this.data.isCanceled;
+  }
+  isCountEnabled() {
+    return this.data.isCountEnabled;
+  }
+  getVariableCount() {
+    return this.data.variableCount;
+  }
+  getIdentityLinkCount() {
+    return this.data.identityLinkCount;
+  }
+  getClaimTime() {
+    return this.data.claimTime ?? void 0;
+  }
+  getTenantId() {
+    return this.data.tenantId;
+  }
+  getEventName() {
+    return this.data.eventName ?? void 0;
+  }
+  getEventHandlerId() {
+    return this.data.eventHandlerId ?? void 0;
+  }
+  isForcedUpdate() {
+    return this.data.forcedUpdate;
+  }
+}
+var DelegationState = /* @__PURE__ */ ((DelegationState2) => {
+  DelegationState2[DelegationState2["PENDING"] = 0] = "PENDING";
+  DelegationState2[DelegationState2["RESOLVED"] = 1] = "RESOLVED";
+  return DelegationState2;
+})(DelegationState || {});
+var NullHandlingOnOrder = /* @__PURE__ */ ((NullHandlingOnOrder2) => {
+  NullHandlingOnOrder2[NullHandlingOnOrder2["NULLS_FIRST"] = 0] = "NULLS_FIRST";
+  NullHandlingOnOrder2[NullHandlingOnOrder2["NULLS_LAST"] = 1] = "NULLS_LAST";
+  return NullHandlingOnOrder2;
+})(NullHandlingOnOrder || {});
+if (typeof module !== "undefined") {
+  module.exports = Tasks;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/bpm/tasks.ts"],
  "sourcesContent": ["/**\n * API Tasks\n */\n\nimport { Streams } from \"@aerokit/sdk/io\";\nimport { Values } from \"@aerokit/sdk/bpm/values\";\n\nconst BpmFacade = Java.type(\"org.eclipse.dirigible.components.api.bpm.BpmFacade\");\n\nexport class Tasks {\n\n\tpublic static list(): TaskData[] {\n\t\tconst tasks: any[] = JSON.parse(BpmFacade.getTasks());\n\t\treturn tasks.map(e => new TaskData(e));\n\t}\n\n\tpublic static getVariable(taskId: string, variableName: string): any {\n\t\treturn Values.parseValue(BpmFacade.getTaskVariable(taskId, variableName));\n\t}\n\n\t/**\n\t * Returns all variables. This will include all variables of parent scopes too.\n\t */\n\tpublic static getVariables(taskId: string): Map<string, any> {\n\t\treturn Values.parseValuesMap(BpmFacade.getTaskVariables(taskId));\n\t}\n\n\tpublic static setVariable(taskId: string, variableName: string, value: any): void {\n\t\tBpmFacade.setTaskVariable(taskId, variableName, Values.stringifyValue(value));\n\t}\n\n\tpublic static setVariables(taskId: string, variables: Map<string, any>): void {\n\t\tBpmFacade.setTaskVariables(taskId, Values.stringifyValuesMap(variables));\n\t}\n\n\tpublic static complete(taskId: string, variables: { [key: string]: any } = {}): void {\n\t\tBpmFacade.completeTask(taskId, JSON.stringify(variables));\n\t}\n\n\tpublic static getTaskService(): TaskService {\n\t\treturn new TaskService(BpmFacade.getBpmProviderFlowable().getTaskService());\n\t}\n}\n\n/**\n * Service which provides access to {@link Task} and form related operations.\n *\n */\nexport class TaskService {\n\n\tprivate readonly taskService: any;\n\n\tconstructor(taskService: any) {\n\t\tthis.taskService = taskService;\n\t}\n\t/**\n\t * Creates a new task that is not related to any process instance.\n\t * \n\t * The returned task is transient and must be saved with {@link #saveTask(Task)} 'manually'.\n\t */\n\tpublic newTask(taskId?: string): Task {\n\t\tif (this.isNotNull(taskId)) {\n\t\t\treturn this.taskService.newTask(taskId);\n\t\t}\n\t\treturn this.taskService.newTask();\n\t}\n\n\t/**\n\t * Create a builder for the task\n\t * \n\t * @return task builder\n\t */\n\tpublic createTaskBuilder(): TaskBuilder {\n\t\treturn this.taskService.createTaskBuilder();\n\t}\n\n\t/**\n\t * Saves the given task to the persistent data store. If the task is already present in the persistent store, it is updated. After a new task has been saved, the task instance passed into this\n\t * method is updated with the id of the newly created task.\n\t * \n\t * @param task\n\t *            the task, cannot be null.\n\t */\n\tpublic saveTask(task: Task): void {\n\t\tthis.taskService.saveTask(task);\n\t}\n\n\t/**\n\t * Saves the given tasks to the persistent data store. If the tasks are already present in the persistent store, it is updated. After a new task has been saved, the task instance passed into this\n\t * method is updated with the id of the newly created task.\n\t *\n\t * @param taskList the list of task instances, cannot be null.\n\t */\n\tpublic bulkSaveTasks(taskList: Task[]): void {\n\t\tthis.taskService.bulkSaveTasks(taskList);\n\t}\n\n\t/**\n\t * Deletes the given task, not deleting historic information that is related to this task.\n\t * \n\t * @param taskId\n\t *            The id of the task that will be deleted, cannot be null. If no task exists with the given taskId, the operation is ignored.\n\t * @param cascade\n\t *            If cascade is true, also the historic information related to this task is deleted.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task with given id does not exist.\n\t * @throws FlowableException\n\t *             when an error occurs while deleting the task or in case the task is part of a running process.\n\t */\n\tpublic deleteTask(taskId: string, cascade?: boolean): void {\n\t\tif (this.isNotNull(cascade)) {\n\t\t\tthis.taskService.deleteTask(taskId, cascade);\n\t\t} else {\n\t\t\tthis.taskService.deleteTask(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * Deletes all tasks of the given collection, not deleting historic information that is related to these tasks.\n\t * \n\t * @param taskIds\n\t *            The id's of the tasks that will be deleted, cannot be null. All id's in the list that don't have an existing task will be ignored.\n\t * @param cascade\n\t *            If cascade is true, also the historic information related to this task is deleted.\n\t * @throws FlowableObjectNotFoundException\n\t *             when one of the task does not exist.\n\t * @throws FlowableException\n\t *             when an error occurs while deleting the tasks or in case one of the tasks is part of a running process.\n\t */\n\tpublic deleteTasks(taskIds: string[], cascade?: boolean): void {\n\t\tif (this.isNotNull(cascade)) {\n\t\t\tthis.taskService.deleteTasks(taskIds, cascade);\n\t\t} else {\n\t\t\tthis.taskService.deleteTasks(taskIds);\n\t\t}\n\t}\n\n\t/**\n\t * Deletes the given task, not deleting historic information that is related to this task..\n\t * \n\t * @param taskId\n\t *            The id of the task that will be deleted, cannot be null. If no task exists with the given taskId, the operation is ignored.\n\t * @param deleteReason\n\t *            reason the task is deleted. Is recorded in history, if enabled.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task with given id does not exist.\n\t * @throws FlowableException\n\t *             when an error occurs while deleting the task or in case the task is part of a running process\n\t */\n\tpublic deleteTaskWithReason(taskId: string, deleteReason: string): void {\n\t\tthis.taskService.deleteTask(taskId, deleteReason)\n\t}\n\n\t/**\n\t * Deletes all tasks of the given collection, not deleting historic information that is related to these tasks.\n\t * \n\t * @param taskIds\n\t *            The id's of the tasks that will be deleted, cannot be null. All id's in the list that don't have an existing task will be ignored.\n\t * @param deleteReason\n\t *            reason the task is deleted. Is recorded in history, if enabled.\n\t * @throws FlowableObjectNotFoundException\n\t *             when one of the tasks does not exist.\n\t * @throws FlowableException\n\t *             when an error occurs while deleting the tasks or in case one of the tasks is part of a running process.\n\t */\n\tpublic deleteTasksWithReason(taskIds: string[], deleteReason: string): void {\n\t\tthis.taskService.deleteTasks(taskIds, deleteReason);\n\t}\n\n\t/**\n\t * Claim responsibility for a task: the given user is made assignee for the task. The difference with {@link #setAssignee(String, String)} is that here a check is done if the task already has a\n\t * user assigned to it. No check is done whether the user is known by the identity component.\n\t * \n\t * @param taskId\n\t *            task to claim, cannot be null.\n\t * @param userId\n\t *            user that claims the task. When userId is null the task is unclaimed, assigned to no one.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task doesn't exist.\n\t * @throws org.flowable.common.engine.api.FlowableTaskAlreadyClaimedException\n\t *             when the task is already claimed by another user\n\t */\n\tpublic claim(taskId: string, userId: string): void {\n\t\tthis.taskService.claim(taskId, userId);\n\t}\n\n\t/**\n\t * A shortcut to {@link #claim} with null user in order to unclaim the task\n\t * \n\t * @param taskId\n\t *            task to unclaim, cannot be null.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task doesn't exist.\n\t */\n\tpublic unclaim(taskId: string): void {\n\t\tthis.taskService.unclaim(taskId);\n\t}\n\n\t/**\n\t * Set the task state to in progress. No check is done whether the user is known by the identity component.\n\t * \n\t * @param taskId\n\t *            task to change the state, cannot be null.\n\t * @param userId\n\t *            user that puts the task in progress.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task doesn't exist.\n\t */\n\tpublic startProgress(taskId: string, userId: string): void {\n\t\tthis.taskService.startProgress(taskId, userId);\n\t}\n\n\t/**\n\t * Suspends the task. No check is done whether the user is known by the identity component.\n\t * \n\t * @param taskId\n\t *            task to suspend, cannot be null.\n\t * @param userId\n\t *            user that suspends the task.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task doesn't exist.\n\t */\n\tpublic suspendTask(taskId: string, userId: string): void {\n\t\tthis.taskService.suspendTask(taskId, userId);\n\t}\n\n\t/**\n\t * Activates the task. No check is done whether the user is known by the identity component.\n\t * \n\t * @param taskId\n\t *            task to activate, cannot be null.\n\t * @param userId\n\t *            user that activates the task.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task doesn't exist.\n\t */\n\tpublic activateTask(taskId: string, userId: string): void {\n\t\tthis.taskService.activateTask(taskId, userId);\n\t}\n\n\t/**\n\t * Delegates the task to another user. This means that the assignee is set and the delegation state is set to {@link DelegationState#PENDING}. If no owner is set on the task, the owner is set to\n\t * the current assignee of the task.\n\t * \n\t * @param taskId\n\t *            The id of the task that will be delegated.\n\t * @param userId\n\t *            The id of the user that will be set as assignee.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task exists with the given id.\n\t */\n\tpublic delegateTask(taskId: string, userId: string): void {\n\t\tthis.taskService.delegateTask(taskId, userId);\n\t}\n\n\t/**\n\t * Marks that the assignee is done with this task and that it can be send back to the owner. Can only be called when this task is {@link DelegationState#PENDING} delegation. After this method\n\t * returns, the {@link Task#getDelegationState() delegationState} is set to {@link DelegationState#RESOLVED}.\n\t * \n\t * @param taskId\n\t *            the id of the task to resolve, cannot be null.\n\t * @param variables\n\t * @param transientVariables\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task exists with the given id.\n\t */\n\tpublic resolveTask(taskId: string, variables?: Map<string, any>, transientVariables?: Map<string, any>): void {\n\t\tif (this.isNotNull(variables) && this.isNotNull(transientVariables)) {\n\t\t\tthis.taskService.resolveTask(taskId, variables, transientVariables);\n\t\t} else if (this.isNotNull(variables)) {\n\t\t\tthis.taskService.resolveTask(taskId, variables);\n\t\t} else {\n\t\t\tthis.taskService.resolveTask(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * Called when the task is successfully executed.\n\t * \n\t * @param taskId\n\t *            the id of the task to complete, cannot be null.\n\t * @param userId\n\t *            user that completes the task.\n\t * @param variables\n\t *            task parameters. May be null or empty.\n\t * @param transientVariables\n\t *            task parameters. May be null or empty.\n\t * @param localScope\n\t *            If true, the provided variables will be stored task-local, instead of process instance wide (which is the default behaviour).\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task exists with the given id.\n\t * @throws FlowableException\n\t *             when this task is {@link DelegationState#PENDING} delegation.\n\t */\n\tpublic complete(taskId: string, userId?: string, variables?: Map<string, any>, transientVariables?: Map<string, any>, localScope?: boolean): void {\n\t\tif (this.isNotNull(userId) && this.isNotNull(variables) && this.isNotNull(localScope)) {\n\t\t\tthis.taskService.complete(taskId, userId, variables, localScope);\n\t\t} else if (this.isNotNull(variables) && this.isNotNull(localScope)) {\n\t\t\tthis.taskService.complete(taskId, variables, localScope);\n\t\t} else if (this.isNotNull(userId) && this.isNotNull(variables) && this.isNotNull(transientVariables)) {\n\t\t\tthis.taskService.complete(taskId, userId, variables, transientVariables);\n\t\t} else if (this.isNotNull(variables) && this.isNotNull(transientVariables)) {\n\t\t\tthis.taskService.complete(taskId, variables, transientVariables);\n\t\t} else if (this.isNotNull(userId) && this.isNotNull(variables)) {\n\t\t\tthis.taskService.complete(taskId, userId, variables);\n\t\t} else if (this.isNotNull(variables)) {\n\t\t\tthis.taskService.complete(taskId, variables);\n\t\t} else if (this.isNotNull(userId)) {\n\t\t\tthis.taskService.complete(taskId, userId);\n\t\t} else {\n\t\t\tthis.taskService.complete(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * Called when the task is successfully executed, and the task form has been submitted.\n\t * \n\t * @param taskId\n\t *            the id of the task to complete, cannot be null.\n\t * @param formDefinitionId\n\t *            the id of the form definition that is filled-in to complete the task, cannot be null.\n\t * @param outcome\n\t *            the outcome of the completed form, can be null.\n\t * @param variables\n\t *            values of the completed form. May be null or empty.\n\t * @param userId\n\t *            user that completes the task.\n\t * @param transientVariables\n\t *            additional transient values that need to added to the process instance transient variables. May be null or empty.\n\t * @param localScope\n\t *            If true, the provided variables will be stored task-local, instead of process instance wide (which is the default for {@link #complete(String, Map)}).\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task exists with the given id.\n\t */\n\tpublic completeTaskWithForm(taskId: string, formDefinitionId: string, outcome: string, variables: Map<String, any>, userId?: string, transientVariables?: Map<String, any>, localScope?: boolean): void {\n\t\tif (this.isNotNull(userId) && this.isNotNull(localScope)) {\n\t\t\tthis.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, userId, variables, localScope);\n\t\t} else if (this.isNotNull(localScope)) {\n\t\t\tthis.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, variables, localScope);\n\t\t} else if (this.isNotNull(userId) && this.isNotNull(transientVariables)) {\n\t\t\tthis.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, userId, variables, transientVariables);\n\t\t} else if (this.isNotNull(transientVariables)) {\n\t\t\tthis.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, variables, transientVariables);\n\t\t} else if (this.isNotNull(userId)) {\n\t\t\tthis.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, userId, variables);\n\t\t} else {\n\t\t\tthis.taskService.completeTaskWithForm(taskId, formDefinitionId, outcome, variables);\n\t\t}\n\t}\n\t/**\n\t * Gets a Form model instance of the task form of a specific task\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param ignoreVariables\n\t *            should the variables be ignored when fetching the form model?\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or form definition doesn't exist.\n\t */\n\tpublic getTaskFormModel(taskId: string, ignoreVariables?: boolean): FormInfo {\n\t\tif (this.isNotNull(ignoreVariables)) {\n\t\t\treturn this.taskService.getTaskFormModel(taskId, ignoreVariables);\n\t\t} else {\n\t\t\treturn this.taskService.getTaskFormModel(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * Changes the assignee of the given task to the given userId. No check is done whether the user is known by the identity component.\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param userId\n\t *            id of the user to use as assignee.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or user doesn't exist.\n\t */\n\tpublic setAssignee(taskId: string, userId: string): void {\n\t\tthis.taskService.setAssignee(taskId, userId);\n\t}\n\n\t/**\n\t * Transfers ownership of this task to another user. No check is done whether the user is known by the identity component.\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param userId\n\t *            of the person that is receiving ownership.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or user doesn't exist.\n\t */\n\tpublic setOwner(taskId: string, userId: string): void {\n\t\tthis.taskService.setOwner(taskId, userId);\n\t}\n\n\t/**\n\t * Retrieves the {@link IdentityLink}s associated with the given task. Such an {@link IdentityLink} informs how a certain identity (eg. group or user) is associated with a certain task (eg. as\n\t * candidate, assignee, etc.)\n\t */\n\tpublic getIdentityLinksForTask(taskId: string): IdentityLink[] {\n\t\treturn this.taskService.getIdentityLinksForTask(taskId);\n\t}\n\n\t/**\n\t * Convenience shorthand for {@link #addUserIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param userId\n\t *            id of the user to use as candidate, cannot be null.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or user doesn't exist.\n\t */\n\tpublic addCandidateUser(taskId: string, userId: string): void {\n\t\tthis.taskService.addCandidateUser(taskId, userId);\n\t}\n\n\t/**\n\t * Convenience shorthand for {@link #addGroupIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param groupId\n\t *            id of the group to use as candidate, cannot be null.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or group doesn't exist.\n\t */\n\tpublic addCandidateGroup(taskId: string, groupId: string): void {\n\t\tthis.taskService.addCandidateGroup(taskId, groupId);\n\t}\n\n\t/**\n\t * Involves a user with a task. The type of identity link is defined by the given identityLinkType.\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param userId\n\t *            id of the user involve, cannot be null.\n\t * @param identityLinkType\n\t *            type of identityLink, cannot be null (@see {@link IdentityLinkType}).\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or user doesn't exist.\n\t */\n\tpublic addUserIdentityLink(taskId: string, userId: string, identityLinkType: string): void {\n\t\tthis.taskService.addUserIdentityLink(taskId, userId, identityLinkType);\n\t}\n\n\t/**\n\t * Involves a group with a task. The type of identityLink is defined by the given identityLink.\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param groupId\n\t *            id of the group to involve, cannot be null.\n\t * @param identityLinkType\n\t *            type of identity, cannot be null (@see {@link IdentityLinkType}).\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or group doesn't exist.\n\t */\n\tpublic addGroupIdentityLink(taskId: string, groupId: string, identityLinkType: string): void {\n\t\tthis.taskService.addGroupIdentityLink(taskId, groupId, identityLinkType);\n\t}\n\n\t/**\n\t * Convenience shorthand for {@link #deleteUserIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param userId\n\t *            id of the user to use as candidate, cannot be null.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or user doesn't exist.\n\t */\n\tpublic deleteCandidateUser(taskId: string, userId: string): void {\n\t\tthis.taskService.deleteCandidateUser(taskId, userId);\n\t}\n\n\t/**\n\t * Convenience shorthand for {@link #deleteGroupIdentityLink(String, String, String)}; with type {@link IdentityLinkType#CANDIDATE}\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param groupId\n\t *            id of the group to use as candidate, cannot be null.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or group doesn't exist.\n\t */\n\tpublic deleteCandidateGroup(taskId: string, groupId: string): void {\n\t\tthis.taskService.deleteCandidateGroup(taskId, groupId);\n\t}\n\n\t/**\n\t * Removes the association between a user and a task for the given identityLinkType.\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param userId\n\t *            id of the user involve, cannot be null.\n\t * @param identityLinkType\n\t *            type of identityLink, cannot be null (@see {@link IdentityLinkType}).\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or user doesn't exist.\n\t */\n\tpublic deleteUserIdentityLink(taskId: string, userId: string, identityLinkType: string): void {\n\t\tthis.taskService.deleteUserIdentityLink(taskId, userId, identityLinkType);\n\t}\n\n\t/**\n\t * Removes the association between a group and a task for the given identityLinkType.\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param groupId\n\t *            id of the group to involve, cannot be null.\n\t * @param identityLinkType\n\t *            type of identity, cannot be null (@see {@link IdentityLinkType}).\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task or group doesn't exist.\n\t */\n\tpublic deleteGroupIdentityLink(taskId: string, groupId: string, identityLinkType: string): void {\n\t\tthis.taskService.deleteGroupIdentityLink(taskId, groupId, identityLinkType);\n\t}\n\n\t/**\n\t * Changes the priority of the task.\n\t * \n\t * Authorization: actual owner / business admin\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param priority\n\t *            the new priority for the task.\n\t * @throws FlowableObjectNotFoundException\n\t *             when the task doesn't exist.\n\t */\n\tpublic setPriority(taskId: string, priority: number): void {\n\t\tthis.taskService.setPriority(taskId, priority);\n\t}\n\n\t/**\n\t * Changes the due date of the task\n\t * \n\t * @param taskId\n\t *            id of the task, cannot be null.\n\t * @param dueDate\n\t *            the new due date for the task\n\t * @throws FlowableException\n\t *             when the task doesn't exist.\n\t */\n\tpublic setDueDate(taskId: string, dueDate: Date): void {\n\t\tthis.taskService.setDueDate(taskId, dueDate);\n\t}\n\n\t/**\n\t * set variable on a task. If the variable is not already existing, it will be created in the most outer scope. This means the process instance in case this task is related to an execution.\n\t */\n\tpublic setVariable(taskId: string, variableName: string, value: any): void {\n\t\tthis.taskService.setVariable(taskId, variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * set variables on a task. If the variable is not already existing, it will be created in the most outer scope. This means the process instance in case this task is related to an execution.\n\t */\n\tpublic setVariables(taskId: string, variables: Map<string, any>): void {\n\t\tthis.taskService.setVariables(taskId, Values.stringifyValuesMap(variables));\n\t}\n\n\t/**\n\t * set variable on a task. If the variable is not already existing, it will be created in the task.\n\t */\n\tpublic setVariableLocal(taskId: string, variableName: string, value: any): void {\n\t\tthis.taskService.setVariableLocal(taskId, variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * set variables on a task. If the variable is not already existing, it will be created in the task.\n\t */\n\tpublic setVariablesLocal(taskId: string, variables: Map<string, any>): void {\n\t\tthis.taskService.setVariablesLocal(taskId, Values.stringifyValuesMap(variables));\n\t}\n\n\t/**\n\t * get a variables and search in the task scope and if available also the execution scopes.\n\t */\n\tpublic getVariable(taskId: string, variableName: string): any {\n\t\treturn Values.parseValue(this.taskService.getVariable(taskId, variableName));\n\t}\n\n\t/**\n\t * The variable. Searching for the variable is done in all scopes that are visible to the given task (including parent scopes). Returns null when no variable value is found with the given name.\n\t *\n\t * @param taskId\n\t *            id of task, cannot be null.\n\t * @param variableName\n\t *            name of variable, cannot be null.\n\t * @return the variable or null if the variable is undefined.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no execution is found for the given taskId.\n\t */\n\tpublic getVariableInstance(taskId: string, variableName: string): VariableInstance {\n\t\treturn this.taskService.getVariableInstance(taskId, variableName);\n\t}\n\n\t/**\n\t * checks whether or not the task has a variable defined with the given name, in the task scope and if available also the execution scopes.\n\t */\n\tpublic hasVariable(taskId: string, variableName: string): boolean {\n\t\treturn this.taskService.hasVariable(taskId, variableName);\n\t}\n\n\t/**\n\t * checks whether or not the task has a variable defined with the given name.\n\t */\n\tpublic getVariableLocal(taskId: string, variableName: string): any {\n\t\treturn Values.parseValue(this.taskService.getVariableLocal(taskId, variableName));\n\t}\n\n\t/**\n\t * The variable for a task. Returns the variable when it is set for the task (and not searching parent scopes). Returns null when no variable is found with the given name.\n\t *\n\t * @param taskId\n\t *            id of task, cannot be null.\n\t * @param variableName\n\t *            name of variable, cannot be null.\n\t * @return the variable or null if the variable is undefined.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task is found for the given taskId.\n\t */\n\tpublic getVariableInstanceLocal(taskId: string, variableName: string): VariableInstance {\n\t\treturn this.taskService.getVariableInstanceLocal(taskId, variableName);\n\t}\n\n\t/**\n\t * checks whether or not the task has a variable defined with the given name, local task scope only.\n\t */\n\tpublic hasVariableLocal(taskId: string, variableName: string): boolean {\n\t\treturn this.taskService.hasVariableLocal(taskId, variableName);\n\t}\n\n\t/**\n\t * get all variables and search in the task scope and if available also the execution scopes. If you have many variables and you only need a few, consider using\n\t * {@link #getVariables(String, Collection)} for better performance.\n\t */\n\tpublic getVariables(taskId: string, variableNames?: string[]): Map<string, any> {\n\t\tif (this.isNotNull(variableNames)) {\n\t\t\treturn Values.parseValuesMap(this.taskService.getVariables(taskId, variableNames));\n\t\t} else {\n\t\t\treturn Values.parseValuesMap(this.taskService.getVariables(taskId));\n\t\t}\n\t}\n\n\t/**\n\t * All variables visible from the given task scope (including parent scopes).\n\t *\n\t * @param taskId\n\t *            id of task, cannot be null.\n\t * @param variableNames\n\t *            the collection of variable names that should be retrieved.\n\t * @return the variable instances or an empty map if no such variables are found.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task is found for the given taskId.\n\t */\n\tpublic getVariableInstances(taskId: string, variableNames?: string[]): Map<string, VariableInstance> {\n\t\tif (this.isNotNull(variableNames)) {\n\t\t\treturn this.taskService.getVariableInstances(taskId, variableNames);\n\t\t} else {\n\t\t\treturn this.taskService.getVariableInstances(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * get all variables and search only in the task scope. If you have many task local variables and you only need a few, consider using {@link #getVariablesLocal(String, Collection)} for better\n\t * performance.\n\t */\n\tpublic getVariablesLocal(taskId: string, variableNames?: string[]): Map<string, any> {\n\t\tif (this.isNotNull(variableNames)) {\n\t\t\treturn Values.parseValuesMap(this.taskService.getVariablesLocal(taskId, variableNames));\n\t\t} else {\n\t\t\treturn Values.parseValuesMap(this.taskService.getVariablesLocal(taskId));\n\t\t}\n\t}\n\n\t/** get all variables and search only in the task scope. */\n\tpublic getVariableInstancesLocalByTaskIds(taskIds: Set<string>): VariableInstance[] {\n\t\treturn this.taskService.getVariableInstancesLocalByTaskIds(taskIds);\n\t}\n\n\t/**\n\t * All variable values that are defined in the task scope, without taking outer scopes into account. If you have many task local variables and you only need a few, consider using\n\t * {@link #getVariableInstancesLocal(String, Collection)} for better performance.\n\t *\n\t * @param taskId\n\t *            id of task, cannot be null.\n\t * @return the variables or an empty map if no such variables are found.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task is found for the given taskId.\n\t */\n\tpublic getVariableInstancesLocal(taskId: string, variableNames?: string[]): Map<string, VariableInstance> {\n\t\tif (this.isNotNull(variableNames)) {\n\t\t\treturn this.taskService.getVariableInstancesLocal(taskId, variableNames);\n\t\t} else {\n\t\t\treturn this.taskService.getVariableInstancesLocal(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * Removes the variable from the task. When the variable does not exist, nothing happens.\n\t */\n\tpublic removeVariable(taskId: string, variableName: string): void {\n\t\tthis.taskService.removeVariable(taskId, variableName);\n\t}\n\n\t/**\n\t * Removes the variable from the task (not considering parent scopes). When the variable does not exist, nothing happens.\n\t */\n\tpublic removeVariableLocal(taskId: string, variableName: string): void {\n\t\tthis.taskService.removeVariableLocal(taskId, variableName);\n\t}\n\n\t/**\n\t * Removes all variables in the given collection from the task. Non existing variable names are simply ignored.\n\t */\n\tpublic removeVariables(taskId: string, variableNames: string[]): void {\n\t\tthis.taskService.removeVariables(taskId, variableNames);\n\t}\n\n\t/**\n\t * Removes all variables in the given collection from the task (not considering parent scopes). Non existing variable names are simply ignored.\n\t */\n\tpublic removeVariablesLocal(taskId: string, variableNames: string[]): void {\n\t\tthis.taskService.removeVariablesLocal(taskId, variableNames);\n\t}\n\n\t/**\n\t * All DataObjects visible from the given execution scope (including parent scopes).\n\t *\n\t * @param taskId\n\t *            id of task, cannot be null.\n\t * @param dataObjectNames\n\t *            the collection of DataObject names that should be retrieved.\n\t * @param locale\n\t *            locale the DataObject name and description should be returned in (if available).\n\t * @param withLocalizationFallback\n\t *            When true localization will fallback to more general locales if the specified locale is not found.\n\t * @return the DataObjects or an empty map if no such variables are found.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task is found for the given taskId.\n\t */\n\tpublic getDataObjects(taskId: string, dataObjectNames?: string[], locale?: string, withLocalizationFallback?: boolean): Map<string, DataObject> {\n\t\tif (this.isNotNull(dataObjectNames) && this.isNotNull(locale) && this.isNotNull(withLocalizationFallback)) {\n\t\t\treturn this.taskService.getDataObjects(taskId, dataObjectNames, locale, withLocalizationFallback);\n\t\t} else if (this.isNotNull(dataObjectNames)) {\n\t\t\treturn this.taskService.getDataObjects(taskId, dataObjectNames);\n\t\t} else if (this.isNotNull(locale) && this.isNotNull(withLocalizationFallback)) {\n\t\t\treturn this.taskService.getDataObjects(taskId, locale, withLocalizationFallback);\n\t\t} else {\n\t\t\treturn this.taskService.getDataObjects(taskId);\n\t\t}\n\t}\n\n\t/**\n\t * The DataObject. Searching for the DataObject is done in all scopes that are visible to the given task (including parent scopes). Returns null when no DataObject value is found with the given\n\t * name.\n\t *\n\t * @param taskId\n\t *            id of task, cannot be null.\n\t * @param dataObject\n\t *            name of DataObject, cannot be null.\n\t * @param locale\n\t *            locale the DataObject name and description should be returned in (if available).\n\t * @param withLocalizationFallback\n\t *            When true localization will fallback to more general locales including the default locale of the JVM if the specified locale is not found.\n\t * @return the DataObject or null if the variable is undefined.\n\t * @throws FlowableObjectNotFoundException\n\t *             when no task is found for the given taskId.\n\t */\n\tpublic getDataObject(taskId: string, dataObject: string, locale?: string, withLocalizationFallback?: boolean): DataObject {\n\t\tif (this.isNotNull(locale) && this.isNotNull(withLocalizationFallback)) {\n\t\t\treturn this.taskService.getDataObject(taskId, dataObject, locale, withLocalizationFallback);\n\t\t} else {\n\t\t\treturn this.taskService.getDataObject(taskId, dataObject);\n\t\t}\n\t}\n\n\t/** Add a comment to a task and/or process instance. */\n\tpublic addComment(taskId: string, processInstanceId: string, message: string, type?: string): Comment {\n\t\tif (this.isNotNull(type)) {\n\t\t\treturn this.taskService.addComment(taskId, processInstanceId, type, message);\n\t\t} else {\n\t\t\treturn this.taskService.addComment(taskId, processInstanceId, message);\n\t\t}\n\t}\n\n\t/** Update a comment to a task and/or process instance. */\n\tpublic saveComment(comment: Comment): void {\n\t\tthis.taskService.saveComment(comment);\n\t}\n\n\t/**\n\t * Returns an individual comment with the given id. Returns null if no comment exists with the given id.\n\t */\n\tpublic getComment(commentId: string): Comment {\n\t\treturn this.taskService.getComment(commentId);\n\t}\n\n\t/** Removes all comments from the provided task and/or process instance */\n\tpublic deleteComments(taskId: string, processInstanceId: string): void {\n\t\tthis.taskService.deleteComments(taskId, processInstanceId);\n\t}\n\n\t/**\n\t * Removes an individual comment with the given id.\n\t * \n\t * @throws FlowableObjectNotFoundException\n\t *             when no comment exists with the given id.\n\t */\n\tpublic deleteComment(commentId: string): void {\n\t\tthis.taskService.deleteComment(commentId);\n\t}\n\n\t/** The comments related to the given task. */\n\tpublic getTaskComments(taskId: string, type?: string): Comment[] {\n\t\tif (this.isNotNull(type)) {\n\t\t\treturn this.taskService.getTaskComments(taskId, type);\n\t\t} else {\n\t\t\treturn this.taskService.getTaskComments(taskId);\n\t\t}\n\t}\n\n\t/** All comments of a given type. */\n\tpublic getCommentsByType(type: string): Comment[] {\n\t\treturn this.taskService.getCommentsByType(type);\n\t}\n\n\t/** The all events related to the given task. */\n\tpublic getTaskEvents(taskId: string): TaskEvent[] {\n\t\treturn this.taskService.getTaskEvents(taskId);\n\t}\n\n\t/**\n\t * Returns an individual event with the given id. Returns null if no event exists with the given id.\n\t */\n\tpublic getEvent(eventId: string): TaskEvent {\n\t\treturn this.taskService.getEvent(eventId);\n\t}\n\n\t/** The comments related to the given process instance. */\n\tpublic getProcessInstanceComments(processInstanceId: string, type?: string): Comment[] {\n\t\tif (this.isNotNull(type)) {\n\t\t\treturn this.taskService.getProcessInstanceComments(processInstanceId, type);\n\t\t} else {\n\t\t\treturn this.taskService.getProcessInstanceComments(processInstanceId);\n\t\t}\n\t}\n\n\t/**\n\t * Add a new attachment to a task and/or a process instance and use an input stream to provide the content\n\t */\n\tpublic createAttachment(attachmentType: string, taskId: string, processInstanceId: string, attachmentName: string, attachmentDescription: string, content?: any[], url?: string): Attachment {\n\t\tif (this.isNotNull(url)) {\n\t\t\treturn this.taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription, url);\n\t\t} else {\n\t\t\treturn this.taskService.createAttachment(attachmentType, taskId, processInstanceId, attachmentName, attachmentDescription, Streams.createByteArrayInputStream(content));\n\t\t}\n\t}\n\n\t/** Update the name and description of an attachment */\n\tpublic saveAttachment(attachment: Attachment): void {\n\t\tthis.taskService.saveAttachment(attachment);\n\t}\n\n\t/** Retrieve a particular attachment */\n\tpublic getAttachment(attachmentId: string): Attachment {\n\t\treturn this.taskService.getAttachment(attachmentId);\n\t}\n\n\t/** Retrieve stream content of a particular attachment */\n\tpublic getAttachmentContent(attachmentId: string): any[] {\n\t\tconst content = this.taskService.getAttachmentContent(attachmentId);\n\t\tconst baos = Streams.createByteArrayOutputStream();\n\t\tStreams.copyLarge(content, baos);\n\t\treturn baos.getBytes()\n\t};\n\n\t/** The list of attachments associated to a task */\n\tpublic getTaskAttachments(taskId: string): Attachment[] {\n\t\treturn this.taskService.getTaskAttachments(taskId);\n\t}\n\n\t/** The list of attachments associated to a process instance */\n\tpublic getProcessInstanceAttachments(processInstanceId: string): Attachment[] {\n\t\treturn this.taskService.getProcessInstanceAttachments(processInstanceId);\n\t}\n\n\t/** Delete an attachment */\n\tpublic deleteAttachment(attachmentId: string): void {\n\t\tthis.taskService.deleteAttachment(attachmentId);\n\t}\n\n\t/** The list of subtasks for this parent task */\n\tpublic getSubTasks(parentTaskId: string): Task[] {\n\t\treturn this.taskService.getSubTasks(parentTaskId);\n\t}\n\n\tprivate isNotNull(property: any): boolean {\n\t\treturn property !== null && property !== undefined;\n\t}\n}\n\nclass TaskData {\n\n\tprivate data: any;\n\n\tconstructor(data: any) {\n\t\tthis.data = data;\n\t}\n\n\tpublic getId(): string | undefined {\n\t\treturn this.data.id ?? undefined;\n\t}\n\n\tpublic getRevision(): number {\n\t\treturn this.data.revision;\n\t}\n\n\tpublic getOwner(): string | undefined {\n\t\treturn this.data.owner ?? undefined;\n\t}\n\n\tpublic getAssigneeUpdatedCount(): number {\n\t\treturn this.data.assigneeUpdatedCount;\n\t}\n\n\tpublic getOriginalAssignee(): string | undefined {\n\t\treturn this.data.originalAssignee ?? undefined;\n\t}\n\n\tpublic getAssignee(): string | undefined {\n\t\treturn this.data.assignee ?? undefined;\n\t}\n\n\tpublic getDelegationState(): string | undefined {\n\t\treturn this.data.delegationState ?? undefined;\n\t}\n\n\tpublic getParentTaskId(): string | undefined {\n\t\treturn this.data.parentTaskId ?? undefined;\n\t}\n\n\tpublic getName(): string | undefined {\n\t\treturn this.data.name ?? undefined;\n\t}\n\n\tpublic getLocalizedName(): string | undefined {\n\t\treturn this.data.localizedName ?? undefined;\n\t}\n\n\tpublic getDescription(): string | undefined {\n\t\treturn this.data.description ?? undefined;\n\t}\n\n\tpublic getLocalizedDescription(): string | undefined {\n\t\treturn this.data.localizedDescription ?? undefined;\n\t}\n\n\tpublic getPriority(): number {\n\t\treturn this.data.priority;\n\t}\n\n\tpublic getCreateTime(): Date | undefined {\n\t\treturn this.data.createTime ?? undefined;\n\t}\n\n\tpublic getDueDate(): Date | undefined {\n\t\treturn this.data.dueDate ?? undefined;\n\t}\n\n\tpublic getSuspensionState(): number {\n\t\treturn this.data.suspensionState ?? undefined;\n\t}\n\n\tpublic getCategory(): string | undefined {\n\t\treturn this.data.category ?? undefined;\n\t}\n\n\tpublic isIdentityLinksInitialized(): boolean {\n\t\treturn this.data.isIdentityLinksInitialized;\n\t}\n\n\tpublic getExecutionId(): string | undefined {\n\t\treturn this.data.executionId ?? undefined;\n\t}\n\n\tpublic getProcessInstanceId(): string | undefined {\n\t\treturn this.data.processInstanceId ?? undefined;\n\t}\n\n\tpublic getProcessDefinitionId(): string | undefined {\n\t\treturn this.data.processDefinitionId ?? undefined;\n\t}\n\n\tpublic getScopeId(): string | undefined {\n\t\treturn this.data.scopeId ?? undefined;\n\t}\n\n\tpublic getSubScopeId(): string | undefined {\n\t\treturn this.data.subScopeId ?? undefined;\n\t}\n\n\tpublic getScopeType(): string | undefined {\n\t\treturn this.data.scopeType ?? undefined;\n\t}\n\n\tpublic getScopeDefinitionId(): string | undefined {\n\t\treturn this.data.scopeDefinitionId ?? undefined;\n\t}\n\n\tpublic getTaskDefinitionKey(): string | undefined {\n\t\treturn this.data.taskDefinitionKey ?? undefined;\n\t}\n\n\tpublic getFormKey(): string | undefined {\n\t\treturn this.data.formKey ?? undefined;\n\t}\n\n\tpublic isDeleted(): boolean {\n\t\treturn this.data.isDeleted;\n\t}\n\n\tpublic isCanceled(): boolean {\n\t\treturn this.data.isCanceled;\n\t}\n\n\tpublic isCountEnabled(): boolean {\n\t\treturn this.data.isCountEnabled;\n\t}\n\n\tpublic getVariableCount(): number {\n\t\treturn this.data.variableCount;\n\t}\n\n\tpublic getIdentityLinkCount(): number {\n\t\treturn this.data.identityLinkCount;\n\t}\n\n\tpublic getClaimTime(): Date | undefined {\n\t\treturn this.data.claimTime ?? undefined;\n\t}\n\n\tpublic getTenantId(): string {\n\t\treturn this.data.tenantId;\n\t}\n\n\tpublic getEventName(): string | undefined {\n\t\treturn this.data.eventName ?? undefined;\n\t}\n\n\tpublic getEventHandlerId(): string | undefined {\n\t\treturn this.data.eventHandlerId ?? undefined;\n\t}\n\n\tpublic isForcedUpdate(): boolean {\n\t\treturn this.data.forcedUpdate;\n\t}\n}\n\n/**\n * Represents one task for a human user.\n */\nexport interface Task extends TaskInfo {\n\n\t/** Name or title of the task. */\n\tsetName(name: string): void;\n\n\t/** Sets an optional localized name for the task. */\n\tsetLocalizedName(name: string): void;\n\n\t/** Change the description of the task */\n\tsetDescription(description: string): void;\n\n\t/** Sets an optional localized description for the task. */\n\tsetLocalizedDescription(description: string): void;\n\n\t/** Sets the indication of how important/urgent this task is */\n\tsetPriority(priority: number): void;\n\n\t/**\n\t * The user id of the person that is responsible for this task.\n\t */\n\tsetOwner(owner: string): void;\n\n\t/**\n\t * The user id of the person to which this task is delegated.\n\t */\n\tsetAssignee(assignee: string): void;\n\n\t/** The current {@link DelegationState} for this task. */\n\tgetDelegationState(): DelegationState;\n\n\t/** The current {@link DelegationState} for this task. */\n\tsetDelegationState(delegationState: DelegationState): void;\n\n\t/** Change due date of the task. */\n\tsetDueDate(dueDate: Date): void;\n\n\t/**\n\t * Change the category of the task. This is an optional field and allows to 'tag' tasks as belonging to a certain category.\n\t */\n\tsetCategory(category: string): void;\n\n\t/** the parent task for which this task is a subtask */\n\tsetParentTaskId(parentTaskId: string): void;\n\n\t/** Change the tenantId of the task */\n\tsetTenantId(tenantId: string): void;\n\n\t/** Change the form key of the task */\n\tsetFormKey(formKey: string): void;\n\n\t/** Indicates whether this task is suspended or not. */\n\tisSuspended(): boolean;\n\n}\n\nexport interface TaskInfo {\n\n\t/** DB id of the task. */\n\tgetId(): string;\n\n\t/**\n\t * Name or title of the task.\n\t */\n\tgetName(): string;\n\n\t/**\n\t * Free text description of the task.\n\t */\n\tgetDescription(): string;\n\n\t/**\n\t * Indication of how important/urgent this task is\n\t */\n\tgetPriority(): number;\n\n\t/**\n\t * The user id of the person that is responsible for this task.\n\t */\n\tgetOwner(): string;\n\n\t/**\n\t * The user id of the person to which this task is delegated.\n\t */\n\tgetAssignee(): string;\n\n\t/**\n\t * Reference to the process instance or null if it is not related to a process instance.\n\t */\n\tgetProcessInstanceId(): string;\n\n\t/**\n\t * Reference to the path of execution or null if it is not related to a process instance.\n\t */\n\tgetExecutionId(): string;\n\n\t/**\n\t * Reference to the task definition or null if it is not related to any task definition.\n\t */\n\tgetTaskDefinitionId(): string;\n\n\t/**\n\t * Reference to the process definition or null if it is not related to a process.\n\t */\n\tgetProcessDefinitionId(): string;\n\n\t/**\n\t * Reference to a scope identifier or null if none is set (e.g. for bpmn process task it is null)\n\t */\n\tgetScopeId(): string;\n\n\t/**\n\t * Reference to a sub scope identifier or null if none is set (e.g. for bpmn process task it is null)\n\t */\n\tgetSubScopeId(): string;\n\n\t/**\n\t * Reference to a scope type or null if none is set (e.g. for bpmn process task it is null)\n\t */\n\tgetScopeType(): string;\n\n\t/**\n\t * Reference to a scope definition identifier or null if none is set (e.g. for bpmn process task it is null)\n\t */\n\tgetScopeDefinitionId(): string;\n\n\t/**\n\t * If this task runs in the context of a case and stage, this method returns it's closest parent stage instance id (the stage plan item instance id to be\n\t * precise). Even if the direct parent of the task is a process which itself might have been created out of a process task of a case, its stage instance\n\t * is reflected in the task.\n\t *\n\t * @return the stage instance id this task belongs to or null, if this task is not part of a case at all or is not a child element of a stage\n\t */\n\tgetPropagatedStageInstanceId(): string;\n\n\t/**\n\t * The state of this task\n\t */\n\tgetState(): string;\n\n\t/** The date/time when this task was created */\n\tgetCreateTime(): Date;\n\n\t/** The date/time when this task was put in progress */\n\tgetInProgressStartTime(): Date;\n\n\t/**\n\t * The user reference that put this task in progress\n\t */\n\tgetInProgressStartedBy(): string;\n\n\t/**\n\t * The claim time of this task\n\t */\n\tgetClaimTime(): Date;\n\n\t/**\n\t * The user reference that claimed this task\n\t */\n\tgetClaimedBy(): String;\n\n\t/**\n\t * The suspended time of this task\n\t */\n\tgetSuspendedTime(): Date;\n\n\t/**\n\t * The user reference that suspended this task\n\t */\n\tgetSuspendedBy(): string;\n\n\t/**\n\t * The id of the activity in the process defining this task or null if this is not related to a process\n\t */\n\tgetTaskDefinitionKey(): string;\n\n\t/**\n\t * In progress start due date of the task.\n\t */\n\tgetInProgressStartDueDate(): Date;\n\n\t/**\n\t * Due date of the task.\n\t */\n\tgetDueDate(): Date;\n\n\t/**\n\t * The category of the task. This is an optional field and allows to 'tag' tasks as belonging to a certain category.\n\t */\n\tgetCategory(); string;\n\n\t/**\n\t * The parent task for which this task is a subtask\n\t */\n\tgetParentTaskId(): string;\n\n\t/**\n\t * The tenant identifier of this task\n\t */\n\tgetTenantId(): string;\n\n\t/**\n\t * The form key for the user task\n\t */\n\tgetFormKey(): string;\n\n\t/**\n\t * Returns the local task variables if requested in the task query\n\t */\n\tgetTaskLocalVariables(): Map<string, Object>;\n\n\t/**\n\t * Returns the process variables if requested in the task query\n\t */\n\tgetProcessVariables(): Map<string, Object>;\n\n\t/**\n\t * Returns the case variables if requested in the task query\n\t */\n\tgetCaseVariables(): Map<string, Object>;\n\n\t/**\n\t * Returns the identity links.\n\t */\n\tgetIdentityLinks(): IdentityLinkInfo[];\n}\n\nexport interface IdentityLinkInfo {\n\tgetType(): string;\n\n\tgetUserId(): string;\n\n\tgetGroupId(): string;\n\n\tgetTaskId(): string;\n\n\tgetProcessInstanceId(): string;\n\n\tgetScopeId(): string;\n\n\tgetSubScopeId(): string;\n\n\tgetScopeType(): string;\n\n\tgetScopeDefinitionId(): string;\n}\n\nexport interface IdentityLink extends IdentityLinkInfo {\n\n\t/**\n\t * The process definition id associated with this identity link.\n\t */\n\tgetProcessDefinitionId(): string;\n\n}\n\nexport enum DelegationState {\n\n\t/**\n\t * The owner delegated the task and wants to review the result after the assignee has resolved the task. When the assignee completes the task, the task is marked as {@link #RESOLVED} and sent back\n\t * to the owner. When that happens, the owner is set as the assignee so that the owner gets this task back in the ToDo.\n\t */\n\tPENDING,\n\n\t/**\n\t * The assignee has resolved the task, the assignee was set to the owner again and the owner now finds this task back in the ToDo list for review. The owner now is able to complete the task.\n\t */\n\tRESOLVED\n}\n\n/**\n * Wraps {@link TaskInfo} to the builder.\n * \n */\nexport interface TaskBuilder {\n\n\t/**\n\t * Creates task instance according values set in the builder\n\t * \n\t * @return task instance\n\t */\n\tcreate(): Task;\n\n\t/**\n\t * DB id of the task.\n\t */\n\tid(id: string): TaskBuilder;\n\tgetId(): string;\n\n\t/**\n\t * Name or title of the task.\n\t */\n\tname(name: string): TaskBuilder;\n\tgetName(): string;\n\n\t/**\n\t * Free text description of the task.\n\t */\n\tdescription(description: string): TaskBuilder;\n\tgetDescription(): string;\n\n\t/**\n\t * Indication of how important/urgent this task is\n\t */\n\tpriority(priority: number): TaskBuilder;\n\tgetPriority(): number;\n\n\t/**\n\t * The userId of the person that is responsible for this task.\n\t */\n\towner(ownerId: string): TaskBuilder;\n\tgetOwner(): string;\n\n\t/**\n\t * The userId of the person to which this task is delegated.\n\t */\n\tassignee(assigneId: string): TaskBuilder;\n\tgetAssignee(): string;\n\n\t/**\n\t * Change due date of the task.\n\t */\n\tdueDate(dueDate: Date): TaskBuilder;\n\tgetDueDate(): Date;\n\n\t/**\n\t * Change the category of the task. This is an optional field and allows to 'tag' tasks as belonging to a certain category.\n\t */\n\tcategory(category: string): TaskBuilder;\n\tgetCategory(): string;\n\n\t/**\n\t * the parent task for which this task is a subtask\n\t */\n\tparentTaskId(parentTaskId: string): TaskBuilder;\n\tgetParentTaskId(): string;\n\n\t/**\n\t * Change the tenantId of the task\n\t */\n\ttenantId(tenantId: string): TaskBuilder;\n\tgetTenantId(): string;\n\n\t/**\n\t * Change the form key of the task\n\t */\n\tformKey(formKey: string): TaskBuilder;\n\tgetFormKey(): string;\n\n\t/**\n\t * task definition id to create task from\n\t */\n\ttaskDefinitionId(taskDefinitionId: string): TaskBuilder;\n\tgetTaskDefinitionId(): string;\n\n\t/**\n\t * task definition key to create task from\n\t */\n\ttaskDefinitionKey(taskDefinitionKey: string): TaskBuilder;\n\tgetTaskDefinitionKey(): string;\n\n\t/**\n\t * add identity links to the task\n\t */\n\tidentityLinks(identityLinks: Set<IdentityLinkInfo>): TaskBuilder;\n\tgetIdentityLinks(): Set<IdentityLinkInfo>;\n\n\t/**\n\t * add task scopeId\n\t */\n\tscopeId(scopeId: string): TaskBuilder;\n\tgetScopeId(): string;\n\n\t/**\n\t * Add scope type\n\t */\n\tscopeType(scopeType: string): TaskBuilder;\n\tgetScopeType(): string;\n}\n\nexport interface FormInfo {\n\n\tgetId(): string;\n\n\tsetId(id: string): void;\n\n\tgetName(): string;\n\n\tsetName(name: string): void;\n\n\tgetDescription(): string;\n\n\tsetDescription(description: string): void;\n\n\tgetKey(): string;\n\n\tsetKey(key: string): void;\n\n\tgetVersion(): number;\n\n\tsetVersion(version: number): void;\n\n\tgetFormModel(): any;\n\n\tsetFormModel(formModel: any): void;\n}\n\nexport interface ValueFields {\n\n\t/**\n\t * @return the name of the variable\n\t */\n\tgetName(): string;\n\n\t/**\n\t * @return the process instance id of the variable\n\t */\n\tgetProcessInstanceId(): string;\n\n\t/**\n\t * @return the execution id of the variable\n\t */\n\tgetExecutionId(): string;\n\n\t/**\n\t * @return the scope id of the variable\n\t */\n\tgetScopeId(): string;\n\n\t/**\n\t * @return the sub scope id of the variable\n\t */\n\tgetSubScopeId(): string;\n\n\t/**\n\t * @return the scope type of the variable\n\t */\n\tgetScopeType(): string;\n\n\t/**\n\t * @return the task id of the variable\n\t */\n\tgetTaskId(): string;\n\n\t/**\n\t * @return the first text value, if any, or null.\n\t */\n\tgetTextValue(): string;\n\n\t/**\n\t * Sets the first text value. A value of null is allowed.\n\t */\n\tsetTextValue(textValue: string): void;\n\n\t/**\n\t * @return the second text value, if any, or null.\n\t */\n\tgetTextValue2(): string;\n\n\t/**\n\t * Sets second text value. A value of null is allowed.\n\t */\n\tsetTextValue2(textValue2: string): void;\n\n\t/**\n\t * @return the long value, if any, or null.\n\t */\n\tgetLongValue(): number;\n\n\t/**\n\t * Sets the long value. A value of null is allowed.\n\t */\n\tsetLongValue(longValue: number): void;\n\n\t/**\n\t * @return the double value, if any, or null.\n\t */\n\tgetDoubleValue(): number;\n\n\t/**\n\t * Sets the double value. A value of null is allowed.\n\t */\n\tsetDoubleValue(doubleValue: number): void;\n\n\t/**\n\t * @return the byte array value, if any, or null.\n\t */\n\tgetBytes(): any[];\n\n\t/**\n\t * Sets the byte array value. A value of null is allowed.\n\t */\n\tsetBytes(bytes: any[]): void;\n\n\tgetCachedValue(): any;\n\n\tsetCachedValue(cachedValue: any): void;\n\n}\n\nexport interface VariableInstance extends ValueFields {\n\n\tgetId(): string;\n\n\tsetId(id: string): void;\n\n\tsetName(name: string): void;\n\n\tsetExecutionId(executionId: string): void;\n\n\tsetProcessInstanceId(processInstanceId: string): void;\n\n\tsetProcessDefinitionId(processDefinitionId: string): void;\n\n\tgetProcessDefinitionId(): string;\n\n\tgetValue(): any;\n\n\tsetValue(value: any): void;\n\n\tgetTypeName(): string;\n\n\tsetTypeName(typeName: string): void;\n\n\tisReadOnly(): boolean;\n\n\tsetTaskId(taskId: string): void;\n\n\tsetScopeId(scopeId: string): void;\n\n\tsetSubScopeId(subScopeId: string): void;\n\n\tsetScopeType(scopeType: string): void;\n\n\tsetScopeDefinitionId(scopeDefinitionId: string): void;\n\n\tgetScopeDefinitionId(): string;\n\n\tgetMetaInfo(): string;\n\n\tsetMetaInfo(metaInfo: string): void;\n\n}\n\nexport interface DataObject {\n\n\t/**\n\t * The unique id of this Data Object.\n\t */\n\tgetId(): string;\n\n\t/**\n\t /**\n\t * The id of the process instance that this Data Object is associated with.\n\t */\n\tgetProcessInstanceId(): string;\n\n\t/**\n\t * The id of the execution in which this Data Object resides. A DataObject only resides on a process instance\n\t * execution or a subprocess execution.\n\t */\n\tgetExecutionId(): string;\n\n\t/**\n\t * Name of the DataObject.\n\t */\n\tgetName(): string;\n\n\t/**\n\t * Localized Name of the DataObject.\n\t */\n\tgetLocalizedName(): string;\n\n\t/**\n\t * Description of the DataObject.\n\t */\n\tgetDescription(): string;\n\n\t/**\n\t * Value of the DataObject.\n\t */\n\tgetValue(): any;\n\n\t/**\n\t * Type of the DataObject.\n\t */\n\tgetType(): string;\n\n\t/**\n\t * The id of the flow element in the process defining this data object.\n\t */\n\tgetDataObjectDefinitionKey(): string;\n}\n\nexport interface Comment {\n\n\t/** unique identifier for this comment */\n\tgetId(): string;\n\n\t/** reference to the user that made the comment */\n\tgetUserId(): string;\n\n\tsetUserId(userId: string): void;\n\n\tgetTime(): Date;\n\n\tsetTime(time: Date);\n\n\t/** reference to the task on which this comment was made */\n\tgetTaskId(): string;\n\n\tsetTaskId(taskId: string): void;\n\n\t/** reference to the process instance on which this comment was made */\n\tgetProcessInstanceId(): string;\n\n\tsetProcessInstanceId(processInstanceId: string): void;\n\n\t/** reference to the type given to the comment */\n\tgetType(): string;\n\n\tsetType(type: string): void;\n\n\t/**\n\t * the full comment message the user had related to the task and/or process instance\n\t * \n\t * @see TaskService#getTaskComments(String)\n\t */\n\tgetFullMessage(): string;\n\n\tsetFullMessage(fullMessage: string): void;\n}\n\nexport interface TaskEvent {\n\n\t/** Unique identifier for this event */\n\tgetId(): string;\n\n\t/**\n\t * Indicates the type of of action and also indicates the meaning of the parts as exposed in {@link #getMessageParts()}\n\t */\n\tgetAction(): string;\n\n\t/**\n\t * The meaning of the message parts is defined by the action as you can find in {@link #getAction()}\n\t */\n\tgetMessageParts(): string[];\n\n\t/**\n\t * The message that can be used in case this action only has a single message part.\n\t */\n\tgetMessage(): string;\n\n\t/** reference to the user that made the comment */\n\tgetUserId(): string;\n\n\t/** time and date when the user made the comment */\n\tgetTime(): Date;\n\n\t/** reference to the task on which this comment was made */\n\tgetTaskId(): string;\n\n\t/** reference to the process instance on which this comment was made */\n\tgetProcessInstanceId(): string;\n\n}\n\nexport interface Attachment {\n\n\t/** unique id for this attachment */\n\tgetId(): string;\n\n\t/** free user defined short (max 255 chars) name for this attachment */\n\tgetName(): string;\n\n\t/** free user defined short (max 255 chars) name for this attachment */\n\tsetName(name: string): void;\n\n\t/**\n\t * long (max 255 chars) explanation what this attachment is about in context of the task and/or process instance it's linked to.\n\t */\n\tgetDescription(): string;\n\n\t/**\n\t * long (max 255 chars) explanation what this attachment is about in context of the task and/or process instance it's linked to.\n\t */\n\tsetDescription(description: string): void;\n\n\t/**\n\t * indication of the type of content that this attachment refers to. Can be mime type or any other indication.\n\t */\n\tgetType(): string;\n\n\t/** reference to the task to which this attachment is associated. */\n\n\tgetTaskId(): string;\n\t/**\n\t * reference to the process instance to which this attachment is associated.\n\t */\n\tgetProcessInstanceId(): string;\n\n\t/**\n\t * the remote URL in case this is remote content. If the attachment content was {@link TaskService#createAttachment(String, String, String, String, String, java.io.InputStream) uploaded with an\n\t * input stream}, then this method returns null and the content can be fetched with {@link TaskService#getAttachmentContent(String)}.\n\t */\n\tgetUrl(): string;\n\n\t/** reference to the user who created this attachment. */\n\tgetUserId(): string;\n\n\t/** timestamp when this attachment was created */\n\tgetTime(): Date;\n\n\t/** timestamp when this attachment was created */\n\tsetTime(time: Date): void;\n\n\t/** the id of the byte array entity storing the content */\n\tgetContentId(): string;\n\n}\n\nexport enum NullHandlingOnOrder {\n\tNULLS_FIRST, NULLS_LAST\n}\n\nexport interface QueryProperty {\n\n\tgetName(): string;\n}\n\nexport interface Query<T, U> {\n\n\t/**\n\t * Order the results ascending on the given property as defined in this class (needs to come after a call to one of the orderByXxxx methods).\n\t */\n\tasc(): T;\n\n\t/**\n\t * Order the results descending on the given property as defined in this class (needs to come after a call to one of the orderByXxxx methods).\n\t */\n\tdesc(): T;\n\n\torderBy(property: QueryProperty): T;\n\n\torderBy(property: QueryProperty, nullHandlingOnOrder: NullHandlingOnOrder): T;\n\n\t/**\n\t * Executes the query and returns the number of results\n\t */\n\tcount(): number;\n\n\t/**\n\t * Executes the query and returns the resulting entity or null if no entity matches the query criteria.\n\t *\n\t * @throws org.flowable.common.engine.api.FlowableException when the query results in more than one entities.\n\t */\n\tsingleResult(): U;\n\n\t/**\n\t * Executes the query and get a list of entities as the result.\n\t */\n\tlist(): U[];\n\n\t/**\n\t * Executes the query and get a list of entities as the result.\n\t */\n\tlistPage(firstResult: number, maxResults: number): U[];\n}\n\n\nexport interface TaskInfoQuery<T, V extends TaskInfo> extends Query<T, V> {\n\n\t/**\n\t * Only select tasks with the given task id (in practice, there will be maximum one of this kind)\n\t */\n\ttaskId(taskId: string): T;\n\n\t/**\n\t * Only select tasks with an id that is in the given list\n\t *\n\t * @throws FlowableIllegalArgumentException\n\t *             When passed id list is empty or <code>null</code> or contains <code>null String</code>.\n\t */\n\ttaskIds(taskIds: string[]): T;\n\n\t/** Only select tasks with the given name */\n\ttaskName(name: string): T;\n\n\t/**\n\t * Only select tasks with a name that is in the given list\n\t * \n\t * @throws FlowableIllegalArgumentException\n\t *             When passed name list is empty or <code>null</code> or contains <code>null String</code>.\n\t */\n\ttaskNameIn(nameList: string[]): T;\n\n\t/**\n\t * Only select tasks with a name that is in the given list\n\t * \n\t * This method, unlike the {@link #taskNameIn(Collection)} method will not take in account the upper/lower case: both the input parameters as the column value are lowercased when the query is executed.\n\t * \n\t * @throws FlowableIllegalArgumentException\n\t *             When passed name list is empty or <code>null</code> or contains <code>null String</code>.\n\t */\n\ttaskNameInIgnoreCase(nameList: string[]): T;\n\n\t/**\n\t * Only select tasks with a name matching the parameter. The syntax is that of SQL: for example usage: nameLike(%test%)\n\t */\n\ttaskNameLike(nameLike: string): T;\n\n\t/**\n\t * Only select tasks with a name matching the parameter. The syntax is that of SQL: for example usage: nameLike(%test%)\n\t * \n\t * This method, unlike the {@link #taskNameLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is\n\t * executed.\n\t */\n\ttaskNameLikeIgnoreCase(nameLike: string): T;\n\n\t/** Only select tasks with the given description. */\n\ttaskDescription(description: string): T;\n\n\t/**\n\t * Only select tasks with a description matching the parameter . The syntax is that of SQL: for example usage: descriptionLike(%test%)\n\t */\n\ttaskDescriptionLike(descriptionLike: string): T;\n\n\t/**\n\t * Only select tasks with a description matching the parameter . The syntax is that of SQL: for example usage: descriptionLike(%test%)\n\t * \n\t * This method, unlike the {@link #taskDescriptionLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is\n\t * executed.\n\t */\n\ttaskDescriptionLikeIgnoreCase(descriptionLike: string): T;\n\n\t/** Only select tasks with the given priority. */\n\ttaskPriority(priority: number): T;\n\n\t/** Only select tasks with the given priority or higher. */\n\ttaskMinPriority(minPriority: number): T;\n\n\t/** Only select tasks with the given priority or lower. */\n\ttaskMaxPriority(maxPriority: number): T;\n\n\t/** Only select tasks which are assigned to the given user. */\n\ttaskAssignee(assignee: string): T;\n\n\t/**\n\t * Only select tasks which were last assigned to an assignee like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t */\n\ttaskAssigneeLike(assigneeLike: string): T;\n\n\t/**\n\t * Only select tasks which were last assigned to an assignee like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t * \n\t * This method, unlike the {@link #taskAssigneeLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is\n\t * executed.\n\t */\n\ttaskAssigneeLikeIgnoreCase(assigneeLikeIgnoreCase: string): T;\n\n\t/** Only select tasks which don't have an assignee. */\n\ttaskUnassigned(): T;\n\n\t/** Only select tasks which are assigned to any user */\n\ttaskAssigned(): T;\n\n\t/**\n\t * Only select tasks with an assignee that is in the given list\n\t * \n\t * @throws FlowableIllegalArgumentException\n\t *             When passed name list is empty or <code>null</code> or contains <code>null String</code>.\n\t */\n\ttaskAssigneeIds(assigneeListIds: string[]): T;\n\n\t/** Only select tasks for which the given user is the owner. */\n\ttaskOwner(owner: string): T;\n\n\t/**\n\t * Only select tasks which were last assigned to an owner like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t */\n\ttaskOwnerLike(ownerLike: string): T;\n\n\t/**\n\t * Only select tasks which were last assigned to an owner like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t * \n\t * This method, unlike the {@link #taskOwnerLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the query is\n\t * executed.\n\t */\n\ttaskOwnerLikeIgnoreCase(ownerLikeIgnoreCase: string): T;\n\n\t/** Only select tasks for which the given user is a candidate. */\n\ttaskCandidateUser(candidateUser: string): T;\n\n\t/**\n\t * Only select tasks for which there exist an {@link IdentityLink} with the given user, including tasks which have been assigned to the given user (assignee) or owned by the given user (owner).\n\t */\n\ttaskInvolvedUser(involvedUser: string): T;\n\n\t/**\n\t * Only select tasks for which there exist an {@link IdentityLink} with the given Groups.\n\t */\n\ttaskInvolvedGroups(involvedGroup: string[]): T;\n\n\t/**\n\t * Allows to select a task using {@link #taskCandidateGroup(String)} {@link #taskCandidateGroupIn(Collection)} or {@link #taskCandidateUser(String)} but ignore the assignee value instead of querying for an empty assignee.\n\t */\n\tignoreAssigneeValue(): T;\n\n\t/** Only select tasks for which users in the given group are candidates. */\n\ttaskCandidateGroup(candidateGroup: string): T;\n\n\t/**\n\t * Only select tasks for which the 'candidateGroup' is one of the given groups.\n\t * \n\t * @throws FlowableIllegalArgumentException\n\t *             When query is executed and {@link #taskCandidateGroup(String)} or {@link #taskCandidateUser(String)} has been executed on the query instance. When passed group list is empty or\n\t *             <code>null</code>.\n\t */\n\ttaskCandidateGroupIn(candidateGroups: string[]): T\n\n\t/**\n\t * Only select tasks that have the given tenant id.\n\t */\n\ttaskTenantId(tenantId: string): T;\n\n\t/**\n\t * Only select tasks with a tenant id like the given one.\n\t */\n\ttaskTenantIdLike(tenantIdLike: string): T;\n\n\t/**\n\t * Only select tasks that do not have a tenant id.\n\t */\n\ttaskWithoutTenantId(): T;\n\n\t/**\n\t * Only select tasks for the given process instance id.\n\t */\n\tprocessInstanceId(processInstanceId: string): T;\n\n\t/**\n\t * Only select tasks for the given process ids.\n\t */\n\tprocessInstanceIdIn(processInstanceIds: string[]): T;\n\n\t/**\n\t * Only select tasks without a process instance id.\n\t */\n\twithoutProcessInstanceId(): T;\n\n\t/**\n\t * Only select tasks for the given business key\n\t */\n\tprocessInstanceBusinessKey(processInstanceBusinessKey: string): T;\n\n\t/**\n\t * Only select tasks with a business key like the given value The syntax is that of SQL: for example usage: processInstanceBusinessKeyLike(\"%test%\").\n\t */\n\tprocessInstanceBusinessKeyLike(processInstanceBusinessKeyLike: string): T;\n\n\t/**\n\t * Only select tasks with a business key like the given value The syntax is that of SQL: for example usage: processInstanceBusinessKeyLike(\"%test%\").\n\t * \n\t * This method, unlike the {@link #processInstanceBusinessKeyLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when\n\t * the query is executed.\n\t */\n\tprocessInstanceBusinessKeyLikeIgnoreCase(processInstanceBusinessKeyLikeIgnoreCase: string): T;\n\n\t/**\n\t * Only select tasks for the given execution.\n\t */\n\texecutionId(executionId: string): T;\n\n\t/**\n\t * Only select tasks for the given case instance.\n\t */\n\tcaseInstanceId(caseInstanceId: string): T;\n\n\t/**\n\t * Only select tasks for the given case definition.\n\t */\n\tcaseDefinitionId(caseDefinitionId: string): T;\n\n\t/**\n\t * Only select tasks which are part of a case instance which has the given case definition key.\n\t */\n\tcaseDefinitionKey(caseDefinitionKey: string): T;\n\n\t/**\n\t * Only select tasks which are part of a case instance which has a case definition key like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t */\n\tcaseDefinitionKeyLike(caseDefinitionKeyLike: string): T;\n\n\t/**\n\t * Only select tasks which are part of a case instance which has a case definition key like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t *\n\t * This method, unlike the {@link #caseDefinitionKeyLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the\n\t * query is executed.\n\t */\n\tcaseDefinitionKeyLikeIgnoreCase(caseDefinitionKeyLikeIgnoreCase: string): T;\n\n\t/** Only select tasks that have a case definition for which the key is present in the given list **/\n\tcaseDefinitionKeyIn(caseDefinitionKeys: string[]): T;\n\n\t/**\n\t * Only select tasks for the given plan item instance. \n\t */\n\tplanItemInstanceId(planItemInstanceId: string): T;\n\n\t/**\n\t * Only select tasks for the given scope identifier. \n\t */\n\tscopeId(scopeId: string): T;\n\n\t/**\n\t * Only select tasks for the given sub scope identifier. \n\t */\n\tsubScopeId(subScopeId: string): T;\n\n\t/**\n\t * Only select tasks for the given scope type. \n\t */\n\tscopeType(scopeType: string): T;\n\n\t/**\n\t * Only select tasks for the given scope definition identifier. \n\t */\n\tscopeDefinitionId(scopeDefinitionId: string): T;\n\n\t/**\n\t * Only select tasks for the given stage, defined through its stage instance id.\n\t */\n\tpropagatedStageInstanceId(propagatedStageInstanceId: string): T;\n\n\t/**\n\t * Select all tasks for the given process instance id and its children.\n\t */\n\tprocessInstanceIdWithChildren(processInstanceId: string): T;\n\n\t/**\n\t * Select all tasks for the given case instance id and its children.\n\t */\n\tcaseInstanceIdWithChildren(caseInstanceId: string): T;\n\n\t/**\n\t * Only select tasks that are created on the given date.\n\t */\n\ttaskCreatedOn(createTime: Date): T;\n\n\t/**\n\t * Only select tasks that are created before the given date.\n\t */\n\ttaskCreatedBefore(before: Date): T;\n\n\t/**\n\t * Only select tasks that are created after the given date.\n\t */\n\ttaskCreatedAfter(after: Date): T;\n\n\t/**\n\t * Only select tasks that are started in progress on the given date.\n\t */\n\ttaskInProgressStartTimeOn(claimedTime: Date): T;\n\n\t/**\n\t * Only select tasks that are started in progress before the given date.\n\t */\n\ttaskInProgressStartTimeBefore(before: Date): T;\n\n\t/**\n\t * Only select tasks that are started in progress after the given date.\n\t */\n\ttaskInProgressStartTimeAfter(after: Date): T;\n\n\t/**\n\t * Select all tasks that have an in progress started user reference for the given value.\n\t */\n\ttaskInProgressStartedBy(startedBy: string): T;\n\n\t/**\n\t * Only select tasks that are claimed on the given date.\n\t */\n\ttaskClaimedOn(claimedTime: Date): T;\n\n\t/**\n\t * Only select tasks that are claimed before the given date.\n\t */\n\ttaskClaimedBefore(before: Date): T;\n\n\t/**\n\t * Only select tasks that are claimed after the given date.\n\t */\n\ttaskClaimedAfter(after: Date): T;\n\n\t/**\n\t * Select all tasks that have a claimed by user reference for the given value.\n\t */\n\ttaskClaimedBy(claimedBy: string): T;\n\n\t/**\n\t * Only select tasks that are suspended on the given date.\n\t */\n\ttaskSuspendedOn(suspendedTime: Date): T;\n\n\t/**\n\t * Only select tasks that are suspended before the given date.\n\t */\n\ttaskSuspendedBefore(before: Date): T;\n\n\t/**\n\t * Only select tasks that are suspended after the given date.\n\t */\n\ttaskSuspendedAfter(after: Date): T;\n\n\t/**\n\t * Select all tasks that have a suspended by user reference for the given value.\n\t */\n\ttaskSuspendedBy(suspendedBy: string): T;\n\n\t/**\n\t * Only select tasks with the given category.\n\t */\n\ttaskCategory(category: string): T;\n\n\t/**\n\t * Only select tasks belonging to one of the categories in the given list.\n\t *\n\t * @param taskCategoryInList\n\t * @throws FlowableIllegalArgumentException When passed category list is empty or <code>null</code> or contains <code>null</code> String.\n\t */\n\ttaskCategoryIn(taskCategoryInList: string[]): T;\n\n\t/**\n\t * Only select tasks with a defined category which do not belong to a category present in the given list.\n\t * <p>\n\t * NOTE: This method does <b>not</b> return tasks <b>without</b> category e.g. tasks having a <code>null</code> category.\n\t * To include <code>null</code> categories, use <code>query.or().taskCategoryNotIn(...).taskWithoutCategory().endOr()</code>\n\t * </p>\n\t *\n\t * @param taskCategoryNotInList\n\t * @throws FlowableIllegalArgumentException When passed category list is empty or <code>null</code> or contains <code>null String</code>.\n\t * @see #taskWithoutCategory\n\t */\n\ttaskCategoryNotIn(taskCategoryNotInList: string[]): T;\n\n\t/**\n\t * Selects tasks without category.\n\t * <p>\n\t * Can also be used in conjunction with other filter criteria to include tasks without category e.g. in <code>or</code> queries.\n\t * </p>\n\t * @see #taskCategoryNotIn(Collection)\n\t */\n\ttaskWithoutCategory(): T;\n\n\t/**\n\t * Only select tasks with form key.\n\t */\n\ttaskWithFormKey(): T;\n\n\t/**\n\t * Only select tasks with the given formKey.\n\t */\n\ttaskFormKey(formKey: string): T;\n\n\t/**\n\t * Only select tasks with the given taskDefinitionKey. The task definition key is the id of the userTask: &lt;userTask id=\"xxx\" .../&gt;\n\t **/\n\ttaskDefinitionKey(key: string): T;\n\n\t/**\n\t * Only select tasks with a taskDefinitionKey that match the given parameter. The syntax is that of SQL: for example usage: taskDefinitionKeyLike(\"%test%\"). The task definition key is the id of\n\t * the userTask: &lt;userTask id=\"xxx\" .../&gt;\n\t **/\n\ttaskDefinitionKeyLike(keyLike: string): T;\n\n\t/**\n\t * Only select tasks with the given taskDefinitionKeys. The task definition key is the id of the userTask: &lt;userTask id=\"xxx\" .../&gt;\n\t **/\n\ttaskDefinitionKeys(keys: string[]): T;\n\n\t/**\n\t * Only select tasks with the given state.\n\t **/\n\ttaskState(state: string): T;\n\n\t/**\n\t * Only select tasks with the given in progress start due date.\n\t */\n\ttaskInProgressStartDueDate(dueDate: Date): T;\n\n\t/**\n\t * Only select tasks which have an in progress start due date before the given date.\n\t */\n\ttaskInProgressStartDueBefore(dueDate: Date): T;\n\n\t/**\n\t * Only select tasks which have an in progress start due date after the given date.\n\t */\n\ttaskInProgressStartDueAfter(dueDate: Date): T;\n\n\t/**\n\t * Only select tasks with no in progress start due date.\n\t */\n\twithoutTaskInProgressStartDueDate(): T;\n\n\t/**\n\t * Only select tasks with the given due date.\n\t */\n\ttaskDueDate(dueDate: Date): T;\n\n\t/**\n\t * Only select tasks which have a due date before the given date.\n\t */\n\ttaskDueBefore(dueDate: Date): T;\n\n\t/**\n\t * Only select tasks which have a due date after the given date.\n\t */\n\ttaskDueAfter(dueDate: Date): T;\n\n\t/**\n\t * Only select tasks with no due date.\n\t */\n\twithoutTaskDueDate(): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has the given process definition key.\n\t */\n\tprocessDefinitionKey(processDefinitionKey: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has a process definition key like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t */\n\tprocessDefinitionKeyLike(processDefinitionKeyLike: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has a process definition key like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t * \n\t * This method, unlike the {@link #processDefinitionKeyLike(String)} method will not take in account the upper/lower case: both the input parameter as the column value are lowercased when the\n\t * query is executed.\n\t */\n\tprocessDefinitionKeyLikeIgnoreCase(processDefinitionKeyLikeIgnoreCase: string): T;\n\n\t/** Only select tasks that have a process definition for which the key is present in the given list **/\n\tprocessDefinitionKeyIn(processDefinitionKeys: string[]): T;\n\n\t/**\n\t * Only select tasks which created from the given task definition referenced by id.\n\t */\n\ttaskDefinitionId(taskDefinitionId: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has the given process definition id.\n\t */\n\tprocessDefinitionId(processDefinitionId: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has the given process definition name.\n\t */\n\tprocessDefinitionName(processDefinitionName: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has a process definition name like the given value. The syntax that should be used is the same as in SQL, eg. %test%.\n\t */\n\tprocessDefinitionNameLike(processDefinitionNameLike: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance whose definition belongs to the category which is present in the given list.\n\t * \n\t * @throws FlowableIllegalArgumentException\n\t *             When passed category list is empty or <code>null</code> or contains <code>null String</code>.\n\t * @param processCategoryInList\n\t */\n\tprocessCategoryIn(processCategoryInList: string[]): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance whose definition does not belong to the category which is present in the given list.\n\t * \n\t * @throws FlowableIllegalArgumentException\n\t *             When passed category list is empty or <code>null</code> or contains <code>null String</code>.\n\t * @param processCategoryNotInList\n\t */\n\tprocessCategoryNotIn(processCategoryNotInList: string[]): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has the given deployment id.\n\t */\n\tdeploymentId(deploymentId: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process instance which has the given deployment id.\n\t */\n\tdeploymentIdIn(deploymentIds: string[]): T;\n\n\t/**\n\t * Only select tasks which are related to a case instance for to the given deployment id.\n\t */\n\tcmmnDeploymentId(cmmnDeploymentId: string): T;\n\n\t/**\n\t * Only select tasks which are related to a case instances for the given deployment id.\n\t */\n\tcmmnDeploymentIdIn(cmmnDeploymentIds: string[]): T;\n\n\t/**\n\t * Only select tasks which don't have a scope id set.\n\t */\n\twithoutScopeId(): T;\n\n\t/**\n\t * Only select tasks which have a local task variable with the given name set to the given value.\n\t */\n\ttaskVariableValueEquals(variableName: string, variableValue: any): T;\n\n\t/**\n\t * Only select tasks which have at least one local task variable with the given value.\n\t */\n\ttaskVariableValueEquals(variableValue: any): T;\n\n\t/**\n\t * Only select tasks which have a local string variable with the given value, case insensitive.\n\t * <p>\n\t * This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use \"collate UTF-8\" on MySQL and for MSSQL, select one of the case-sensitive\n\t * Collations available (<a href=\"http://msdn.microsoft.com/en-us/library/ms144250(v=sql.105).aspx\" >MSDN Server Collation Reference</a>).\n\t * </p>\n\t */\n\ttaskVariableValueEqualsIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a local task variable with the given name, but with a different value than the passed value. Byte-arrays and {@link Serializable} objects (which are not primitive\n\t * type wrappers) are not supported.\n\t */\n\ttaskVariableValueNotEquals(variableName: string, variableValue: any): T;\n\n\t/**\n\t * Only select tasks which have a local string variable with is not the given value, case insensitive.\n\t * <p>\n\t * This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use \"collate UTF-8\" on MySQL and for MSSQL, select one of the case-sensitive\n\t * Collations available (<a href=\"http://msdn.microsoft.com/en-us/library/ms144250(v=sql.105).aspx\" >MSDN Server Collation Reference</a>).\n\t * </p>\n\t */\n\ttaskVariableValueNotEqualsIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a local variable value greater than the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers)\n\t * are not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\ttaskVariableValueGreaterThan(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a local variable value greater than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive\n\t * type wrappers) are not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\ttaskVariableValueGreaterThanOrEqual(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a local variable value less than the passed value when the ended.Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers) are\n\t * not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\ttaskVariableValueLessThan(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a local variable value less than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\ttaskVariableValueLessThanOrEqual(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a local variable value like the given value when they ended. This can be used on string variables only.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).\n\t */\n\ttaskVariableValueLike(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a local variable value like the given value (case insensitive) when they ended. This can be used on string variables only.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).\n\t */\n\ttaskVariableValueLikeIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a local variable with the given name.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t */\n\ttaskVariableExists(name: string): T;\n\n\t/**\n\t * Only select tasks which does not have a local variable with the given name.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t */\n\ttaskVariableNotExists(name: string): T;\n\n\t/**\n\t * Only select tasks which are part of a process that has a variable with the given name set to the given value.\n\t */\n\tprocessVariableValueEquals(variableName: string, variableValue: any): T;\n\n\t/**\n\t * Only select tasks which are part of a process that has at least one variable with the given value.\n\t */\n\tprocessVariableValueEquals(variableValue: any): T;\n\n\t/**\n\t * Only select tasks which are part of a process that has a local string variable which is not the given value, case insensitive.\n\t * <p>\n\t * This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use \"collate UTF-8\" on MySQL and for MSSQL, select one of the case-sensitive\n\t * Collations available (<a href=\"http://msdn.microsoft.com/en-us/library/ms144250(v=sql.105).aspx\" >MSDN Server Collation Reference</a>).\n\t * </p>\n\t */\n\tprocessVariableValueEqualsIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a variable with the given name, but with a different value than the passed value. Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t */\n\tprocessVariableValueNotEquals(variableName: string, variableValue: any): T;\n\n\t/**\n\t * Only select tasks which are part of a process that has a string variable with the given value, case insensitive.\n\t * <p>\n\t * This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use \"collate UTF-8\" on MySQL and for MSSQL, select one of the case-sensitive\n\t * Collations available (<a href=\"http://msdn.microsoft.com/en-us/library/ms144250(v=sql.105).aspx\" >MSDN Server Collation Reference</a>).\n\t * </p>\n\t */\n\tprocessVariableValueNotEqualsIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a global variable value greater than the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\tprocessVariableValueGreaterThan(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value greater than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive\n\t * type wrappers) are not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\tprocessVariableValueGreaterThanOrEqual(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value less than the passed value when the ended.Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers) are\n\t * not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\tprocessVariableValueLessThan(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value less than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null.\n\t */\n\tprocessVariableValueLessThanOrEqual(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value like the given value when they ended. This can be used on string variables only.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).\n\t */\n\tprocessVariableValueLike(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a global variable value like the given value (case insensitive) when they ended. This can be used on string variables only.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t * @param value\n\t *            cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).\n\t */\n\tprocessVariableValueLikeIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a global variable with the given name.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t */\n\tprocessVariableExists(name: string): T;\n\n\t/**\n\t * Only select tasks which does not have a global variable with the given name.\n\t * \n\t * @param name\n\t *            cannot be null.\n\t */\n\tprocessVariableNotExists(name: string): T;\n\n\t/**\n\t * Only select tasks which are part of a case that has a variable with the given name set to the given value.\n\t */\n\tcaseVariableValueEquals(variableName: string, variableValue: any): T;\n\n\t/**\n\t * Only select tasks which are part of a case that has at least one variable with the given value.\n\t */\n\tcaseVariableValueEquals(variableValue: any): T;\n\n\t/**\n\t * Only select tasks which are part of a case that has a local string variable which is not the given value, case insensitive.\n\t * <p>\n\t * This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use \"collate UTF-8\" on MySQL and for MSSQL, select one of the case-sensitive\n\t * Collations available (<a href=\"http://msdn.microsoft.com/en-us/library/ms144250(v=sql.105).aspx\" >MSDN Server Collation Reference</a>).\n\t * </p>\n\t */\n\tcaseVariableValueEqualsIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a variable with the given name, but with a different value than the passed value. Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t */\n\tcaseVariableValueNotEquals(variableName: string, variableValue: any): T;\n\n\t/**\n\t * Only select tasks which are part of a case that has a string variable with the given value, case insensitive.\n\t * <p>\n\t * This method only works if your database has encoding/collation that supports case-sensitive queries. For example, use \"collate UTF-8\" on MySQL and for MSSQL, select one of the case-sensitive\n\t * Collations available (<a href=\"http://msdn.microsoft.com/en-us/library/ms144250(v=sql.105).aspx\" >MSDN Server Collation Reference</a>).\n\t * </p>\n\t */\n\tcaseVariableValueNotEqualsIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a global variable value greater than the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t *\n\t * @param name cannot be null.\n\t * @param value cannot be null.\n\t */\n\tcaseVariableValueGreaterThan(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value greater than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive\n\t * type wrappers) are not supported.\n\t *\n\t * @param name cannot be null.\n\t * @param value cannot be null.\n\t */\n\tcaseVariableValueGreaterThanOrEqual(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value less than the passed value when the ended.Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type wrappers) are\n\t * not supported.\n\t *\n\t * @param name cannot be null.\n\t * @param value cannot be null.\n\t */\n\tcaseVariableValueLessThan(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value less than or equal to the passed value when they ended. Booleans, Byte-arrays and {@link Serializable} objects (which are not primitive type\n\t * wrappers) are not supported.\n\t *\n\t * @param name cannot be null.\n\t * @param value cannot be null.\n\t */\n\tcaseVariableValueLessThanOrEqual(name: string, value: any): T;\n\n\t/**\n\t * Only select tasks which have a global variable value like the given value when they ended. This can be used on string variables only.\n\t *\n\t * @param name cannot be null.\n\t * @param value cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).\n\t */\n\tcaseVariableValueLike(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a global variable value like the given value (case insensitive) when they ended. This can be used on string variables only.\n\t *\n\t * @param name cannot be null.\n\t * @param value cannot be null. The string can include the wildcard character '%' to express like-strategy: starts with (string%), ends with (%string) or contains (%string%).\n\t */\n\tcaseVariableValueLikeIgnoreCase(name: string, value: string): T;\n\n\t/**\n\t * Only select tasks which have a global variable with the given name.\n\t *\n\t * @param name cannot be null.\n\t */\n\tcaseVariableExists(name: string): T;\n\n\t/**\n\t * Only select tasks which does not have a global variable with the given name.\n\t *\n\t * @param name cannot be null.\n\t */\n\tcaseVariableNotExists(name: string): T;\n\n\t/**\n\t * Only selects tasks which with the given root scope id\n\t */\n\ttaskRootScopeId(parentScopeId: string): T;\n\n\t/**\n\t * Only selects tasks which with the given parent scope id\n\t */\n\ttaskParentScopeId(parentScopeId: string): T;\n\n\t/**\n\t * Include local task variables in the task query result\n\t */\n\tincludeTaskLocalVariables(): T;\n\n\t/**\n\t * Include global process variables in the task query result\n\t */\n\tincludeProcessVariables(): T;\n\n\t/**\n\t * Include global case variables in the task query result\n\t */\n\tincludeCaseVariables(): T;\n\n\t/**\n\t * Include identity links in the task query result\n\t */\n\tincludeIdentityLinks(): T;\n\n\t/**\n\t * Localize task name and description to specified locale.\n\t */\n\tlocale(locale: string): T;\n\n\t/**\n\t * Instruct localization to fallback to more general locales including the default locale of the JVM if the specified locale is not found.\n\t */\n\twithLocalizationFallback(): T;\n\n\t/**\n\t * All query clauses called will be added to a single or-statement. This or-statement will be included with the other already existing clauses in the query, joined by an 'and'.\n\t * <p>\n\t * Calling endOr() will add all clauses to the regular query again. Calling or() after or() has been called or calling endOr() after endOr() has been called will result in an exception.\n\t * It is possible to call or() endOr() several times if each or() has a matching endOr(), e.g.:\n\t * </p>\n\t * {@code query.<ConditionA>}\n\t * {@code  .or().<conditionB>.<conditionC>.endOr()}\n\t * {@code  .<conditionD>.<conditionE>}\n\t * {@code  .or().<conditionF>.<conditionG>.endOr()}\n\t * <p>\n\t * will result in: conditionA &amp; (conditionB | conditionC) &amp; conditionD &amp; conditionE &amp; (conditionF | conditionG)\n\t */\n\tor(): T;\n\n\tendOr(): T;\n\n\t// ORDERING\n\n\t/**\n\t * Order by task id (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskId(): T;\n\n\t/**\n\t * Order by task name (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskName(): T;\n\n\t/**\n\t * Order by description (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskDescription(): T;\n\n\t/**\n\t * Order by priority (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskPriority(): T;\n\n\t/**\n\t * Order by assignee (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskAssignee(): T;\n\n\t/**\n\t * Order by the time on which the tasks were created (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskCreateTime(): T;\n\n\t/**\n\t * Order by process instance id (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByProcessInstanceId(): T;\n\n\t/**\n\t * Order by execution id (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByExecutionId(): T;\n\n\t/**\n\t * Order by process definition id (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByProcessDefinitionId(): T;\n\n\t/**\n\t * Order by task due date (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskDueDate(): T;\n\n\t/**\n\t * Order by task owner (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskOwner(): T;\n\n\t/**\n\t * Order by task definition key (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTaskDefinitionKey(): T;\n\n\t/**\n\t * Order by tenant id (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByTenantId(): T;\n\n\t/**\n\t * Order by due date (needs to be followed by {@link #asc()} or {@link #desc()}). If any of the tasks have null for the due date, these will be first in the result.\n\t */\n\torderByDueDateNullsFirst(): T;\n\n\t/**\n\t * Order by due date (needs to be followed by {@link #asc()} or {@link #desc()}). If any of the tasks have null for the due date, these will be last in the result.\n\t */\n\torderByDueDateNullsLast(): T;\n\n\t/**\n\t * Order by category (needs to be followed by {@link #asc()} or {@link #desc()}).\n\t */\n\torderByCategory(): T;\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Tasks;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,gBAAwB;AACxB,oBAAuB;AAEvB,MAAM,YAAY,KAAK,KAAK,oDAAoD;AAEzE,MAAM,MAAM;AAAA,EAElB,OAAc,OAAmB;AAChC,UAAM,QAAe,KAAK,MAAM,UAAU,SAAS,CAAC;AACpD,WAAO,MAAM,IAAI,OAAK,IAAI,SAAS,CAAC,CAAC;AAAA,EACtC;AAAA,EAEA,OAAc,YAAY,QAAgB,cAA2B;AACpE,WAAO,qBAAO,WAAW,UAAU,gBAAgB,QAAQ,YAAY,CAAC;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA,EAKA,OAAc,aAAa,QAAkC;AAC5D,WAAO,qBAAO,eAAe,UAAU,iBAAiB,MAAM,CAAC;AAAA,EAChE;AAAA,EAEA,OAAc,YAAY,QAAgB,cAAsB,OAAkB;AACjF,cAAU,gBAAgB,QAAQ,cAAc,qBAAO,eAAe,KAAK,CAAC;AAAA,EAC7E;AAAA,EAEA,OAAc,aAAa,QAAgB,WAAmC;AAC7E,cAAU,iBAAiB,QAAQ,qBAAO,mBAAmB,SAAS,CAAC;AAAA,EACxE;AAAA,EAEA,OAAc,SAAS,QAAgB,YAAoC,CAAC,GAAS;AACpF,cAAU,aAAa,QAAQ,KAAK,UAAU,SAAS,CAAC;AAAA,EACzD;AAAA,EAEA,OAAc,iBAA8B;AAC3C,WAAO,IAAI,YAAY,UAAU,uBAAuB,EAAE,eAAe,CAAC;AAAA,EAC3E;AACD;AAMO,MAAM,YAAY;AAAA,EAIxB,YAAY,aAAkB;AAC7B,SAAK,cAAc;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,QAAQ,QAAuB;AACrC,QAAI,KAAK,UAAU,MAAM,GAAG;AAC3B,aAAO,KAAK,YAAY,QAAQ,MAAM;AAAA,IACvC;AACA,WAAO,KAAK,YAAY,QAAQ;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,oBAAiC;AACvC,WAAO,KAAK,YAAY,kBAAkB;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,SAAS,MAAkB;AACjC,SAAK,YAAY,SAAS,IAAI;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,cAAc,UAAwB;AAC5C,SAAK,YAAY,cAAc,QAAQ;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,WAAW,QAAgB,SAAyB;AAC1D,QAAI,KAAK,UAAU,OAAO,GAAG;AAC5B,WAAK,YAAY,WAAW,QAAQ,OAAO;AAAA,IAC5C,OAAO;AACN,WAAK,YAAY,WAAW,MAAM;AAAA,IACnC;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,YAAY,SAAmB,SAAyB;AAC9D,QAAI,KAAK,UAAU,OAAO,GAAG;AAC5B,WAAK,YAAY,YAAY,SAAS,OAAO;AAAA,IAC9C,OAAO;AACN,WAAK,YAAY,YAAY,OAAO;AAAA,IACrC;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,qBAAqB,QAAgB,cAA4B;AACvE,SAAK,YAAY,WAAW,QAAQ,YAAY;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,sBAAsB,SAAmB,cAA4B;AAC3E,SAAK,YAAY,YAAY,SAAS,YAAY;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeO,MAAM,QAAgB,QAAsB;AAClD,SAAK,YAAY,MAAM,QAAQ,MAAM;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUO,QAAQ,QAAsB;AACpC,SAAK,YAAY,QAAQ,MAAM;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,cAAc,QAAgB,QAAsB;AAC1D,SAAK,YAAY,cAAc,QAAQ,MAAM;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAAY,QAAgB,QAAsB;AACxD,SAAK,YAAY,YAAY,QAAQ,MAAM;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,aAAa,QAAgB,QAAsB;AACzD,SAAK,YAAY,aAAa,QAAQ,MAAM;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,aAAa,QAAgB,QAAsB;AACzD,SAAK,YAAY,aAAa,QAAQ,MAAM;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,YAAY,QAAgB,WAA8B,oBAA6C;AAC7G,QAAI,KAAK,UAAU,SAAS,KAAK,KAAK,UAAU,kBAAkB,GAAG;AACpE,WAAK,YAAY,YAAY,QAAQ,WAAW,kBAAkB;AAAA,IACnE,WAAW,KAAK,UAAU,SAAS,GAAG;AACrC,WAAK,YAAY,YAAY,QAAQ,SAAS;AAAA,IAC/C,OAAO;AACN,WAAK,YAAY,YAAY,MAAM;AAAA,IACpC;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,SAAS,QAAgB,QAAiB,WAA8B,oBAAuC,YAA4B;AACjJ,QAAI,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,SAAS,KAAK,KAAK,UAAU,UAAU,GAAG;AACtF,WAAK,YAAY,SAAS,QAAQ,QAAQ,WAAW,UAAU;AAAA,IAChE,WAAW,KAAK,UAAU,SAAS,KAAK,KAAK,UAAU,UAAU,GAAG;AACnE,WAAK,YAAY,SAAS,QAAQ,WAAW,UAAU;AAAA,IACxD,WAAW,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,SAAS,KAAK,KAAK,UAAU,kBAAkB,GAAG;AACrG,WAAK,YAAY,SAAS,QAAQ,QAAQ,WAAW,kBAAkB;AAAA,IACxE,WAAW,KAAK,UAAU,SAAS,KAAK,KAAK,UAAU,kBAAkB,GAAG;AAC3E,WAAK,YAAY,SAAS,QAAQ,WAAW,kBAAkB;AAAA,IAChE,WAAW,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,SAAS,GAAG;AAC/D,WAAK,YAAY,SAAS,QAAQ,QAAQ,SAAS;AAAA,IACpD,WAAW,KAAK,UAAU,SAAS,GAAG;AACrC,WAAK,YAAY,SAAS,QAAQ,SAAS;AAAA,IAC5C,WAAW,KAAK,UAAU,MAAM,GAAG;AAClC,WAAK,YAAY,SAAS,QAAQ,MAAM;AAAA,IACzC,OAAO;AACN,WAAK,YAAY,SAAS,MAAM;AAAA,IACjC;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBO,qBAAqB,QAAgB,kBAA0B,SAAiB,WAA6B,QAAiB,oBAAuC,YAA4B;AACvM,QAAI,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,UAAU,GAAG;AACzD,WAAK,YAAY,qBAAqB,QAAQ,kBAAkB,SAAS,QAAQ,WAAW,UAAU;AAAA,IACvG,WAAW,KAAK,UAAU,UAAU,GAAG;AACtC,WAAK,YAAY,qBAAqB,QAAQ,kBAAkB,SAAS,WAAW,UAAU;AAAA,IAC/F,WAAW,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,kBAAkB,GAAG;AACxE,WAAK,YAAY,qBAAqB,QAAQ,kBAAkB,SAAS,QAAQ,WAAW,kBAAkB;AAAA,IAC/G,WAAW,KAAK,UAAU,kBAAkB,GAAG;AAC9C,WAAK,YAAY,qBAAqB,QAAQ,kBAAkB,SAAS,WAAW,kBAAkB;AAAA,IACvG,WAAW,KAAK,UAAU,MAAM,GAAG;AAClC,WAAK,YAAY,qBAAqB,QAAQ,kBAAkB,SAAS,QAAQ,SAAS;AAAA,IAC3F,OAAO;AACN,WAAK,YAAY,qBAAqB,QAAQ,kBAAkB,SAAS,SAAS;AAAA,IACnF;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,iBAAiB,QAAgB,iBAAqC;AAC5E,QAAI,KAAK,UAAU,eAAe,GAAG;AACpC,aAAO,KAAK,YAAY,iBAAiB,QAAQ,eAAe;AAAA,IACjE,OAAO;AACN,aAAO,KAAK,YAAY,iBAAiB,MAAM;AAAA,IAChD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAAY,QAAgB,QAAsB;AACxD,SAAK,YAAY,YAAY,QAAQ,MAAM;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,SAAS,QAAgB,QAAsB;AACrD,SAAK,YAAY,SAAS,QAAQ,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,wBAAwB,QAAgC;AAC9D,WAAO,KAAK,YAAY,wBAAwB,MAAM;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,iBAAiB,QAAgB,QAAsB;AAC7D,SAAK,YAAY,iBAAiB,QAAQ,MAAM;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,kBAAkB,QAAgB,SAAuB;AAC/D,SAAK,YAAY,kBAAkB,QAAQ,OAAO;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,oBAAoB,QAAgB,QAAgB,kBAAgC;AAC1F,SAAK,YAAY,oBAAoB,QAAQ,QAAQ,gBAAgB;AAAA,EACtE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,qBAAqB,QAAgB,SAAiB,kBAAgC;AAC5F,SAAK,YAAY,qBAAqB,QAAQ,SAAS,gBAAgB;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,oBAAoB,QAAgB,QAAsB;AAChE,SAAK,YAAY,oBAAoB,QAAQ,MAAM;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,qBAAqB,QAAgB,SAAuB;AAClE,SAAK,YAAY,qBAAqB,QAAQ,OAAO;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,uBAAuB,QAAgB,QAAgB,kBAAgC;AAC7F,SAAK,YAAY,uBAAuB,QAAQ,QAAQ,gBAAgB;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,wBAAwB,QAAgB,SAAiB,kBAAgC;AAC/F,SAAK,YAAY,wBAAwB,QAAQ,SAAS,gBAAgB;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,YAAY,QAAgB,UAAwB;AAC1D,SAAK,YAAY,YAAY,QAAQ,QAAQ;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,WAAW,QAAgB,SAAqB;AACtD,SAAK,YAAY,WAAW,QAAQ,OAAO;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAKO,YAAY,QAAgB,cAAsB,OAAkB;AAC1E,SAAK,YAAY,YAAY,QAAQ,cAAc,qBAAO,eAAe,KAAK,CAAC;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA,EAKO,aAAa,QAAgB,WAAmC;AACtE,SAAK,YAAY,aAAa,QAAQ,qBAAO,mBAAmB,SAAS,CAAC;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA,EAKO,iBAAiB,QAAgB,cAAsB,OAAkB;AAC/E,SAAK,YAAY,iBAAiB,QAAQ,cAAc,qBAAO,eAAe,KAAK,CAAC;AAAA,EACrF;AAAA;AAAA;AAAA;AAAA,EAKO,kBAAkB,QAAgB,WAAmC;AAC3E,SAAK,YAAY,kBAAkB,QAAQ,qBAAO,mBAAmB,SAAS,CAAC;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA,EAKO,YAAY,QAAgB,cAA2B;AAC7D,WAAO,qBAAO,WAAW,KAAK,YAAY,YAAY,QAAQ,YAAY,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,oBAAoB,QAAgB,cAAwC;AAClF,WAAO,KAAK,YAAY,oBAAoB,QAAQ,YAAY;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA,EAKO,YAAY,QAAgB,cAA+B;AACjE,WAAO,KAAK,YAAY,YAAY,QAAQ,YAAY;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA,EAKO,iBAAiB,QAAgB,cAA2B;AAClE,WAAO,qBAAO,WAAW,KAAK,YAAY,iBAAiB,QAAQ,YAAY,CAAC;AAAA,EACjF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,yBAAyB,QAAgB,cAAwC;AACvF,WAAO,KAAK,YAAY,yBAAyB,QAAQ,YAAY;AAAA,EACtE;AAAA;AAAA;AAAA;AAAA,EAKO,iBAAiB,QAAgB,cAA+B;AACtE,WAAO,KAAK,YAAY,iBAAiB,QAAQ,YAAY;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,aAAa,QAAgB,eAA4C;AAC/E,QAAI,KAAK,UAAU,aAAa,GAAG;AAClC,aAAO,qBAAO,eAAe,KAAK,YAAY,aAAa,QAAQ,aAAa,CAAC;AAAA,IAClF,OAAO;AACN,aAAO,qBAAO,eAAe,KAAK,YAAY,aAAa,MAAM,CAAC;AAAA,IACnE;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,qBAAqB,QAAgB,eAAyD;AACpG,QAAI,KAAK,UAAU,aAAa,GAAG;AAClC,aAAO,KAAK,YAAY,qBAAqB,QAAQ,aAAa;AAAA,IACnE,OAAO;AACN,aAAO,KAAK,YAAY,qBAAqB,MAAM;AAAA,IACpD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,kBAAkB,QAAgB,eAA4C;AACpF,QAAI,KAAK,UAAU,aAAa,GAAG;AAClC,aAAO,qBAAO,eAAe,KAAK,YAAY,kBAAkB,QAAQ,aAAa,CAAC;AAAA,IACvF,OAAO;AACN,aAAO,qBAAO,eAAe,KAAK,YAAY,kBAAkB,MAAM,CAAC;AAAA,IACxE;AAAA,EACD;AAAA;AAAA,EAGO,mCAAmC,SAA0C;AACnF,WAAO,KAAK,YAAY,mCAAmC,OAAO;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,0BAA0B,QAAgB,eAAyD;AACzG,QAAI,KAAK,UAAU,aAAa,GAAG;AAClC,aAAO,KAAK,YAAY,0BAA0B,QAAQ,aAAa;AAAA,IACxE,OAAO;AACN,aAAO,KAAK,YAAY,0BAA0B,MAAM;AAAA,IACzD;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAKO,eAAe,QAAgB,cAA4B;AACjE,SAAK,YAAY,eAAe,QAAQ,YAAY;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA,EAKO,oBAAoB,QAAgB,cAA4B;AACtE,SAAK,YAAY,oBAAoB,QAAQ,YAAY;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA,EAKO,gBAAgB,QAAgB,eAA+B;AACrE,SAAK,YAAY,gBAAgB,QAAQ,aAAa;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA,EAKO,qBAAqB,QAAgB,eAA+B;AAC1E,SAAK,YAAY,qBAAqB,QAAQ,aAAa;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBO,eAAe,QAAgB,iBAA4B,QAAiB,0BAA6D;AAC/I,QAAI,KAAK,UAAU,eAAe,KAAK,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,wBAAwB,GAAG;AAC1G,aAAO,KAAK,YAAY,eAAe,QAAQ,iBAAiB,QAAQ,wBAAwB;AAAA,IACjG,WAAW,KAAK,UAAU,eAAe,GAAG;AAC3C,aAAO,KAAK,YAAY,eAAe,QAAQ,eAAe;AAAA,IAC/D,WAAW,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,wBAAwB,GAAG;AAC9E,aAAO,KAAK,YAAY,eAAe,QAAQ,QAAQ,wBAAwB;AAAA,IAChF,OAAO;AACN,aAAO,KAAK,YAAY,eAAe,MAAM;AAAA,IAC9C;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBO,cAAc,QAAgB,YAAoB,QAAiB,0BAAgD;AACzH,QAAI,KAAK,UAAU,MAAM,KAAK,KAAK,UAAU,wBAAwB,GAAG;AACvE,aAAO,KAAK,YAAY,cAAc,QAAQ,YAAY,QAAQ,wBAAwB;AAAA,IAC3F,OAAO;AACN,aAAO,KAAK,YAAY,cAAc,QAAQ,UAAU;AAAA,IACzD;AAAA,EACD;AAAA;AAAA,EAGO,WAAW,QAAgB,mBAA2B,SAAiB,MAAwB;AACrG,QAAI,KAAK,UAAU,IAAI,GAAG;AACzB,aAAO,KAAK,YAAY,WAAW,QAAQ,mBAAmB,MAAM,OAAO;AAAA,IAC5E,OAAO;AACN,aAAO,KAAK,YAAY,WAAW,QAAQ,mBAAmB,OAAO;AAAA,IACtE;AAAA,EACD;AAAA;AAAA,EAGO,YAAY,SAAwB;AAC1C,SAAK,YAAY,YAAY,OAAO;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA,EAKO,WAAW,WAA4B;AAC7C,WAAO,KAAK,YAAY,WAAW,SAAS;AAAA,EAC7C;AAAA;AAAA,EAGO,eAAe,QAAgB,mBAAiC;AACtE,SAAK,YAAY,eAAe,QAAQ,iBAAiB;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,cAAc,WAAyB;AAC7C,SAAK,YAAY,cAAc,SAAS;AAAA,EACzC;AAAA;AAAA,EAGO,gBAAgB,QAAgB,MAA0B;AAChE,QAAI,KAAK,UAAU,IAAI,GAAG;AACzB,aAAO,KAAK,YAAY,gBAAgB,QAAQ,IAAI;AAAA,IACrD,OAAO;AACN,aAAO,KAAK,YAAY,gBAAgB,MAAM;AAAA,IAC/C;AAAA,EACD;AAAA;AAAA,EAGO,kBAAkB,MAAyB;AACjD,WAAO,KAAK,YAAY,kBAAkB,IAAI;AAAA,EAC/C;AAAA;AAAA,EAGO,cAAc,QAA6B;AACjD,WAAO,KAAK,YAAY,cAAc,MAAM;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA,EAKO,SAAS,SAA4B;AAC3C,WAAO,KAAK,YAAY,SAAS,OAAO;AAAA,EACzC;AAAA;AAAA,EAGO,2BAA2B,mBAA2B,MAA0B;AACtF,QAAI,KAAK,UAAU,IAAI,GAAG;AACzB,aAAO,KAAK,YAAY,2BAA2B,mBAAmB,IAAI;AAAA,IAC3E,OAAO;AACN,aAAO,KAAK,YAAY,2BAA2B,iBAAiB;AAAA,IACrE;AAAA,EACD;AAAA;AAAA;AAAA;AAAA,EAKO,iBAAiB,gBAAwB,QAAgB,mBAA2B,gBAAwB,uBAA+B,SAAiB,KAA0B;AAC5L,QAAI,KAAK,UAAU,GAAG,GAAG;AACxB,aAAO,KAAK,YAAY,iBAAiB,gBAAgB,QAAQ,mBAAmB,gBAAgB,uBAAuB,GAAG;AAAA,IAC/H,OAAO;AACN,aAAO,KAAK,YAAY,iBAAiB,gBAAgB,QAAQ,mBAAmB,gBAAgB,uBAAuB,kBAAQ,2BAA2B,OAAO,CAAC;AAAA,IACvK;AAAA,EACD;AAAA;AAAA,EAGO,eAAe,YAA8B;AACnD,SAAK,YAAY,eAAe,UAAU;AAAA,EAC3C;AAAA;AAAA,EAGO,cAAc,cAAkC;AACtD,WAAO,KAAK,YAAY,cAAc,YAAY;AAAA,EACnD;AAAA;AAAA,EAGO,qBAAqB,cAA6B;AACxD,UAAM,UAAU,KAAK,YAAY,qBAAqB,YAAY;AAClE,UAAM,OAAO,kBAAQ,4BAA4B;AACjD,sBAAQ,UAAU,SAAS,IAAI;AAC/B,WAAO,KAAK,SAAS;AAAA,EACtB;AAAA;AAAA,EAGO,mBAAmB,QAA8B;AACvD,WAAO,KAAK,YAAY,mBAAmB,MAAM;AAAA,EAClD;AAAA;AAAA,EAGO,8BAA8B,mBAAyC;AAC7E,WAAO,KAAK,YAAY,8BAA8B,iBAAiB;AAAA,EACxE;AAAA;AAAA,EAGO,iBAAiB,cAA4B;AACnD,SAAK,YAAY,iBAAiB,YAAY;AAAA,EAC/C;AAAA;AAAA,EAGO,YAAY,cAA8B;AAChD,WAAO,KAAK,YAAY,YAAY,YAAY;AAAA,EACjD;AAAA,EAEQ,UAAU,UAAwB;AACzC,WAAO,aAAa,QAAQ,aAAa;AAAA,EAC1C;AACD;AAEA,MAAM,SAAS;AAAA,EAId,YAAY,MAAW;AACtB,SAAK,OAAO;AAAA,EACb;AAAA,EAEO,QAA4B;AAClC,WAAO,KAAK,KAAK,MAAM;AAAA,EACxB;AAAA,EAEO,cAAsB;AAC5B,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,WAA+B;AACrC,WAAO,KAAK,KAAK,SAAS;AAAA,EAC3B;AAAA,EAEO,0BAAkC;AACxC,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,sBAA0C;AAChD,WAAO,KAAK,KAAK,oBAAoB;AAAA,EACtC;AAAA,EAEO,cAAkC;AACxC,WAAO,KAAK,KAAK,YAAY;AAAA,EAC9B;AAAA,EAEO,qBAAyC;AAC/C,WAAO,KAAK,KAAK,mBAAmB;AAAA,EACrC;AAAA,EAEO,kBAAsC;AAC5C,WAAO,KAAK,KAAK,gBAAgB;AAAA,EAClC;AAAA,EAEO,UAA8B;AACpC,WAAO,KAAK,KAAK,QAAQ;AAAA,EAC1B;AAAA,EAEO,mBAAuC;AAC7C,WAAO,KAAK,KAAK,iBAAiB;AAAA,EACnC;AAAA,EAEO,iBAAqC;AAC3C,WAAO,KAAK,KAAK,eAAe;AAAA,EACjC;AAAA,EAEO,0BAA8C;AACpD,WAAO,KAAK,KAAK,wBAAwB;AAAA,EAC1C;AAAA,EAEO,cAAsB;AAC5B,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,gBAAkC;AACxC,WAAO,KAAK,KAAK,cAAc;AAAA,EAChC;AAAA,EAEO,aAA+B;AACrC,WAAO,KAAK,KAAK,WAAW;AAAA,EAC7B;AAAA,EAEO,qBAA6B;AACnC,WAAO,KAAK,KAAK,mBAAmB;AAAA,EACrC;AAAA,EAEO,cAAkC;AACxC,WAAO,KAAK,KAAK,YAAY;AAAA,EAC9B;AAAA,EAEO,6BAAsC;AAC5C,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,iBAAqC;AAC3C,WAAO,KAAK,KAAK,eAAe;AAAA,EACjC;AAAA,EAEO,uBAA2C;AACjD,WAAO,KAAK,KAAK,qBAAqB;AAAA,EACvC;AAAA,EAEO,yBAA6C;AACnD,WAAO,KAAK,KAAK,uBAAuB;AAAA,EACzC;AAAA,EAEO,aAAiC;AACvC,WAAO,KAAK,KAAK,WAAW;AAAA,EAC7B;AAAA,EAEO,gBAAoC;AAC1C,WAAO,KAAK,KAAK,cAAc;AAAA,EAChC;AAAA,EAEO,eAAmC;AACzC,WAAO,KAAK,KAAK,aAAa;AAAA,EAC/B;AAAA,EAEO,uBAA2C;AACjD,WAAO,KAAK,KAAK,qBAAqB;AAAA,EACvC;AAAA,EAEO,uBAA2C;AACjD,WAAO,KAAK,KAAK,qBAAqB;AAAA,EACvC;AAAA,EAEO,aAAiC;AACvC,WAAO,KAAK,KAAK,WAAW;AAAA,EAC7B;AAAA,EAEO,YAAqB;AAC3B,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,aAAsB;AAC5B,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,iBAA0B;AAChC,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,mBAA2B;AACjC,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,uBAA+B;AACrC,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,eAAiC;AACvC,WAAO,KAAK,KAAK,aAAa;AAAA,EAC/B;AAAA,EAEO,cAAsB;AAC5B,WAAO,KAAK,KAAK;AAAA,EAClB;AAAA,EAEO,eAAmC;AACzC,WAAO,KAAK,KAAK,aAAa;AAAA,EAC/B;AAAA,EAEO,oBAAwC;AAC9C,WAAO,KAAK,KAAK,kBAAkB;AAAA,EACpC;AAAA,EAEO,iBAA0B;AAChC,WAAO,KAAK,KAAK;AAAA,EAClB;AACD;AAoQO,IAAK,kBAAL,kBAAKA,qBAAL;AAMN,EAAAA,kCAAA;AAKA,EAAAA,kCAAA;AAXW,SAAAA;AAAA,GAAA;AAidL,IAAK,sBAAL,kBAAKC,yBAAL;AACN,EAAAA,0CAAA;AAAa,EAAAA,0CAAA;AADF,SAAAA;AAAA,GAAA;AAkiCZ,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": ["DelegationState", "NullHandlingOnOrder"]
}
