@aerokit/sdk 12.72.0 → 12.74.0

package/dist/cjs/bpm/process.js

@@ -17,11 +17,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var process_exports = {};
 __export(process_exports, {
+  BpmnError: () => BpmnError,
   Process: () => Process
 });
 module.exports = __toCommonJS(process_exports);
 var import_values = require("@aerokit/sdk/bpm/values");
+const JBpmnError = Java.type("org.flowable.engine.delegate.BpmnError");
 const BpmFacade = Java.type("org.eclipse.dirigible.components.api.bpm.BpmFacade");
+class BpmnError {
+  constructor(code, message) {
+    return new JBpmnError(code, message);
+  }
+}
 class Process {
   /**
    * Starts a new process instance for a given process definition key.
@@ -117,9 +124,308 @@ class Process {
   static getExecutionContext() {
     return new ExecutionContext();
   }
+  /**
+   * Retrieves the current task context object, typically used within a task listener or service task.
+   *
+   * @returns A new instance of the `TaskContext` containing details about the current task.
+   */
+  static getTaskContext() {
+    return new TaskContext();
+  }
+}
+class VariableScope {
+  constructor(variableScope) {
+    this.variableScope = variableScope;
+  }
+  /**
+   * Returns all variables. This will include all variables of parent scopes too.
+   * @returns A Map of variable names (`string`) to variable values (`any`).
+   */
+  getVariables() {
+    const variables = this.variableScope.getVariables();
+    for (const [key, value] of variables) {
+      variables.set(key, import_values.Values.parseValue(value));
+    }
+    return variables;
+  }
+  /**
+   * Returns all variables, as instances of the {@link VariableInstance} interface, which gives more information than only the value (type, execution id, etc.)
+   * @returns A Map of variable names (`string`) to {@link VariableInstance} objects (Java type).
+   */
+  getVariableInstances() {
+    return this.variableScope.getVariableInstances();
+  }
+  /**
+   * Returns the variable local to this scope only. So, in contrary to {@link #getVariables()}, the variables from the parent scope won't be returned.
+   * @returns A Map of variable names (`string`) to local variable values (`any`).
+   */
+  getVariablesLocal() {
+    const variablesLocal = this.variableScope.getVariablesLocal();
+    for (const [key, value] of variablesLocal) {
+      variablesLocal.set(key, import_values.Values.parseValue(value));
+    }
+    return variablesLocal;
+  }
+  /**
+   * Returns the variables local to this scope as instances of the {@link VariableInstance} interface, which provided additional information about the variable.
+   * @returns A Map of variable names (`string`) to local {@link VariableInstance} objects (Java type).
+   */
+  getVariableInstancesLocal() {
+    return this.variableScope.getVariableInstancesLocal();
+  }
+  /**
+   * Returns the variable value for one specific variable. Will look in parent scopes when the variable does not exist on this particular scope.
+   * @param variableName The name of the variable to retrieve.
+   * @returns The value of the variable (`any`), or `null` if not found.
+   */
+  getVariable(variableName) {
+    return import_values.Values.parseValue(this.variableScope.getVariable(variableName));
+  }
+  /**
+   * Similar to {@link #getVariable(String)}, but returns a {@link VariableInstance} instance, which contains more information than just the value.
+   * @param variableName The name of the variable to retrieve.
+   * @returns The {@link VariableInstance} object (Java type), or `null`.
+   */
+  getVariableInstance(variableName) {
+    return this.variableScope.getVariableInstance(variableName);
+  }
+  /**
+   * Returns the value for the specific variable and only checks this scope and not any parent scope.
+   * @param variableName The name of the local variable to retrieve.
+   * @returns The value of the local variable (`any`), or `null` if not found locally.
+   */
+  getVariableLocal(variableName) {
+    return import_values.Values.parseValue(this.variableScope.getVariableLocal(variableName));
+  }
+  /**
+   * Similar to {@link #getVariableLocal(String)}, but returns an instance of {@link VariableInstance}, which has some additional information beyond the value.
+   * @param variableName The name of the local variable to retrieve.
+   * @returns The local {@link VariableInstance} object (Java type), or `null`.
+   */
+  getVariableInstanceLocal(variableName) {
+    return this.variableScope.getVariableInstanceLocal(variableName);
+  }
+  /**
+   * Returns all the names of the variables for this scope and all parent scopes.
+   * @returns A Set of all variable names (`string`).
+   */
+  getVariableNames() {
+    const variableNames = /* @__PURE__ */ new Set();
+    for (const next of this.variableScope.getVariableNames().toArray()) {
+      variableNames.add(next);
+    }
+    return variableNames;
+  }
+  /**
+   * Returns all the names of the variables for this scope (no parent scopes).
+   * @returns A Set of local variable names (`string`).
+   */
+  getVariableNamesLocal() {
+    const variableNamesLocal = /* @__PURE__ */ new Set();
+    for (const next of this.variableScope.getVariableNamesLocal().toArray()) {
+      variableNamesLocal.add(next);
+    }
+    return variableNamesLocal;
+  }
+  /**
+   * Sets the variable with the provided name to the provided value. It checks parent scopes for an existing variable before setting on the current scope.
+   * @param variableName The name of the variable to be set.
+   * @param value The value of the variable to be set (`any`).
+   */
+  setVariable(variableName, value) {
+    this.variableScope.setVariable(variableName, import_values.Values.stringifyValue(value));
+  }
+  /**
+   * Similar to {@link #setVariable(String, Object)}, but the variable is set to this scope specifically (local variable).
+   * @param variableName The name of the variable to be set locally.
+   * @param value The value of the variable to be set (`any`).
+   * @returns The old value of the local variable (Java type), or `null`.
+   */
+  setVariableLocal(variableName, value) {
+    return this.variableScope.setVariableLocal(variableName, import_values.Values.stringifyValue(value));
+  }
+  /**
+   * Sets the provided variables to the variable scope, using the default scoping algorithm.
+   * @param variables A map of keys (`string`) and values (`any`) for the variables to be set.
+   */
+  setVariables(variables) {
+    for (const [key, value] of variables) {
+      variables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.variableScope.setVariables(variables);
+  }
+  /**
+   * Similar to {@link #setVariables(Map)}, but the variables are set on this scope specifically (local variables).
+   * @param variables A map of keys (`string`) and values (`any`) for the local variables to be set.
+   */
+  setVariablesLocal(variables) {
+    for (const [key, value] of variables) {
+      variables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.variableScope.setVariablesLocal(variables);
+  }
+  /**
+   * Returns whether this scope or any parent scope has variables.
+   * @returns `true` if variables exist in scope hierarchy, `false` otherwise.
+   */
+  hasVariables() {
+    return this.variableScope.hasVariables();
+  }
+  /**
+   * Returns whether this scope has variables.
+   * @returns `true` if local variables exist, `false` otherwise.
+   */
+  hasVariablesLocal() {
+    return this.variableScope.hasVariablesLocal();
+  }
+  /**
+   * Returns whether this scope or any parent scope has a specific variable.
+   * @param variableName The name of the variable to check.
+   * @returns `true` if the variable is found in the scope hierarchy, `false` otherwise.
+   */
+  hasVariable(variableName) {
+    return this.variableScope.hasVariable(variableName);
+  }
+  /**
+   * Returns whether this scope has a specific variable.
+   * @param variableName The name of the local variable to check.
+   * @returns `true` if the variable is found locally, `false` otherwise.
+   */
+  hasVariableLocal(variableName) {
+    return this.variableScope.hasVariableLocal(variableName);
+  }
+  /**
+   * Removes the variable from the process instance and creates a new HistoricVariableUpdate. Searches up the scope hierarchy.
+   * @param variableName The name of the variable to remove.
+   */
+  removeVariable(variableName) {
+    this.variableScope.removeVariable(variableName);
+  }
+  /**
+   * Removes the local variable and creates a new HistoricVariableUpdate.
+   * @param variableName The name of the local variable to remove.
+   */
+  removeVariableLocal(variableName) {
+    this.variableScope.removeVariableLocal(variableName);
+  }
+  /**
+   * Removes the variables and creates a new HistoricVariableUpdate for each of them. Searches up the scope hierarchy.
+   * @param variableNames An array of variable names (`string[]`) to remove.
+   */
+  removeVariables(variableNames) {
+    this.variableScope.removeVariables(variableNames);
+  }
+  /**
+   * Removes the local variables and creates a new HistoricVariableUpdate for each of them.
+   * @param variableNames An array of local variable names (`string[]`) to remove.
+   */
+  removeVariablesLocal(variableNames) {
+    this.variableScope.removeVariablesLocal(variableNames);
+  }
+  /**
+   * Sets a transient variable using the default scoping mechanism (up the hierarchy). Transient variables have no history and are cleared at wait states.
+   * @param variableName The name of the transient variable.
+   * @param variableValue The value of the transient variable (`any`).
+   */
+  setTransientVariable(variableName, variableValue) {
+    this.variableScope.setTransientVariable(variableName, import_values.Values.stringifyValue(variableValue));
+  }
+  /**
+   * Sets a local transient variable. Transient variables have no history and are cleared at wait states.
+   * @param variableName The name of the local transient variable.
+   * @param variableValue The value of the local transient variable (`any`).
+   */
+  setTransientVariableLocal(variableName, variableValue) {
+    this.variableScope.setTransientVariableLocal(variableName, import_values.Values.stringifyValue(variableValue));
+  }
+  /**
+   * Sets multiple transient variables using the default scoping mechanism (up the hierarchy).
+   * @param transientVariables A map of keys (`string`) and values (`any`) for the transient variables to be set.
+   */
+  setTransientVariables(transientVariables) {
+    for (const [key, value] of transientVariables) {
+      transientVariables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.variableScope.setTransientVariables(transientVariables);
+  }
+  /**
+   * Retrieves the value of a transient variable, searching up the parent scopes.
+   * @param variableName The name of the transient variable to retrieve.
+   * @returns The value of the transient variable (`any`), or `null` if not found.
+   */
+  getTransientVariable(variableName) {
+    return import_values.Values.parseValue(this.variableScope.getTransientVariable(variableName));
+  }
+  /**
+   * Retrieves all transient variables in the current scope hierarchy.
+   * @returns A Map of transient variable names (`string`) to values (`any`).
+   */
+  getTransientVariables() {
+    const transientVariables = this.variableScope.getTransientVariables();
+    for (const [key, value] of transientVariables) {
+      transientVariables.set(key, import_values.Values.parseValue(value));
+    }
+    return transientVariables;
+  }
+  /**
+   * Sets multiple local transient variables.
+   * @param transientVariables A map of keys (`string`) and values (`any`) for the local transient variables to be set.
+   */
+  setTransientVariablesLocal(transientVariables) {
+    for (const [key, value] of transientVariables) {
+      transientVariables.set(key, import_values.Values.stringifyValue(value));
+    }
+    this.variableScope.setTransientVariablesLocal(transientVariables);
+  }
+  /**
+   * Retrieves the value of a local transient variable.
+   * @param variableName The name of the local transient variable to retrieve.
+   * @returns The value of the local transient variable (`any`), or `null` if not found.
+   */
+  getTransientVariableLocal(variableName) {
+    return import_values.Values.parseValue(this.variableScope.getTransientVariableLocal(variableName));
+  }
+  /**
+   * Retrieves all local transient variables.
+   * @returns A Map of local transient variable names (`string`) to values (`any`).
+   */
+  getTransientVariablesLocal() {
+    const transientVariablesLocal = this.variableScope.getTransientVariablesLocal();
+    for (const [key, value] of transientVariablesLocal) {
+      transientVariablesLocal.set(key, import_values.Values.parseValue(value));
+    }
+    return transientVariablesLocal;
+  }
+  /**
+   * Removes a specific local transient variable.
+   * @param variableName The name of the local transient variable to remove.
+   */
+  removeTransientVariableLocal(variableName) {
+    this.variableScope.removeTransientVariableLocal(variableName);
+  }
+  /**
+   * Removes a specific transient variable, searching up the scope hierarchy.
+   * @param variableName The name of the transient variable to remove.
+   */
+  removeTransientVariable(variableName) {
+    this.variableScope.removeTransientVariable(variableName);
+  }
+  /**
+   * Remove all transient variables of this scope and its parent scopes.
+   */
+  removeTransientVariables() {
+    this.variableScope.removeTransientVariables();
+  }
+  /**
+   * Removes all local transient variables.
+   */
+  removeTransientVariablesLocal() {
+    this.variableScope.removeTransientVariablesLocal();
+  }
 }
-class ExecutionContext {
+class ExecutionContext extends VariableScope {
   constructor() {
+    super(__context.get("execution"));
     this.execution = __context.get("execution");
   }
   /**
@@ -344,293 +650,422 @@ class ExecutionContext {
   setMultiInstanceRoot(isMultiInstanceRoot) {
     this.execution.setMultiInstanceRoot(isMultiInstanceRoot);
   }
+}
+var DelegationState = /* @__PURE__ */ ((DelegationState2) => {
+  DelegationState2[DelegationState2["PENDING"] = 0] = "PENDING";
+  DelegationState2[DelegationState2["RESOLVED"] = 1] = "RESOLVED";
+  return DelegationState2;
+})(DelegationState || {});
+class TaskContext extends VariableScope {
+  constructor() {
+    super(__context.get("task"));
+    this.task = __context.get("task");
+  }
   /**
-   * Returns all variables. This will include all variables of parent scopes too.
-   * @returns A Map of variable names (`string`) to variable values (`any`).
+   * DB id of the task.
+   * 
+   * @returns the unique ID of the current task.
    */
-  getVariables() {
-    const variables = this.execution.getVariables();
-    for (const [key, value] of variables) {
-      variables.set(key, import_values.Values.parseValue(value));
-    }
-    return variables;
+  getId() {
+    return this.task.getId();
   }
   /**
-   * Returns all variables, as instances of the {@link VariableInstance} interface, which gives more information than only the value (type, execution id, etc.)
-   * @returns A Map of variable names (`string`) to {@link VariableInstance} objects (Java type).
+   * Name or title of the task.
+   * 
+   * @returns the name of the current task.
    */
-  getVariableInstances() {
-    return this.execution.getVariableInstances();
+  getName() {
+    return this.task.getName();
   }
   /**
-   * Returns the variable local to this scope only. So, in contrary to {@link #getVariables()}, the variables from the parent scope won't be returned.
-   * @returns A Map of variable names (`string`) to local variable values (`any`).
+   * Change the name of the task.
+   * 
+   * @param name the new name for the task.
    */
-  getVariablesLocal() {
-    const variablesLocal = this.execution.getVariablesLocal();
-    for (const [key, value] of variablesLocal) {
-      variablesLocal.set(key, import_values.Values.parseValue(value));
-    }
-    return variablesLocal;
+  setName(name) {
+    this.task.setName(name);
   }
   /**
-   * Returns the variables local to this scope as instances of the {@link VariableInstance} interface, which provided additional information about the variable.
-   * @returns A Map of variable names (`string`) to local {@link VariableInstance} objects (Java type).
+   * Get the free text description of the task.
+   * 
+   * @returns the description of the current task.
    */
-  getVariableInstancesLocal() {
-    return this.execution.getVariableInstancesLocal();
+  getDescription() {
+    return this.task.getDescription();
   }
   /**
-   * Returns the variable value for one specific variable. Will look in parent scopes when the variable does not exist on this particular scope.
-   * @param variableName The name of the variable to retrieve.
-   * @returns The value of the variable (`any`), or `null` if not found.
+   * Free text description of the task.
+   * 
+   * @param description the new description for the task.
    */
-  getVariable(variableName) {
-    return import_values.Values.parseValue(this.execution.getVariable(variableName));
+  setDescription(description) {
+    this.task.setDescription(description);
   }
   /**
-   * Similar to {@link #getVariable(String)}, but returns a {@link VariableInstance} instance, which contains more information than just the value.
-   * @param variableName The name of the variable to retrieve.
-   * @returns The {@link VariableInstance} object (Java type), or `null`.
+   * Indication of how important/urgent this task is with a number between 0 and 100 where higher values mean a higher priority and lower values mean lower priority: [0..19] lowest, [20..39] low,
+   * [40..59] normal, [60..79] high [80..100] highest
+   * 
+   * @returns the priority of the current task.
    */
-  getVariableInstance(variableName) {
-    return this.execution.getVariableInstance(variableName);
+  getPriority() {
+    return this.task.getPriority();
   }
   /**
-   * Returns the value for the specific variable and only checks this scope and not any parent scope.
-   * @param variableName The name of the local variable to retrieve.
-   * @returns The value of the local variable (`any`), or `null` if not found locally.
+   * Indication of how important/urgent this task is with a number between 0 and 100 where higher values mean a higher priority and lower values mean lower priority: [0..19] lowest, [20..39] low,
+   * [40..59] normal, [60..79] high [80..100] highest
+   * 
+   * @param priority the new priority for the task, with a number between 0 and 100 where higher values mean a higher priority and lower values mean lower priority: [0..19] lowest, [20..39] low, [40..59] normal, 
    */
-  getVariableLocal(variableName) {
-    return import_values.Values.parseValue(this.execution.getVariableLocal(variableName));
+  setPriority(priority) {
+    this.task.setPriority(priority);
   }
   /**
-   * Similar to {@link #getVariableLocal(String)}, but returns an instance of {@link VariableInstance}, which has some additional information beyond the value.
-   * @param variableName The name of the local variable to retrieve.
-   * @returns The local {@link VariableInstance} object (Java type), or `null`.
+   * Refrence to the process instance this task is associated with, or `null` if the task is not related to a process instance.
+   * 
+   * @returns the ID of the process instance this task is associated with, or `null`.
    */
-  getVariableInstanceLocal(variableName) {
-    return this.execution.getVariableInstanceLocal(variableName);
+  getProcessInstanceId() {
+    return this.task.getProcessInstanceId();
   }
   /**
-   * Returns all the names of the variables for this scope and all parent scopes.
-   * @returns A Set of all variable names (`string`).
+   * Reference to the path of execution this task is associated with, or `null` if the task is not related to a process instance.
+   * 
+   * @returns the ID of the execution this task is associated with, or `null`.
    */
-  getVariableNames() {
-    const variableNames = /* @__PURE__ */ new Set();
-    for (const next of this.execution.getVariableNames().toArray()) {
-      variableNames.add(next);
-    }
-    return variableNames;
+  getExecutionId() {
+    return this.task.getExecutionId();
   }
   /**
-   * Returns all the names of the variables for this scope (no parent scopes).
-   * @returns A Set of local variable names (`string`).
+   * Reference to the process definition this task is associated with, or `null` if the task is not related to a process instance.
+   * 
+   * @returns the ID of the process definition this task is associated with, or `null`.
    */
-  getVariableNamesLocal() {
-    const variableNamesLocal = /* @__PURE__ */ new Set();
-    for (const next of this.execution.getVariableNamesLocal().toArray()) {
-      variableNamesLocal.add(next);
-    }
-    return variableNamesLocal;
+  getProcessDefinitionId() {
+    return this.task.getProcessDefinitionId();
   }
   /**
-   * Sets the variable with the provided name to the provided value. It checks parent scopes for an existing variable before setting on the current scope.
-   * @param variableName The name of the variable to be set.
-   * @param value The value of the variable to be set (`any`).
+   * The current state of the task.
+   * 
+   * @returns the state of the current task.
    */
-  setVariable(variableName, value) {
-    this.execution.setVariable(variableName, import_values.Values.stringifyValue(value));
+  getState() {
+    return this.task.getState();
   }
   /**
-   * Similar to {@link #setVariable(String, Object)}, but the variable is set to this scope specifically (local variable).
-   * @param variableName The name of the variable to be set locally.
-   * @param value The value of the variable to be set (`any`).
-   * @returns The old value of the local variable (Java type), or `null`.
+   * The date/time when this task was created.
+   * 
+   * @returns the creation time of the current task.
    */
-  setVariableLocal(variableName, value) {
-    return this.execution.setVariableLocal(variableName, import_values.Values.stringifyValue(value));
+  getCreateTime() {
+    return this.task.getCreateTime();
   }
   /**
-   * Sets the provided variables to the variable scope, using the default scoping algorithm.
-   * @param variables A map of keys (`string`) and values (`any`) for the variables to be set.
+   * The date/time when this task was put in progress.
+   * 
+   * @returns the in progress start time of the current task.
    */
-  setVariables(variables) {
-    for (const [key, value] of variables) {
-      variables.set(key, import_values.Values.stringifyValue(value));
-    }
-    this.execution.setVariables(variables);
+  getInProgressStartTime() {
+    return this.task.getInProgressStartTime();
   }
   /**
-   * Similar to {@link #setVariables(Map)}, but the variables are set on this scope specifically (local variables).
-   * @param variables A map of keys (`string`) and values (`any`) for the local variables to be set.
+   * The user reference that started the task.
+   * 
+   * @returns the user reference that started the task.
    */
-  setVariablesLocal(variables) {
-    for (const [key, value] of variables) {
-      variables.set(key, import_values.Values.stringifyValue(value));
-    }
-    this.execution.setVariablesLocal(variables);
+  getInProgressStartedBy() {
+    return this.task.getInProgressStartedBy();
   }
   /**
-   * Returns whether this scope or any parent scope has variables.
-   * @returns `true` if variables exist in scope hierarchy, `false` otherwise.
+   * The date/time when this task was claimed.
+   * 
+   * @returns the claim time of the current task.
    */
-  hasVariables() {
-    return this.execution.hasVariables();
+  getClaimTime() {
+    return this.task.getClaimTime();
   }
   /**
-   * Returns whether this scope has variables.
-   * @returns `true` if local variables exist, `false` otherwise.
+   * The user reference that claimed the task.
+   * 
+   * @returns the user reference that claimed the task.
    */
-  hasVariablesLocal() {
-    return this.execution.hasVariablesLocal();
+  getClaimedBy() {
+    return this.task.getClaimedBy();
   }
   /**
-   * Returns whether this scope or any parent scope has a specific variable.
-   * @param variableName The name of the variable to check.
-   * @returns `true` if the variable is found in the scope hierarchy, `false` otherwise.
+   * The date/time when this task was suspended.
+   * 
+   * @returns the date/time when this task was suspended.
    */
-  hasVariable(variableName) {
-    return this.execution.hasVariable(variableName);
+  getSuspendedTime() {
+    return this.task.getSuspendedTime();
   }
   /**
-   * Returns whether this scope has a specific variable.
-   * @param variableName The name of the local variable to check.
-   * @returns `true` if the variable is found locally, `false` otherwise.
+   * The user reference that suspended the task.
+   * 
+   * @returns the user reference that suspended the task.
    */
-  hasVariableLocal(variableName) {
-    return this.execution.hasVariableLocal(variableName);
+  getSuspendedBy() {
+    return this.task.getSuspendedBy();
   }
   /**
-   * Removes the variable from the process instance and creates a new HistoricVariableUpdate. Searches up the scope hierarchy.
-   * @param variableName The name of the variable to remove.
+   * The id of the activity in the process defining this task or null if this is not related to a process.
+   * 
+   * @returns the task definition key.
    */
-  removeVariable(variableName) {
-    this.execution.removeVariable(variableName);
+  getTaskDefinitionKey() {
+    return this.task.getTaskDefinitionKey();
   }
   /**
-   * Removes the local variable and creates a new HistoricVariableUpdate.
-   * @param variableName The name of the local variable to remove.
+   * Indicated whether this task is suspended or not.
+   * 
+   * @returns `true` if the task is suspended, `false` otherwise.
    */
-  removeVariableLocal(variableName) {
-    this.execution.removeVariableLocal(variableName);
+  isSuspended() {
+    return this.task.isSuspended();
   }
   /**
-   * Removes the variables and creates a new HistoricVariableUpdate for each of them. Searches up the scope hierarchy.
-   * @param variableNames An array of variable names (`string[]`) to remove.
+   * The tenant identifier of this task, which is the same as the tenant identifier of the process definition and process instance this task is associated with (if any).
+   * 
+   * @returns the tenant ID of this task, or `null`/empty string if no tenant is associated.
    */
-  removeVariables(variableNames) {
-    this.execution.removeVariables(variableNames);
+  getTenantId() {
+    return this.task.getTenantId();
   }
   /**
-   * Removes the local variables and creates a new HistoricVariableUpdate for each of them.
-   * @param variableNames An array of local variable names (`string[]`) to remove.
+   * The form key for the user task, which is the same as the form key defined on the user task in the process definition. Will return `null` if this task is not a user task or if no form key is defined.
+   * 
+   * @returns the form key for the user task, or `null` if no form key is defined.
    */
-  removeVariablesLocal(variableNames) {
-    this.execution.removeVariablesLocal(variableNames);
+  getFormKey() {
+    return this.task.getFormKey();
   }
   /**
-   * Sets a transient variable using the default scoping mechanism (up the hierarchy). Transient variables have no history and are cleared at wait states.
-   * @param variableName The name of the transient variable.
-   * @param variableValue The value of the transient variable (`any`).
+   * Change the form key of the task.
+   * 
+   * @param formKey the new form key for the user task, or `null` to remove the form key
    */
-  setTransientVariable(variableName, variableValue) {
-    this.execution.setTransientVariable(variableName, import_values.Values.stringifyValue(variableValue));
+  setFormKey(formKey) {
+    this.task.setFormKey(formKey);
   }
   /**
-   * Sets a local transient variable. Transient variables have no history and are cleared at wait states.
-   * @param variableName The name of the local transient variable.
-   * @param variableValue The value of the local transient variable (`any`).
+   * The event name which triggered the task listener to fire for this task. Will return `null`/empty string if not executing a task listener.
+   * 
+   * @returns the event name which triggered the task listener to fire for this task, or `null`/empty string if not executing a task listener.
    */
-  setTransientVariableLocal(variableName, variableValue) {
-    this.execution.setTransientVariableLocal(variableName, import_values.Values.stringifyValue(variableValue));
+  getEventName() {
+    return this.task.getEventName();
   }
   /**
-   * Sets multiple transient variables using the default scoping mechanism (up the hierarchy).
-   * @param transientVariables A map of keys (`string`) and values (`any`) for the transient variables to be set.
+   * The event handler identifier which triggered the task listener to fire for this task. Will return `null`/empty string if not executing a task listener or if the event handler does not have an identifier.
+   * 
+   * @returns the event handler identifier, or `null`/empty string if not executing a task listener or if the event handler does not have an identifier.
    */
-  setTransientVariables(transientVariables) {
-    for (const [key, value] of transientVariables) {
-      transientVariables.set(key, import_values.Values.stringifyValue(value));
-    }
-    this.execution.setTransientVariables(transientVariables);
+  getEventHandlerId() {
+    return this.task.getEventHandlerId();
   }
   /**
-   * Retrieves the value of a transient variable, searching up the parent scopes.
-   * @param variableName The name of the transient variable to retrieve.
-   * @returns The value of the transient variable (`any`), or `null` if not found.
+   * The current delegation state of the task, which is `null` if the task is not delegated, `PENDING` if the task is delegated and waiting for resolution by the assignee, and `RESOLVED` if the task is delegated and has been resolved by the assignee but not yet completed by the owner.
+   * 
+   * @returns the delegation state of the task, which is `null` if the task is not delegated, `PENDING` if the task is delegated and waiting for resolution by the assignee, and `RESOLVED` if the task is delegated and has been resolved by the assignee but not yet completed by the owner.
    */
-  getTransientVariable(variableName) {
-    return import_values.Values.parseValue(this.execution.getTransientVariable(variableName));
+  getDelegationState() {
+    return this.task.getDelegationState();
   }
   /**
-   * Retrieves all transient variables in the current scope hierarchy.
-   * @returns A Map of transient variable names (`string`) to values (`any`).
+   * Adds a candidate user to this task, which means that the user is allowed to claim and work on this task. This does not mean that the user is the assignee of the task, but it means that the user is a candidate to become an assignee. The user will be able to see this task in their task list and claim it to become the assignee.
+   * 
+   * @param userId the user ID of the candidate user to add to this task.
    */
-  getTransientVariables() {
-    const transientVariables = this.execution.getTransientVariables();
-    for (const [key, value] of transientVariables) {
-      transientVariables.set(key, import_values.Values.parseValue(value));
-    }
-    return transientVariables;
+  addCandidateUser(userId) {
+    this.task.addCandidateUser(userId);
   }
   /**
-   * Sets multiple local transient variables.
-   * @param transientVariables A map of keys (`string`) and values (`any`) for the local transient variables to be set.
+   * Adds multiple users as candidate user to this task.
+   * 
+   * @param candidateUsers the collection of candidate user IDs to add to this task.
    */
-  setTransientVariablesLocal(transientVariables) {
-    for (const [key, value] of transientVariables) {
-      transientVariables.set(key, import_values.Values.stringifyValue(value));
-    }
-    this.execution.setTransientVariablesLocal(transientVariables);
+  addCandidateUsers(candidateUsers) {
+    this.task.addCandidateUsers(candidateUsers);
   }
   /**
-   * Retrieves the value of a local transient variable.
-   * @param variableName The name of the local transient variable to retrieve.
-   * @returns The value of the local transient variable (`any`), or `null` if not found.
+   * Adds a candidate group to this task, which means that all users that are members of this group are allowed to claim and work on this task. This does not mean that the group is the assignee of the task, but it means that all users that are members of the group are candidates to become assignees. The users that are members of the group will be able to see this task in their task list and claim it to become the assignee.
+   * 
+   * @param groupId the group ID of the candidate group to add to this task.
    */
-  getTransientVariableLocal(variableName) {
-    return import_values.Values.parseValue(this.execution.getTransientVariableLocal(variableName));
+  addCandidateGroup(groupId) {
+    this.task.addCandidateGroup(groupId);
   }
   /**
-   * Retrieves all local transient variables.
-   * @returns A Map of local transient variable names (`string`) to values (`any`).
+   * Adds multiple groups as candidate group to this task.
+   * 
+   * @param candidateGroups the collection of candidate group IDs to add to this task.
    */
-  getTransientVariablesLocal() {
-    const transientVariablesLocal = this.execution.getTransientVariablesLocal();
-    for (const [key, value] of transientVariablesLocal) {
-      transientVariablesLocal.set(key, import_values.Values.parseValue(value));
-    }
-    return transientVariablesLocal;
+  addCandidateGroups(candidateGroups) {
+    this.task.addCandidateGroups(candidateGroups);
   }
   /**
-   * Removes a specific local transient variable.
-   * @param variableName The name of the local transient variable to remove.
+   * The user id of the person responsible for this task. This is the user that has to work on this task and complete it. When a task is assigned to a user, that user becomes the assignee of the task. The assignee is the only one that can complete the task (unless the task is delegated
+   * 
+   * @returns the user ID of the assignee of this task
    */
-  removeTransientVariableLocal(variableName) {
-    this.execution.removeTransientVariableLocal(variableName);
+  getOwner() {
+    return this.task.getOwner();
   }
   /**
-   * Removes a specific transient variable, searching up the scope hierarchy.
-   * @param variableName The name of the transient variable to remove.
+   * The user id of the person responsible for this task. This is the user that has to work on this task and complete it. When a task is assigned to a user, that user becomes the assignee of the task. The assignee is the only one that can complete the task (unless the task is delegated
+   * 
+   * @param owner the user ID of the assignee of this task
    */
-  removeTransientVariable(variableName) {
-    this.execution.removeTransientVariable(variableName);
+  setOwner(owner) {
+    this.task.setOwner(owner);
   }
   /**
-   * Remove all transient variables of this scope and its parent scopes.
+   * The user id of the person to which this task is delegated.
+   * 
+   * @returns the user ID of the assignee of this task
    */
-  removeTransientVariables() {
-    this.execution.removeTransientVariables();
+  getAssignee() {
+    return this.task.getAssignee();
   }
   /**
-   * Removes all local transient variables.
+   * The user id of the person to which this task is delegated.
+   * @param assignee the user ID of the assignee of this task
    */
-  removeTransientVariablesLocal() {
-    this.execution.removeTransientVariablesLocal();
+  setAssignee(assignee) {
+    this.task.setAssignee(assignee);
+  }
+  /**
+   * Due date of the in progress start of the task.
+   * 
+   * @returns the due date of the in progress start of the task.
+   */
+  getInProgressStartDueDate() {
+    return this.task.getInProgressStartDueDate();
+  }
+  /**
+   * Change the in progress start due date of the task.
+   * 
+   * @param inProgressStartDueDate the new due date of the in progress start of the task.
+   */
+  setInProgressStartDueDate(inProgressStartDueDate) {
+    this.task.setInProgressStartDueDate(inProgressStartDueDate);
+  }
+  /**
+   * Due date of the task.
+   * 
+   * @returns the due date of the task.
+   */
+  getDueDate() {
+    return this.task.getDueDate();
+  }
+  /**
+   * Change the due date of the task.
+   * 
+   * @param dueDate the new due date of the task.
+   */
+  setDueDate(dueDate) {
+    this.task.setDueDate(dueDate);
+  }
+  /**
+   * The category of the task. This is an optional field and allows to 'tag' tasks as belonging to a certain category.
+   * 
+   * @returns the category of the task
+   */
+  getCategory() {
+    return this.task.getCategory();
+  }
+  /**
+   * Change the category of the task. This is an optional field and allows to 'tag' tasks as belonging to a certain category.
+   * 
+   * @param category the new category of the task
+   */
+  setCategory(category) {
+    this.task.setCategory(category);
+  }
+  /**
+   * Involves a user with a task. The type of identity link is defined by the given identityLinkType.
+   *
+   * @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(userId, identityLinkType) {
+    this.task.addUserIdentityLink(userId, identityLinkType);
+  }
+  /**
+   * Involves a group with group task. The type of identityLink is defined by the given identityLink.
+   *
+   * @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(groupId, identityLinkType) {
+    this.task.addGroupIdentityLink(groupId, identityLinkType);
+  }
+  /**
+   * Convenience shorthand for {@link #deleteUserIdentityLink(String, String)} ; with type {@link IdentityLinkType#CANDIDATE}
+   *
+   * @param userId
+   *            id of the user to use as candidate, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or user doesn't exist.
+   */
+  deleteCandidateUser(userId) {
+    this.task.deleteCandidateUser(userId);
+  }
+  /**
+   * Convenience shorthand for {@link #deleteGroupIdentityLink(String, String)}; with type {@link IdentityLinkType#CANDIDATE}
+   *
+   * @param groupId
+   *            id of the group to use as candidate, cannot be null.
+   * @throws FlowableObjectNotFoundException
+   *             when the task or group doesn't exist.
+   */
+  deleteCandidateGroup(groupId) {
+    this.task.deleteCandidateGroup(groupId);
+  }
+  /**
+      * Removes the association between a user and a task for the given identityLinkType.
+      *
+      * @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(userId, identityLinkType) {
+    this.task.deleteUserIdentityLink(userId, identityLinkType);
+  }
+  /**
+   * Removes the association between a group and a task for the given identityLinkType.
+   *
+   * @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(groupId, identityLinkType) {
+    this.task.deleteGroupIdentityLink(groupId, identityLinkType);
+  }
+  /**
+   * Retrieves the candidate users and groups associated with the task.
+   *
+   * @return set of {@link IdentityLink}s of type {@link IdentityLinkType#CANDIDATE}.
+   */
+  getCandidates() {
+    return this.task.getCandidates();
   }
 }
 if (typeof module !== "undefined") {
   module.exports = Process;
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/bpm/process.ts"],
  "sourcesContent": ["/**\n * API Process\n * * Provides methods for interacting with process instances,\n * including starting, updating metadata, and managing variables.\n */\n\nimport { Values } from \"@aerokit/sdk/bpm/values\";\n\nconst BpmFacade = Java.type(\"org.eclipse.dirigible.components.api.bpm.BpmFacade\");\n\nexport class Process {\n\n\t/**\n\t * Starts a new process instance for a given process definition key.\n\t *\n\t * @param key The process definition key (ID) of the process to start.\n\t * @param businessKey An optional business key to associate with the process instance. Defaults to an empty string.\n\t * @param parameters An optional map of process variables to pass to the process instance upon starting. Defaults to an empty object.\n\t * @returns The unique ID of the newly started process instance.\n\t */\n\tpublic static start(key: string, businessKey: string = '', parameters: { [key: string]: any } = {}): string {\n\t\treturn BpmFacade.startProcess(key, businessKey, JSON.stringify(parameters));\n\t}\n\n\t/**\n\t * Sets a human-readable name for an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param name The new name for the process instance.\n\t */\n\tpublic static setProcessInstanceName(processInstanceId: string, name: string): void {\n\t\tBpmFacade.setProcessInstanceName(processInstanceId, name);\n\t}\n\n\t/**\n\t * Updates the business key of an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param businessKey The new business key.\n\t */\n\tpublic static updateBusinessKey(processInstanceId: string, businessKey: string): void {\n\t\tBpmFacade.updateBusinessKey(processInstanceId, businessKey);\n\t}\n\n\t/**\n\t * Updates the business status of an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param businessStatus The new business status.\n\t */\n\tpublic static updateBusinessStatus(processInstanceId: string, businessStatus: string): void {\n\t\tBpmFacade.updateBusinessStatus(processInstanceId, businessStatus);\n\t}\n\n\t/**\n\t * Retrieves the value of a specific variable from a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The value of the variable, or `null` if the variable does not exist. The type is `any` as it depends on the stored value.\n\t */\n\tpublic static getVariable(processInstanceId: string, variableName: string): any {\n\t\treturn BpmFacade.getVariable(processInstanceId, variableName);\n\t}\n\n\t/**\n\t * Retrieves all variables associated with a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @returns An object containing all variables for the process instance, where keys are variable names and values are the variable values.\n\t */\n\tpublic static getVariables(processInstanceId: string): any {\n\t\treturn BpmFacade.getVariables(processInstanceId);\n\t}\n\n\t/**\n\t * Sets or updates the value of a variable in a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to set.\n\t * @param value The new value for the variable. The type is `any` to accommodate different data types.\n\t */\n\tpublic static setVariable(processInstanceId: string, variableName: string, value: any): void {\n\t\tBpmFacade.setVariable(processInstanceId, variableName, value);\n\t}\n\n\t/**\n\t * Removes a variable from a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to remove.\n\t */\n\tpublic static removeVariable(processInstanceId: string, variableName: string): void {\n\t\tBpmFacade.removeVariable(processInstanceId, variableName);\n\t}\n\n\t/**\n\t * Correlates a message event with a running process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to correlate the message to.\n\t * @param messageName The name of the message event defined in the BPMN process.\n\t * @param variables A map of variables (`Map<string, any>`) to pass along with the message event.\n\t */\n\tpublic static correlateMessageEvent(processInstanceId: string, messageName: string, variables: Map<string, any>): void {\n\t\tBpmFacade.correlateMessageEvent(processInstanceId, messageName, Values.stringifyValuesMap(variables));\n\t}\n\n\t/**\n\t * Retrieves the current execution context object, typically used within an execution listener or service task.\n\t *\n\t * @returns A new instance of the `ExecutionContext` containing details about the current process execution path.\n\t */\n\tpublic static getExecutionContext() {\n\t\treturn new ExecutionContext();\n\t}\n}\n\n/**\n * ExecutionContext object\n * * Provides detailed information and control over the current process execution path.\n */\nclass ExecutionContext {\n\n\tprivate execution: any;\n\n\tconstructor() {\n\t\tthis.execution = __context.get('execution');\n\t}\n\n\t/**\n\t * Unique id of this path of execution that can be used as a handle to provide external signals back into the engine after wait states.\n\t *\n\t * @returns The unique ID of the current execution.\n\t */\n\tpublic getId(): string {\n\t\treturn this.execution.getId();\n\t}\n\n\t/**\n\t * Reference to the overall process instance.\n\t * @returns The ID of the process instance.\n\t */\n\tpublic getProcessInstanceId(): string {\n\t\treturn this.execution.getProcessInstanceId();\n\t}\n\n\t/**\n\t * The 'root' process instance. When using call activity for example, the processInstance set will not always be the root. This method returns the topmost process instance.\n\t *\n\t * @returns The ID of the root process instance.\n\t */\n\tpublic getRootProcessInstanceId(): string {\n\t\treturn this.execution.getRootProcessInstanceId();\n\t}\n\n\t/**\n\t * Will contain the event name in case this execution is passed in for an {@link ExecutionListener}.\n\t * @returns The current event name, or `null`/empty string if not executing an event listener.\n\t */\n\tpublic getEventName(): string {\n\t\treturn this.execution.getEventName();\n\t}\n\n\t/**\n\t * Sets the current event (typically when execution an {@link ExecutionListener}).\n\t *\n\t * @param eventName The name of the event.\n\t */\n\tpublic setEventName(eventName: string): void {\n\t\tthis.execution.setEventName(eventName);\n\t}\n\n\t/**\n\t * The business key for the process instance this execution is associated with.\n\t * @returns The business key.\n\t */\n\tpublic getProcessInstanceBusinessKey(): string {\n\t\treturn this.execution.getProcessInstanceBusinessKey();\n\t}\n\n\t/**\n\t * The business status for the process instance this execution is associated with.\n\t * @returns The business status.\n\t */\n\tpublic getProcessInstanceBusinessStatus(): string {\n\t\treturn this.execution.getProcessInstanceBusinessStatus();\n\t}\n\n\t/**\n\t * The process definition key for the process instance this execution is associated with.\n\t * @returns The process definition ID.\n\t */\n\tpublic getProcessDefinitionId(): string {\n\t\treturn this.execution.getProcessDefinitionId();\n\t}\n\n\t/**\n\t * If this execution 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).\n\t *\n\t * @returns The stage instance id this execution belongs to or `null`, if this execution is not part of a case at all or is not a child element of a stage.\n\t */\n\tpublic getPropagatedStageInstanceId(): string {\n\t\treturn this.execution.getPropagatedStageInstanceId();\n\t}\n\n\t/**\n\t * Gets the id of the parent of this execution. If null, the execution represents a process-instance.\n\t * @returns The parent execution ID, or `null`.\n\t */\n\tpublic getParentId(): string {\n\t\treturn this.execution.getParentId();\n\t}\n\n\t/**\n\t * Gets the id of the calling execution. If not null, the execution is part of a subprocess.\n\t * @returns The super execution ID, or `null`.\n\t */\n\tpublic getSuperExecutionId(): string {\n\t\treturn this.execution.getSuperExecutionId();\n\t}\n\n\t/**\n\t * Gets the id of the current activity.\n\t * @returns The current activity ID.\n\t */\n\tpublic getCurrentActivityId(): string {\n\t\treturn this.execution.getCurrentActivityId();\n\t}\n\n\t/**\n\t * Returns the tenant id, if any is set before on the process definition or process instance.\n\t * @returns The tenant ID, or `null`/empty string.\n\t */\n\tpublic getTenantId(): string {\n\t\treturn this.execution.getTenantId();\n\t}\n\n\t/**\n\t * The BPMN element where the execution currently is at.\n\t * @returns The current flow element object (type is Java object).\n\t */\n\tpublic getCurrentFlowElement(): any {\n\t\treturn this.execution.getCurrentFlowElement();\n\t}\n\n\t/**\n\t * Change the current BPMN element the execution is at.\n\t * @param flowElement The new flow element object (Java type).\n\t */\n\tpublic setCurrentFlowElement(flowElement: any): void {\n\t\tthis.execution.setCurrentFlowElement(flowElement);\n\t}\n\n\t/**\n\t * Returns the {@link FlowableListener} instance matching an {@link ExecutionListener} if currently an execution listener is being execution. Returns null otherwise.\n\t * @returns The current Flowable Listener object (Java type), or `null`.\n\t */\n\tpublic getCurrentFlowableListener(): any {\n\t\treturn this.execution.getCurrentFlowableListener();\n\t}\n\n\t/**\n\t * Called when an {@link ExecutionListener} is being executed.\n\t * @param currentListener The current listener object (Java type).\n\t */\n\tpublic setCurrentFlowableListener(currentListener: any): void {\n\t\tthis.execution.setCurrentFlowableListener(currentListener);\n\t}\n\n\t/**\n\t * Create a snapshot read only delegate execution of this delegate execution.\n\t *\n\t * @returns A {@link ReadOnlyDelegateExecution} object (Java type).\n\t */\n\tpublic snapshotReadOnly(): any {\n\t\treturn this.execution.snapshotReadOnly();\n\t}\n\n\t/**\n\t * returns the parent of this execution, or null if there no parent.\n\t * @returns The parent execution object (Java type), or `null`.\n\t */\n\tpublic getParent(): any {\n\t\treturn this.execution.getParent();\n\t}\n\n\t/**\n\t * returns the list of execution of which this execution the parent of.\n\t * @returns An array of child execution objects (Java type).\n\t */\n\tpublic getExecutions(): any[] {\n\t\treturn this.execution.getExecutions();\n\t}\n\n\t/**\n\t * makes this execution active or inactive.\n\t * @param isActive A boolean indicating whether the execution should be active.\n\t */\n\tpublic setActive(isActive: boolean): void {\n\t\tthis.execution.setActive(isActive);\n\t}\n\n\t/**\n\t * returns whether this execution is currently active.\n\t * @returns `true` if active, `false` otherwise.\n\t */\n\tpublic isActive(): boolean {\n\t\treturn this.execution.isActive();\n\t}\n\n\t/**\n\t * returns whether this execution has ended or not.\n\t * @returns `true` if ended, `false` otherwise.\n\t */\n\tpublic isEnded(): boolean {\n\t\treturn this.execution.isEnded();\n\t}\n\n\t/**\n\t * changes the concurrent indicator on this execution.\n\t * @param isConcurrent A boolean indicating whether the execution should be concurrent.\n\t */\n\tpublic setConcurrent(isConcurrent: boolean): void {\n\t\tthis.execution.setConcurrent(isConcurrent);\n\t}\n\n\t/**\n\t * returns whether this execution is concurrent or not.\n\t * @returns `true` if concurrent, `false` otherwise.\n\t */\n\tpublic isConcurrent(): boolean {\n\t\treturn this.execution.isConcurrent();\n\t}\n\n\t/**\n\t * returns whether this execution is a process instance or not.\n\t * @returns `true` if it's a process instance, `false` otherwise.\n\t */\n\tpublic isProcessInstanceType(): boolean {\n\t\treturn this.execution.isProcessInstanceType();\n\t}\n\n\t/**\n\t * Inactivates this execution. This is useful for example in a join: the execution still exists, but it is not longer active.\n\t */\n\tpublic inactivate(): void {\n\t\tthis.execution.inactivate();\n\t}\n\n\t/**\n\t * Returns whether this execution is a scope.\n\t * @returns `true` if it is a scope, `false` otherwise.\n\t */\n\tpublic isScope(): boolean {\n\t\treturn this.execution.isScope();\n\t}\n\n\t/**\n\t * Changes whether this execution is a scope or not.\n\t * @param isScope A boolean indicating whether the execution should be a scope.\n\t */\n\tpublic setScope(isScope: boolean): void {\n\t\tthis.execution.setScope(isScope);\n\t}\n\n\t/**\n\t * Returns whether this execution is the root of a multi instance execution.\n\t * @returns `true` if it's a multi instance root, `false` otherwise.\n\t */\n\tpublic isMultiInstanceRoot(): boolean {\n\t\treturn this.execution.isMultiInstanceRoot();\n\t}\n\n\t/**\n\t * Changes whether this execution is a multi instance root or not.\n\t * @param isMultiInstanceRoot A boolean indicating whether the execution is the root of a multi-instance execution.\n\t */\n\tpublic setMultiInstanceRoot(isMultiInstanceRoot: boolean): void {\n\t\tthis.execution.setMultiInstanceRoot(isMultiInstanceRoot);\n\t}\n\n\t/**\n\t * Returns all variables. This will include all variables of parent scopes too.\n\t * @returns A Map of variable names (`string`) to variable values (`any`).\n\t */\n\tpublic getVariables(): Map<string, any> {\n\t\tconst variables = this.execution.getVariables();\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn variables;\n\t}\n\n\t/**\n\t * Returns all variables, as instances of the {@link VariableInstance} interface, which gives more information than only the value (type, execution id, etc.)\n\t * @returns A Map of variable names (`string`) to {@link VariableInstance} objects (Java type).\n\t */\n\tpublic getVariableInstances(): Map<string, any> {\n\t\treturn this.execution.getVariableInstances();\n\t}\n\n\t/**\n\t * Returns the variable local to this scope only. So, in contrary to {@link #getVariables()}, the variables from the parent scope won't be returned.\n\t * @returns A Map of variable names (`string`) to local variable values (`any`).\n\t */\n\tpublic getVariablesLocal(): Map<string, any> {\n\t\tconst variablesLocal = this.execution.getVariablesLocal();\n\t\tfor (const [key, value] of variablesLocal) {\n\t\t\tvariablesLocal.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn variablesLocal;\n\t}\n\n\t/**\n\t * Returns the variables local to this scope as instances of the {@link VariableInstance} interface, which provided additional information about the variable.\n\t * @returns A Map of variable names (`string`) to local {@link VariableInstance} objects (Java type).\n\t */\n\tpublic getVariableInstancesLocal(): Map<string, any> {\n\t\treturn this.execution.getVariableInstancesLocal();\n\t}\n\n\t/**\n\t * Returns the variable value for one specific variable. Will look in parent scopes when the variable does not exist on this particular scope.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The value of the variable (`any`), or `null` if not found.\n\t */\n\tpublic getVariable(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getVariable(variableName));\n\t}\n\n\t/**\n\t * Similar to {@link #getVariable(String)}, but returns a {@link VariableInstance} instance, which contains more information than just the value.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The {@link VariableInstance} object (Java type), or `null`.\n\t */\n\tpublic getVariableInstance(variableName: string): any {\n\t\treturn this.execution.getVariableInstance(variableName);\n\t}\n\n\t/**\n\t * Returns the value for the specific variable and only checks this scope and not any parent scope.\n\t * @param variableName The name of the local variable to retrieve.\n\t * @returns The value of the local variable (`any`), or `null` if not found locally.\n\t */\n\tpublic getVariableLocal(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getVariableLocal(variableName));\n\t}\n\n\t/**\n\t * Similar to {@link #getVariableLocal(String)}, but returns an instance of {@link VariableInstance}, which has some additional information beyond the value.\n\t * @param variableName The name of the local variable to retrieve.\n\t * @returns The local {@link VariableInstance} object (Java type), or `null`.\n\t */\n\tpublic getVariableInstanceLocal(variableName: string): any {\n\t\treturn this.execution.getVariableInstanceLocal(variableName);\n\t}\n\n\t/**\n\t * Returns all the names of the variables for this scope and all parent scopes.\n\t * @returns A Set of all variable names (`string`).\n\t */\n\tpublic getVariableNames(): Set<string> {\n\t\tconst variableNames = new Set<string>();\n\t\tfor (const next of this.execution.getVariableNames().toArray()) {\n\t\t\tvariableNames.add(next);\n\t\t}\n\t\treturn variableNames;\n\t}\n\n\t/**\n\t * Returns all the names of the variables for this scope (no parent scopes).\n\t * @returns A Set of local variable names (`string`).\n\t */\n\tpublic getVariableNamesLocal(): Set<string> {\n\t\tconst variableNamesLocal = new Set<string>();\n\t\tfor (const next of this.execution.getVariableNamesLocal().toArray()) {\n\t\t\tvariableNamesLocal.add(next);\n\t\t}\n\t\treturn variableNamesLocal;\n\t}\n\n\t/**\n\t * Sets the variable with the provided name to the provided value. It checks parent scopes for an existing variable before setting on the current scope.\n\t * @param variableName The name of the variable to be set.\n\t * @param value The value of the variable to be set (`any`).\n\t */\n\tpublic setVariable(variableName: string, value: any): void {\n\t\tthis.execution.setVariable(variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * Similar to {@link #setVariable(String, Object)}, but the variable is set to this scope specifically (local variable).\n\t * @param variableName The name of the variable to be set locally.\n\t * @param value The value of the variable to be set (`any`).\n\t * @returns The old value of the local variable (Java type), or `null`.\n\t */\n\tpublic setVariableLocal(variableName: string, value: any): any {\n\t\treturn this.execution.setVariableLocal(variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * Sets the provided variables to the variable scope, using the default scoping algorithm.\n\t * @param variables A map of keys (`string`) and values (`any`) for the variables to be set.\n\t */\n\tpublic setVariables(variables: Map<string, any>): void {\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setVariables(variables);\n\t}\n\n\t/**\n\t * Similar to {@link #setVariables(Map)}, but the variables are set on this scope specifically (local variables).\n\t * @param variables A map of keys (`string`) and values (`any`) for the local variables to be set.\n\t */\n\tpublic setVariablesLocal(variables: Map<string, any>): void {\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setVariablesLocal(variables);\n\t}\n\n\t/**\n\t * Returns whether this scope or any parent scope has variables.\n\t * @returns `true` if variables exist in scope hierarchy, `false` otherwise.\n\t */\n\tpublic hasVariables(): boolean {\n\t\treturn this.execution.hasVariables();\n\t}\n\n\t/**\n\t * Returns whether this scope has variables.\n\t * @returns `true` if local variables exist, `false` otherwise.\n\t */\n\tpublic hasVariablesLocal(): boolean {\n\t\treturn this.execution.hasVariablesLocal();\n\t}\n\n\t/**\n\t * Returns whether this scope or any parent scope has a specific variable.\n\t * @param variableName The name of the variable to check.\n\t * @returns `true` if the variable is found in the scope hierarchy, `false` otherwise.\n\t */\n\tpublic hasVariable(variableName: string): boolean {\n\t\treturn this.execution.hasVariable(variableName);\n\t}\n\n\t/**\n\t * Returns whether this scope has a specific variable.\n\t * @param variableName The name of the local variable to check.\n\t * @returns `true` if the variable is found locally, `false` otherwise.\n\t */\n\tpublic hasVariableLocal(variableName: string): boolean {\n\t\treturn this.execution.hasVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes the variable from the process instance and creates a new HistoricVariableUpdate. Searches up the scope hierarchy.\n\t * @param variableName The name of the variable to remove.\n\t */\n\tpublic removeVariable(variableName: string): void {\n\t\tthis.execution.removeVariable(variableName);\n\t}\n\n\t/**\n\t * Removes the local variable and creates a new HistoricVariableUpdate.\n\t * @param variableName The name of the local variable to remove.\n\t */\n\tpublic removeVariableLocal(variableName: string): void {\n\t\tthis.execution.removeVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes the variables and creates a new HistoricVariableUpdate for each of them. Searches up the scope hierarchy.\n\t * @param variableNames An array of variable names (`string[]`) to remove.\n\t */\n\tpublic removeVariables(variableNames: string[]): void {\n\t\tthis.execution.removeVariables(variableNames);\n\t}\n\n\t/**\n\t * Removes the local variables and creates a new HistoricVariableUpdate for each of them.\n\t * @param variableNames An array of local variable names (`string[]`) to remove.\n\t */\n\tpublic removeVariablesLocal(variableNames: string[]): void {\n\t\tthis.execution.removeVariablesLocal(variableNames);\n\t}\n\n\t/**\n\t * Sets a transient variable using the default scoping mechanism (up the hierarchy). Transient variables have no history and are cleared at wait states.\n\t * @param variableName The name of the transient variable.\n\t * @param variableValue The value of the transient variable (`any`).\n\t */\n\tpublic setTransientVariable(variableName: string, variableValue: any): void {\n\t\tthis.execution.setTransientVariable(variableName, Values.stringifyValue(variableValue));\n\t}\n\n\t/**\n\t * Sets a local transient variable. Transient variables have no history and are cleared at wait states.\n\t * @param variableName The name of the local transient variable.\n\t * @param variableValue The value of the local transient variable (`any`).\n\t */\n\tpublic setTransientVariableLocal(variableName: string, variableValue: any): void {\n\t\tthis.execution.setTransientVariableLocal(variableName, Values.stringifyValue(variableValue));\n\t}\n\n\t/**\n\t * Sets multiple transient variables using the default scoping mechanism (up the hierarchy).\n\t * @param transientVariables A map of keys (`string`) and values (`any`) for the transient variables to be set.\n\t */\n\tpublic setTransientVariables(transientVariables: Map<string, any>): void {\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setTransientVariables(transientVariables);\n\t}\n\n\t/**\n\t * Retrieves the value of a transient variable, searching up the parent scopes.\n\t * @param variableName The name of the transient variable to retrieve.\n\t * @returns The value of the transient variable (`any`), or `null` if not found.\n\t */\n\tpublic getTransientVariable(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getTransientVariable(variableName));\n\t}\n\n\t/**\n\t * Retrieves all transient variables in the current scope hierarchy.\n\t * @returns A Map of transient variable names (`string`) to values (`any`).\n\t */\n\tpublic getTransientVariables(): Map<string, any> {\n\t\tconst transientVariables = this.execution.getTransientVariables();\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn transientVariables;\n\t}\n\n\t/**\n\t * Sets multiple local transient variables.\n\t * @param transientVariables A map of keys (`string`) and values (`any`) for the local transient variables to be set.\n\t */\n\tpublic setTransientVariablesLocal(transientVariables: Map<string, any>): void {\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.execution.setTransientVariablesLocal(transientVariables);\n\t}\n\n\t/**\n\t * Retrieves the value of a local transient variable.\n\t * @param variableName The name of the local transient variable to retrieve.\n\t * @returns The value of the local transient variable (`any`), or `null` if not found.\n\t */\n\tpublic getTransientVariableLocal(variableName: string): any {\n\t\treturn Values.parseValue(this.execution.getTransientVariableLocal(variableName));\n\t}\n\n\t/**\n\t * Retrieves all local transient variables.\n\t * @returns A Map of local transient variable names (`string`) to values (`any`).\n\t */\n\tpublic getTransientVariablesLocal(): Map<string, any> {\n\t\tconst transientVariablesLocal = this.execution.getTransientVariablesLocal();\n\t\tfor (const [key, value] of transientVariablesLocal) {\n\t\t\ttransientVariablesLocal.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn transientVariablesLocal;\n\t}\n\n\t/**\n\t * Removes a specific local transient variable.\n\t * @param variableName The name of the local transient variable to remove.\n\t */\n\tpublic removeTransientVariableLocal(variableName: string): void {\n\t\tthis.execution.removeTransientVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes a specific transient variable, searching up the scope hierarchy.\n\t * @param variableName The name of the transient variable to remove.\n\t */\n\tpublic removeTransientVariable(variableName: string): void {\n\t\tthis.execution.removeTransientVariable(variableName);\n\t}\n\n\t/**\n\t * Remove all transient variables of this scope and its parent scopes.\n\t */\n\tpublic removeTransientVariables(): void {\n\t\tthis.execution.removeTransientVariables();\n\t}\n\n\t/**\n\t * Removes all local transient variables.\n\t */\n\tpublic removeTransientVariablesLocal(): void {\n\t\tthis.execution.removeTransientVariablesLocal();\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Process;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/bpm/process.ts"],
  "sourcesContent": ["/**\n * API Process\n * * Provides methods for interacting with process instances,\n * including starting, updating metadata, and managing variables.\n */\n\nimport { Values } from \"@aerokit/sdk/bpm/values\";\nimport { IdentityLink } from \"./tasks\";\n\nconst JBpmnError = Java.type('org.flowable.engine.delegate.BpmnError');\nconst BpmFacade = Java.type(\"org.eclipse.dirigible.components.api.bpm.BpmFacade\");\n\nexport class BpmnError {\n\tconstructor(code: string, message?: string) {\n\t\treturn new JBpmnError(code, message);\n\t}\n}\n\nexport class Process {\n\n\t/**\n\t * Starts a new process instance for a given process definition key.\n\t *\n\t * @param key The process definition key (ID) of the process to start.\n\t * @param businessKey An optional business key to associate with the process instance. Defaults to an empty string.\n\t * @param parameters An optional map of process variables to pass to the process instance upon starting. Defaults to an empty object.\n\t * @returns The unique ID of the newly started process instance.\n\t */\n\tpublic static start(key: string, businessKey: string = '', parameters: { [key: string]: any } = {}): string {\n\t\treturn BpmFacade.startProcess(key, businessKey, JSON.stringify(parameters));\n\t}\n\n\t/**\n\t * Sets a human-readable name for an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param name The new name for the process instance.\n\t */\n\tpublic static setProcessInstanceName(processInstanceId: string, name: string): void {\n\t\tBpmFacade.setProcessInstanceName(processInstanceId, name);\n\t}\n\n\t/**\n\t * Updates the business key of an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param businessKey The new business key.\n\t */\n\tpublic static updateBusinessKey(processInstanceId: string, businessKey: string): void {\n\t\tBpmFacade.updateBusinessKey(processInstanceId, businessKey);\n\t}\n\n\t/**\n\t * Updates the business status of an existing process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to update.\n\t * @param businessStatus The new business status.\n\t */\n\tpublic static updateBusinessStatus(processInstanceId: string, businessStatus: string): void {\n\t\tBpmFacade.updateBusinessStatus(processInstanceId, businessStatus);\n\t}\n\n\t/**\n\t * Retrieves the value of a specific variable from a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The value of the variable, or `null` if the variable does not exist. The type is `any` as it depends on the stored value.\n\t */\n\tpublic static getVariable(processInstanceId: string, variableName: string): any {\n\t\treturn BpmFacade.getVariable(processInstanceId, variableName);\n\t}\n\n\t/**\n\t * Retrieves all variables associated with a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @returns An object containing all variables for the process instance, where keys are variable names and values are the variable values.\n\t */\n\tpublic static getVariables(processInstanceId: string): any {\n\t\treturn BpmFacade.getVariables(processInstanceId);\n\t}\n\n\t/**\n\t * Sets or updates the value of a variable in a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to set.\n\t * @param value The new value for the variable. The type is `any` to accommodate different data types.\n\t */\n\tpublic static setVariable(processInstanceId: string, variableName: string, value: any): void {\n\t\tBpmFacade.setVariable(processInstanceId, variableName, value);\n\t}\n\n\t/**\n\t * Removes a variable from a process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance.\n\t * @param variableName The name of the variable to remove.\n\t */\n\tpublic static removeVariable(processInstanceId: string, variableName: string): void {\n\t\tBpmFacade.removeVariable(processInstanceId, variableName);\n\t}\n\n\t/**\n\t * Correlates a message event with a running process instance.\n\t *\n\t * @param processInstanceId The ID of the process instance to correlate the message to.\n\t * @param messageName The name of the message event defined in the BPMN process.\n\t * @param variables A map of variables (`Map<string, any>`) to pass along with the message event.\n\t */\n\tpublic static correlateMessageEvent(processInstanceId: string, messageName: string, variables: Map<string, any>): void {\n\t\tBpmFacade.correlateMessageEvent(processInstanceId, messageName, Values.stringifyValuesMap(variables));\n\t}\n\n\t/**\n\t * Retrieves the current execution context object, typically used within an execution listener or service task.\n\t *\n\t * @returns A new instance of the `ExecutionContext` containing details about the current process execution path.\n\t */\n\tpublic static getExecutionContext() {\n\t\treturn new ExecutionContext();\n\t}\n\n\t/**\n\t * Retrieves the current task context object, typically used within a task listener or service task.\n\t *\n\t * @returns A new instance of the `TaskContext` containing details about the current task.\n\t */\n\tpublic static getTaskContext() {\n\t\treturn new TaskContext();\n\t}\n}\n\nclass VariableScope {\n\n\tprivate variableScope: any;\n\n\tconstructor(variableScope: any) {\n\t\tthis.variableScope = variableScope;\n\t}\n\n\t/**\n\t * Returns all variables. This will include all variables of parent scopes too.\n\t * @returns A Map of variable names (`string`) to variable values (`any`).\n\t */\n\tpublic getVariables(): Map<string, any> {\n\t\tconst variables = this.variableScope.getVariables();\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn variables;\n\t}\n\n\t/**\n\t * Returns all variables, as instances of the {@link VariableInstance} interface, which gives more information than only the value (type, execution id, etc.)\n\t * @returns A Map of variable names (`string`) to {@link VariableInstance} objects (Java type).\n\t */\n\tpublic getVariableInstances(): Map<string, any> {\n\t\treturn this.variableScope.getVariableInstances();\n\t}\n\n\t/**\n\t * Returns the variable local to this scope only. So, in contrary to {@link #getVariables()}, the variables from the parent scope won't be returned.\n\t * @returns A Map of variable names (`string`) to local variable values (`any`).\n\t */\n\tpublic getVariablesLocal(): Map<string, any> {\n\t\tconst variablesLocal = this.variableScope.getVariablesLocal();\n\t\tfor (const [key, value] of variablesLocal) {\n\t\t\tvariablesLocal.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn variablesLocal;\n\t}\n\n\t/**\n\t * Returns the variables local to this scope as instances of the {@link VariableInstance} interface, which provided additional information about the variable.\n\t * @returns A Map of variable names (`string`) to local {@link VariableInstance} objects (Java type).\n\t */\n\tpublic getVariableInstancesLocal(): Map<string, any> {\n\t\treturn this.variableScope.getVariableInstancesLocal();\n\t}\n\n\t/**\n\t * Returns the variable value for one specific variable. Will look in parent scopes when the variable does not exist on this particular scope.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The value of the variable (`any`), or `null` if not found.\n\t */\n\tpublic getVariable(variableName: string): any {\n\t\treturn Values.parseValue(this.variableScope.getVariable(variableName));\n\t}\n\n\t/**\n\t * Similar to {@link #getVariable(String)}, but returns a {@link VariableInstance} instance, which contains more information than just the value.\n\t * @param variableName The name of the variable to retrieve.\n\t * @returns The {@link VariableInstance} object (Java type), or `null`.\n\t */\n\tpublic getVariableInstance(variableName: string): any {\n\t\treturn this.variableScope.getVariableInstance(variableName);\n\t}\n\n\t/**\n\t * Returns the value for the specific variable and only checks this scope and not any parent scope.\n\t * @param variableName The name of the local variable to retrieve.\n\t * @returns The value of the local variable (`any`), or `null` if not found locally.\n\t */\n\tpublic getVariableLocal(variableName: string): any {\n\t\treturn Values.parseValue(this.variableScope.getVariableLocal(variableName));\n\t}\n\n\t/**\n\t * Similar to {@link #getVariableLocal(String)}, but returns an instance of {@link VariableInstance}, which has some additional information beyond the value.\n\t * @param variableName The name of the local variable to retrieve.\n\t * @returns The local {@link VariableInstance} object (Java type), or `null`.\n\t */\n\tpublic getVariableInstanceLocal(variableName: string): any {\n\t\treturn this.variableScope.getVariableInstanceLocal(variableName);\n\t}\n\n\t/**\n\t * Returns all the names of the variables for this scope and all parent scopes.\n\t * @returns A Set of all variable names (`string`).\n\t */\n\tpublic getVariableNames(): Set<string> {\n\t\tconst variableNames = new Set<string>();\n\t\tfor (const next of this.variableScope.getVariableNames().toArray()) {\n\t\t\tvariableNames.add(next);\n\t\t}\n\t\treturn variableNames;\n\t}\n\n\t/**\n\t * Returns all the names of the variables for this scope (no parent scopes).\n\t * @returns A Set of local variable names (`string`).\n\t */\n\tpublic getVariableNamesLocal(): Set<string> {\n\t\tconst variableNamesLocal = new Set<string>();\n\t\tfor (const next of this.variableScope.getVariableNamesLocal().toArray()) {\n\t\t\tvariableNamesLocal.add(next);\n\t\t}\n\t\treturn variableNamesLocal;\n\t}\n\n\t/**\n\t * Sets the variable with the provided name to the provided value. It checks parent scopes for an existing variable before setting on the current scope.\n\t * @param variableName The name of the variable to be set.\n\t * @param value The value of the variable to be set (`any`).\n\t */\n\tpublic setVariable(variableName: string, value: any): void {\n\t\tthis.variableScope.setVariable(variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * Similar to {@link #setVariable(String, Object)}, but the variable is set to this scope specifically (local variable).\n\t * @param variableName The name of the variable to be set locally.\n\t * @param value The value of the variable to be set (`any`).\n\t * @returns The old value of the local variable (Java type), or `null`.\n\t */\n\tpublic setVariableLocal(variableName: string, value: any): any {\n\t\treturn this.variableScope.setVariableLocal(variableName, Values.stringifyValue(value));\n\t}\n\n\t/**\n\t * Sets the provided variables to the variable scope, using the default scoping algorithm.\n\t * @param variables A map of keys (`string`) and values (`any`) for the variables to be set.\n\t */\n\tpublic setVariables(variables: Map<string, any>): void {\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.variableScope.setVariables(variables);\n\t}\n\n\t/**\n\t * Similar to {@link #setVariables(Map)}, but the variables are set on this scope specifically (local variables).\n\t * @param variables A map of keys (`string`) and values (`any`) for the local variables to be set.\n\t */\n\tpublic setVariablesLocal(variables: Map<string, any>): void {\n\t\tfor (const [key, value] of variables) {\n\t\t\tvariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.variableScope.setVariablesLocal(variables);\n\t}\n\n\t/**\n\t * Returns whether this scope or any parent scope has variables.\n\t * @returns `true` if variables exist in scope hierarchy, `false` otherwise.\n\t */\n\tpublic hasVariables(): boolean {\n\t\treturn this.variableScope.hasVariables();\n\t}\n\n\t/**\n\t * Returns whether this scope has variables.\n\t * @returns `true` if local variables exist, `false` otherwise.\n\t */\n\tpublic hasVariablesLocal(): boolean {\n\t\treturn this.variableScope.hasVariablesLocal();\n\t}\n\n\t/**\n\t * Returns whether this scope or any parent scope has a specific variable.\n\t * @param variableName The name of the variable to check.\n\t * @returns `true` if the variable is found in the scope hierarchy, `false` otherwise.\n\t */\n\tpublic hasVariable(variableName: string): boolean {\n\t\treturn this.variableScope.hasVariable(variableName);\n\t}\n\n\t/**\n\t * Returns whether this scope has a specific variable.\n\t * @param variableName The name of the local variable to check.\n\t * @returns `true` if the variable is found locally, `false` otherwise.\n\t */\n\tpublic hasVariableLocal(variableName: string): boolean {\n\t\treturn this.variableScope.hasVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes the variable from the process instance and creates a new HistoricVariableUpdate. Searches up the scope hierarchy.\n\t * @param variableName The name of the variable to remove.\n\t */\n\tpublic removeVariable(variableName: string): void {\n\t\tthis.variableScope.removeVariable(variableName);\n\t}\n\n\t/**\n\t * Removes the local variable and creates a new HistoricVariableUpdate.\n\t * @param variableName The name of the local variable to remove.\n\t */\n\tpublic removeVariableLocal(variableName: string): void {\n\t\tthis.variableScope.removeVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes the variables and creates a new HistoricVariableUpdate for each of them. Searches up the scope hierarchy.\n\t * @param variableNames An array of variable names (`string[]`) to remove.\n\t */\n\tpublic removeVariables(variableNames: string[]): void {\n\t\tthis.variableScope.removeVariables(variableNames);\n\t}\n\n\t/**\n\t * Removes the local variables and creates a new HistoricVariableUpdate for each of them.\n\t * @param variableNames An array of local variable names (`string[]`) to remove.\n\t */\n\tpublic removeVariablesLocal(variableNames: string[]): void {\n\t\tthis.variableScope.removeVariablesLocal(variableNames);\n\t}\n\n\t/**\n\t * Sets a transient variable using the default scoping mechanism (up the hierarchy). Transient variables have no history and are cleared at wait states.\n\t * @param variableName The name of the transient variable.\n\t * @param variableValue The value of the transient variable (`any`).\n\t */\n\tpublic setTransientVariable(variableName: string, variableValue: any): void {\n\t\tthis.variableScope.setTransientVariable(variableName, Values.stringifyValue(variableValue));\n\t}\n\n\t/**\n\t * Sets a local transient variable. Transient variables have no history and are cleared at wait states.\n\t * @param variableName The name of the local transient variable.\n\t * @param variableValue The value of the local transient variable (`any`).\n\t */\n\tpublic setTransientVariableLocal(variableName: string, variableValue: any): void {\n\t\tthis.variableScope.setTransientVariableLocal(variableName, Values.stringifyValue(variableValue));\n\t}\n\n\t/**\n\t * Sets multiple transient variables using the default scoping mechanism (up the hierarchy).\n\t * @param transientVariables A map of keys (`string`) and values (`any`) for the transient variables to be set.\n\t */\n\tpublic setTransientVariables(transientVariables: Map<string, any>): void {\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.variableScope.setTransientVariables(transientVariables);\n\t}\n\n\t/**\n\t * Retrieves the value of a transient variable, searching up the parent scopes.\n\t * @param variableName The name of the transient variable to retrieve.\n\t * @returns The value of the transient variable (`any`), or `null` if not found.\n\t */\n\tpublic getTransientVariable(variableName: string): any {\n\t\treturn Values.parseValue(this.variableScope.getTransientVariable(variableName));\n\t}\n\n\t/**\n\t * Retrieves all transient variables in the current scope hierarchy.\n\t * @returns A Map of transient variable names (`string`) to values (`any`).\n\t */\n\tpublic getTransientVariables(): Map<string, any> {\n\t\tconst transientVariables = this.variableScope.getTransientVariables();\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn transientVariables;\n\t}\n\n\t/**\n\t * Sets multiple local transient variables.\n\t * @param transientVariables A map of keys (`string`) and values (`any`) for the local transient variables to be set.\n\t */\n\tpublic setTransientVariablesLocal(transientVariables: Map<string, any>): void {\n\t\tfor (const [key, value] of transientVariables) {\n\t\t\ttransientVariables.set(key, Values.stringifyValue(value));\n\t\t}\n\t\tthis.variableScope.setTransientVariablesLocal(transientVariables);\n\t}\n\n\t/**\n\t * Retrieves the value of a local transient variable.\n\t * @param variableName The name of the local transient variable to retrieve.\n\t * @returns The value of the local transient variable (`any`), or `null` if not found.\n\t */\n\tpublic getTransientVariableLocal(variableName: string): any {\n\t\treturn Values.parseValue(this.variableScope.getTransientVariableLocal(variableName));\n\t}\n\n\t/**\n\t * Retrieves all local transient variables.\n\t * @returns A Map of local transient variable names (`string`) to values (`any`).\n\t */\n\tpublic getTransientVariablesLocal(): Map<string, any> {\n\t\tconst transientVariablesLocal = this.variableScope.getTransientVariablesLocal();\n\t\tfor (const [key, value] of transientVariablesLocal) {\n\t\t\ttransientVariablesLocal.set(key, Values.parseValue(value));\n\t\t}\n\t\treturn transientVariablesLocal;\n\t}\n\n\t/**\n\t * Removes a specific local transient variable.\n\t * @param variableName The name of the local transient variable to remove.\n\t */\n\tpublic removeTransientVariableLocal(variableName: string): void {\n\t\tthis.variableScope.removeTransientVariableLocal(variableName);\n\t}\n\n\t/**\n\t * Removes a specific transient variable, searching up the scope hierarchy.\n\t * @param variableName The name of the transient variable to remove.\n\t */\n\tpublic removeTransientVariable(variableName: string): void {\n\t\tthis.variableScope.removeTransientVariable(variableName);\n\t}\n\n\t/**\n\t * Remove all transient variables of this scope and its parent scopes.\n\t */\n\tpublic removeTransientVariables(): void {\n\t\tthis.variableScope.removeTransientVariables();\n\t}\n\n\t/**\n\t * Removes all local transient variables.\n\t */\n\tpublic removeTransientVariablesLocal(): void {\n\t\tthis.variableScope.removeTransientVariablesLocal();\n\t}\n}\n\n/**\n * ExecutionContext object\n * * Provides detailed information and control over the current process execution path.\n */\nclass ExecutionContext extends VariableScope {\n\n\tprivate execution: any;\n\n\tconstructor() {\n\t\tsuper(__context.get('execution'));\n\t\tthis.execution = __context.get('execution');\n\t}\n\n\t/**\n\t * Unique id of this path of execution that can be used as a handle to provide external signals back into the engine after wait states.\n\t *\n\t * @returns The unique ID of the current execution.\n\t */\n\tpublic getId(): string {\n\t\treturn this.execution.getId();\n\t}\n\n\t/**\n\t * Reference to the overall process instance.\n\t * @returns The ID of the process instance.\n\t */\n\tpublic getProcessInstanceId(): string {\n\t\treturn this.execution.getProcessInstanceId();\n\t}\n\n\t/**\n\t * The 'root' process instance. When using call activity for example, the processInstance set will not always be the root. This method returns the topmost process instance.\n\t *\n\t * @returns The ID of the root process instance.\n\t */\n\tpublic getRootProcessInstanceId(): string {\n\t\treturn this.execution.getRootProcessInstanceId();\n\t}\n\n\t/**\n\t * Will contain the event name in case this execution is passed in for an {@link ExecutionListener}.\n\t * @returns The current event name, or `null`/empty string if not executing an event listener.\n\t */\n\tpublic getEventName(): string {\n\t\treturn this.execution.getEventName();\n\t}\n\n\t/**\n\t * Sets the current event (typically when execution an {@link ExecutionListener}).\n\t *\n\t * @param eventName The name of the event.\n\t */\n\tpublic setEventName(eventName: string): void {\n\t\tthis.execution.setEventName(eventName);\n\t}\n\n\t/**\n\t * The business key for the process instance this execution is associated with.\n\t * @returns The business key.\n\t */\n\tpublic getProcessInstanceBusinessKey(): string {\n\t\treturn this.execution.getProcessInstanceBusinessKey();\n\t}\n\n\t/**\n\t * The business status for the process instance this execution is associated with.\n\t * @returns The business status.\n\t */\n\tpublic getProcessInstanceBusinessStatus(): string {\n\t\treturn this.execution.getProcessInstanceBusinessStatus();\n\t}\n\n\t/**\n\t * The process definition key for the process instance this execution is associated with.\n\t * @returns The process definition ID.\n\t */\n\tpublic getProcessDefinitionId(): string {\n\t\treturn this.execution.getProcessDefinitionId();\n\t}\n\n\t/**\n\t * If this execution 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).\n\t *\n\t * @returns The stage instance id this execution belongs to or `null`, if this execution is not part of a case at all or is not a child element of a stage.\n\t */\n\tpublic getPropagatedStageInstanceId(): string {\n\t\treturn this.execution.getPropagatedStageInstanceId();\n\t}\n\n\t/**\n\t * Gets the id of the parent of this execution. If null, the execution represents a process-instance.\n\t * @returns The parent execution ID, or `null`.\n\t */\n\tpublic getParentId(): string {\n\t\treturn this.execution.getParentId();\n\t}\n\n\t/**\n\t * Gets the id of the calling execution. If not null, the execution is part of a subprocess.\n\t * @returns The super execution ID, or `null`.\n\t */\n\tpublic getSuperExecutionId(): string {\n\t\treturn this.execution.getSuperExecutionId();\n\t}\n\n\t/**\n\t * Gets the id of the current activity.\n\t * @returns The current activity ID.\n\t */\n\tpublic getCurrentActivityId(): string {\n\t\treturn this.execution.getCurrentActivityId();\n\t}\n\n\t/**\n\t * Returns the tenant id, if any is set before on the process definition or process instance.\n\t * @returns The tenant ID, or `null`/empty string.\n\t */\n\tpublic getTenantId(): string {\n\t\treturn this.execution.getTenantId();\n\t}\n\n\t/**\n\t * The BPMN element where the execution currently is at.\n\t * @returns The current flow element object (type is Java object).\n\t */\n\tpublic getCurrentFlowElement(): any {\n\t\treturn this.execution.getCurrentFlowElement();\n\t}\n\n\t/**\n\t * Change the current BPMN element the execution is at.\n\t * @param flowElement The new flow element object (Java type).\n\t */\n\tpublic setCurrentFlowElement(flowElement: any): void {\n\t\tthis.execution.setCurrentFlowElement(flowElement);\n\t}\n\n\t/**\n\t * Returns the {@link FlowableListener} instance matching an {@link ExecutionListener} if currently an execution listener is being execution. Returns null otherwise.\n\t * @returns The current Flowable Listener object (Java type), or `null`.\n\t */\n\tpublic getCurrentFlowableListener(): any {\n\t\treturn this.execution.getCurrentFlowableListener();\n\t}\n\n\t/**\n\t * Called when an {@link ExecutionListener} is being executed.\n\t * @param currentListener The current listener object (Java type).\n\t */\n\tpublic setCurrentFlowableListener(currentListener: any): void {\n\t\tthis.execution.setCurrentFlowableListener(currentListener);\n\t}\n\n\t/**\n\t * Create a snapshot read only delegate execution of this delegate execution.\n\t *\n\t * @returns A {@link ReadOnlyDelegateExecution} object (Java type).\n\t */\n\tpublic snapshotReadOnly(): any {\n\t\treturn this.execution.snapshotReadOnly();\n\t}\n\n\t/**\n\t * returns the parent of this execution, or null if there no parent.\n\t * @returns The parent execution object (Java type), or `null`.\n\t */\n\tpublic getParent(): any {\n\t\treturn this.execution.getParent();\n\t}\n\n\t/**\n\t * returns the list of execution of which this execution the parent of.\n\t * @returns An array of child execution objects (Java type).\n\t */\n\tpublic getExecutions(): any[] {\n\t\treturn this.execution.getExecutions();\n\t}\n\n\t/**\n\t * makes this execution active or inactive.\n\t * @param isActive A boolean indicating whether the execution should be active.\n\t */\n\tpublic setActive(isActive: boolean): void {\n\t\tthis.execution.setActive(isActive);\n\t}\n\n\t/**\n\t * returns whether this execution is currently active.\n\t * @returns `true` if active, `false` otherwise.\n\t */\n\tpublic isActive(): boolean {\n\t\treturn this.execution.isActive();\n\t}\n\n\t/**\n\t * returns whether this execution has ended or not.\n\t * @returns `true` if ended, `false` otherwise.\n\t */\n\tpublic isEnded(): boolean {\n\t\treturn this.execution.isEnded();\n\t}\n\n\t/**\n\t * changes the concurrent indicator on this execution.\n\t * @param isConcurrent A boolean indicating whether the execution should be concurrent.\n\t */\n\tpublic setConcurrent(isConcurrent: boolean): void {\n\t\tthis.execution.setConcurrent(isConcurrent);\n\t}\n\n\t/**\n\t * returns whether this execution is concurrent or not.\n\t * @returns `true` if concurrent, `false` otherwise.\n\t */\n\tpublic isConcurrent(): boolean {\n\t\treturn this.execution.isConcurrent();\n\t}\n\n\t/**\n\t * returns whether this execution is a process instance or not.\n\t * @returns `true` if it's a process instance, `false` otherwise.\n\t */\n\tpublic isProcessInstanceType(): boolean {\n\t\treturn this.execution.isProcessInstanceType();\n\t}\n\n\t/**\n\t * Inactivates this execution. This is useful for example in a join: the execution still exists, but it is not longer active.\n\t */\n\tpublic inactivate(): void {\n\t\tthis.execution.inactivate();\n\t}\n\n\t/**\n\t * Returns whether this execution is a scope.\n\t * @returns `true` if it is a scope, `false` otherwise.\n\t */\n\tpublic isScope(): boolean {\n\t\treturn this.execution.isScope();\n\t}\n\n\t/**\n\t * Changes whether this execution is a scope or not.\n\t * @param isScope A boolean indicating whether the execution should be a scope.\n\t */\n\tpublic setScope(isScope: boolean): void {\n\t\tthis.execution.setScope(isScope);\n\t}\n\n\t/**\n\t * Returns whether this execution is the root of a multi instance execution.\n\t * @returns `true` if it's a multi instance root, `false` otherwise.\n\t */\n\tpublic isMultiInstanceRoot(): boolean {\n\t\treturn this.execution.isMultiInstanceRoot();\n\t}\n\n\t/**\n\t * Changes whether this execution is a multi instance root or not.\n\t * @param isMultiInstanceRoot A boolean indicating whether the execution is the root of a multi-instance execution.\n\t */\n\tpublic setMultiInstanceRoot(isMultiInstanceRoot: boolean): void {\n\t\tthis.execution.setMultiInstanceRoot(isMultiInstanceRoot);\n\t}\n\n}\n\nenum 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\nclass TaskContext extends VariableScope {\n\n\tprivate task: any;\n\n\tconstructor() {\n\t\tsuper(__context.get('task'));\n\t\tthis.task = __context.get('task');\n\t}\n\n\t/**\n\t * DB id of the task.\n\t * \n\t * @returns the unique ID of the current task.\n\t */\n\tpublic getId(): string {\n\t\treturn this.task.getId();\n\t}\n\n\t/**\n\t * Name or title of the task.\n\t * \n\t * @returns the name of the current task.\n\t */\n\tpublic getName(): string {\n\t\treturn this.task.getName();\n\t}\n\n\t/**\n\t * Change the name of the task.\n\t * \n\t * @param name the new name for the task.\n\t */\n\tpublic setName(name: string): void {\n\t\tthis.task.setName(name);\n\t}\n\n\t/**\n\t * Get the free text description of the task.\n\t * \n\t * @returns the description of the current task.\n\t */\n\tpublic getDescription(): string {\n\t\treturn this.task.getDescription();\n\t}\n\n\t/**\n\t * Free text description of the task.\n\t * \n\t * @param description the new description for the task.\n\t */\n\tpublic setDescription(description: string): void {\n\t\tthis.task.setDescription(description);\n\t}\n\n\t/**\n\t * Indication of how important/urgent this task is with a number between 0 and 100 where higher values mean a higher priority and lower values mean lower priority: [0..19] lowest, [20..39] low,\n\t * [40..59] normal, [60..79] high [80..100] highest\n\t * \n\t * @returns the priority of the current task.\n\t */\n\tpublic getPriority(): number {\n\t\treturn this.task.getPriority();\n\t}\n\n\t/**\n\t * Indication of how important/urgent this task is with a number between 0 and 100 where higher values mean a higher priority and lower values mean lower priority: [0..19] lowest, [20..39] low,\n\t * [40..59] normal, [60..79] high [80..100] highest\n\t * \n\t * @param priority the new priority for the task, with a number between 0 and 100 where higher values mean a higher priority and lower values mean lower priority: [0..19] lowest, [20..39] low, [40..59] normal, \n\t */\n\tpublic setPriority(priority: number): void {\n\t\tthis.task.setPriority(priority);\n\t}\n\n\t/**\n\t * Refrence to the process instance this task is associated with, or `null` if the task is not related to a process instance.\n\t * \n\t * @returns the ID of the process instance this task is associated with, or `null`.\n\t */\n\tpublic getProcessInstanceId(): string {\n\t\treturn this.task.getProcessInstanceId();\n\t}\n\n\t/**\n\t * Reference to the path of execution this task is associated with, or `null` if the task is not related to a process instance.\n\t * \n\t * @returns the ID of the execution this task is associated with, or `null`.\n\t */\n\tpublic getExecutionId(): string {\n\t\treturn this.task.getExecutionId();\n\t}\n\n\t/**\n\t * Reference to the process definition this task is associated with, or `null` if the task is not related to a process instance.\n\t * \n\t * @returns the ID of the process definition this task is associated with, or `null`.\n\t */\n\tpublic getProcessDefinitionId(): string {\n\t\treturn this.task.getProcessDefinitionId();\n\t}\n\n\t/**\n\t * The current state of the task.\n\t * \n\t * @returns the state of the current task.\n\t */\n\tpublic getState(): string {\n\t\treturn this.task.getState();\n\t}\n\n\t/**\n\t * The date/time when this task was created.\n\t * \n\t * @returns the creation time of the current task.\n\t */\n\tpublic getCreateTime(): Date {\n\t\treturn this.task.getCreateTime();\n\t}\n\n\t/**\n\t * The date/time when this task was put in progress.\n\t * \n\t * @returns the in progress start time of the current task.\n\t */\n\tpublic getInProgressStartTime(): Date {\n\t\treturn this.task.getInProgressStartTime();\n\t}\n\n\t/**\n\t * The user reference that started the task.\n\t * \n\t * @returns the user reference that started the task.\n\t */\n\tpublic getInProgressStartedBy(): string {\n\t\treturn this.task.getInProgressStartedBy();\n\t}\n\n\t/**\n\t * The date/time when this task was claimed.\n\t * \n\t * @returns the claim time of the current task.\n\t */\n\tpublic getClaimTime(): Date {\n\t\treturn this.task.getClaimTime();\n\t}\n\n\t/**\n\t * The user reference that claimed the task.\n\t * \n\t * @returns the user reference that claimed the task.\n\t */\n\tpublic getClaimedBy(): string {\n\t\treturn this.task.getClaimedBy();\n\t}\n\n\t/**\n\t * The date/time when this task was suspended.\n\t * \n\t * @returns the date/time when this task was suspended.\n\t */\n\tpublic getSuspendedTime(): Date {\n\t\treturn this.task.getSuspendedTime();\n\t}\n\n\t/**\n\t * The user reference that suspended the task.\n\t * \n\t * @returns the user reference that suspended the task.\n\t */\n\tpublic getSuspendedBy(): string {\n\t\treturn this.task.getSuspendedBy();\n\t}\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\t * @returns the task definition key.\n\t */\n\tpublic getTaskDefinitionKey(): string {\n\t\treturn this.task.getTaskDefinitionKey();\n\t}\n\n\t/**\n\t * Indicated whether this task is suspended or not.\n\t * \n\t * @returns `true` if the task is suspended, `false` otherwise.\n\t */\n\tpublic isSuspended(): boolean {\n\t\treturn this.task.isSuspended();\n\t}\n\n\t/**\n\t * The tenant identifier of this task, which is the same as the tenant identifier of the process definition and process instance this task is associated with (if any).\n\t * \n\t * @returns the tenant ID of this task, or `null`/empty string if no tenant is associated.\n\t */\n\tpublic getTenantId(): string {\n\t\treturn this.task.getTenantId();\n\t}\n\n\t/**\n\t * The form key for the user task, which is the same as the form key defined on the user task in the process definition. Will return `null` if this task is not a user task or if no form key is defined.\n\t * \n\t * @returns the form key for the user task, or `null` if no form key is defined.\n\t */\n\tpublic getFormKey(): string {\n\t\treturn this.task.getFormKey();\n\t}\n\n\t/**\n\t * Change the form key of the task.\n\t * \n\t * @param formKey the new form key for the user task, or `null` to remove the form key\n\t */\n\tpublic setFormKey(formKey: string): void {\n\t\tthis.task.setFormKey(formKey);\n\t}\n\n\t/**\n\t * The event name which triggered the task listener to fire for this task. Will return `null`/empty string if not executing a task listener.\n\t * \n\t * @returns the event name which triggered the task listener to fire for this task, or `null`/empty string if not executing a task listener.\n\t */\n\tpublic getEventName(): string {\n\t\treturn this.task.getEventName();\n\t}\n\n\t/**\n\t * The event handler identifier which triggered the task listener to fire for this task. Will return `null`/empty string if not executing a task listener or if the event handler does not have an identifier.\n\t * \n\t * @returns the event handler identifier, or `null`/empty string if not executing a task listener or if the event handler does not have an identifier.\n\t */\n\tpublic getEventHandlerId(): string {\n\t\treturn this.task.getEventHandlerId();\n\t}\n\n\t/**\n\t * The current delegation state of the task, which is `null` if the task is not delegated, `PENDING` if the task is delegated and waiting for resolution by the assignee, and `RESOLVED` if the task is delegated and has been resolved by the assignee but not yet completed by the owner.\n\t * \n\t * @returns the delegation state of the task, which is `null` if the task is not delegated, `PENDING` if the task is delegated and waiting for resolution by the assignee, and `RESOLVED` if the task is delegated and has been resolved by the assignee but not yet completed by the owner.\n\t */\n\tpublic getDelegationState(): DelegationState {\n\t\treturn this.task.getDelegationState();\n\t}\n\n\t/**\n\t * Adds a candidate user to this task, which means that the user is allowed to claim and work on this task. This does not mean that the user is the assignee of the task, but it means that the user is a candidate to become an assignee. The user will be able to see this task in their task list and claim it to become the assignee.\n\t * \n\t * @param userId the user ID of the candidate user to add to this task.\n\t */\n\tpublic addCandidateUser(userId: string): void {\n\t\tthis.task.addCandidateUser(userId);\n\t}\n\n\t/**\n\t * Adds multiple users as candidate user to this task.\n\t * \n\t * @param candidateUsers the collection of candidate user IDs to add to this task.\n\t */\n\tpublic addCandidateUsers(candidateUsers: string[]): void {\n\t\tthis.task.addCandidateUsers(candidateUsers);\n\t}\n\n\t/**\n\t * Adds a candidate group to this task, which means that all users that are members of this group are allowed to claim and work on this task. This does not mean that the group is the assignee of the task, but it means that all users that are members of the group are candidates to become assignees. The users that are members of the group will be able to see this task in their task list and claim it to become the assignee.\n\t * \n\t * @param groupId the group ID of the candidate group to add to this task.\n\t */\n\tpublic addCandidateGroup(groupId: string): void {\n\t\tthis.task.addCandidateGroup(groupId);\n\t}\n\n\t/**\n\t * Adds multiple groups as candidate group to this task.\n\t * \n\t * @param candidateGroups the collection of candidate group IDs to add to this task.\n\t */\n\tpublic addCandidateGroups(candidateGroups: string[]): void {\n\t\tthis.task.addCandidateGroups(candidateGroups);\n\t}\n\n\t/**\n\t * The user id of the person responsible for this task. This is the user that has to work on this task and complete it. When a task is assigned to a user, that user becomes the assignee of the task. The assignee is the only one that can complete the task (unless the task is delegated\n\t * \n\t * @returns the user ID of the assignee of this task\n\t */\n\tpublic getOwner(): string {\n\t\treturn this.task.getOwner();\n\t}\n\n\t/**\n\t * The user id of the person responsible for this task. This is the user that has to work on this task and complete it. When a task is assigned to a user, that user becomes the assignee of the task. The assignee is the only one that can complete the task (unless the task is delegated\n\t * \n\t * @param owner the user ID of the assignee of this task\n\t */\n\tpublic setOwner(owner: string): void {\n\t\tthis.task.setOwner(owner);\n\t}\n\n\t/**\n\t * The user id of the person to which this task is delegated.\n\t * \n\t * @returns the user ID of the assignee of this task\n\t */\n\tpublic getAssignee(): string {\n\t\treturn this.task.getAssignee();\n\t}\n\n\t/**\n\t * The user id of the person to which this task is delegated.\n\t * @param assignee the user ID of the assignee of this task\n\t */\n    public setAssignee(assignee: string): void {\n        this.task.setAssignee(assignee);\n    }\n\n\t/**\n\t * Due date of the in progress start of the task.\n\t * \n\t * @returns the due date of the in progress start of the task.\n\t */\n\tpublic getInProgressStartDueDate(): Date {\n\t\treturn this.task.getInProgressStartDueDate();\n\t}\n\n\t/**\n\t * Change the in progress start due date of the task.\n\t * \n\t * @param inProgressStartDueDate the new due date of the in progress start of the task.\n\t */\n\tpublic setInProgressStartDueDate(inProgressStartDueDate: Date): void {\n\t\tthis.task.setInProgressStartDueDate(inProgressStartDueDate);\n\t}\n\n\t/**\n\t * Due date of the task.\n\t * \n\t * @returns the due date of the task.\n\t */\n\tpublic getDueDate(): Date {\n\t\treturn this.task.getDueDate();\n\t}\n\n\t/**\n\t * Change the due date of the task.\n\t * \n\t * @param dueDate the new due date of the task.\n\t */\n\tpublic setDueDate(dueDate: Date): void {\n\t\tthis.task.setDueDate(dueDate);\n\t}\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\t * @returns the category of the task\n\t */\n\tpublic getCategory(): string {\n\t\treturn this.task.getCategory();\n\t}\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\t * @param category the new category of the task\n\t */\n\tpublic setCategory(category: string): void {\n\t\tthis.task.setCategory(category);\n\t}\n\n\n    /**\n     * Involves a user with a task. The type of identity link is defined by the given identityLinkType.\n     *\n     * @param userId\n     *            id of the user involve, cannot be null.\n     * @param identityLinkType\n     *            type of identityLink, cannot be null (@see {@link IdentityLinkType}).\n     * @throws FlowableObjectNotFoundException\n     *             when the task or user doesn't exist.\n     */\n\tpublic addUserIdentityLink(userId: string, identityLinkType: string): void {\n\t\tthis.task.addUserIdentityLink(userId, identityLinkType);\n\t}\n\n    /**\n     * Involves a group with group task. The type of identityLink is defined by the given identityLink.\n     *\n     * @param groupId\n     *            id of the group to involve, cannot be null.\n     * @param identityLinkType\n     *            type of identity, cannot be null (@see {@link IdentityLinkType}).\n     * @throws FlowableObjectNotFoundException\n     *             when the task or group doesn't exist.\n     */\n    public addGroupIdentityLink(groupId: string, identityLinkType: string): void {\n        this.task.addGroupIdentityLink(groupId, identityLinkType);\n    }\n\n    /**\n     * Convenience shorthand for {@link #deleteUserIdentityLink(String, String)} ; with type {@link IdentityLinkType#CANDIDATE}\n     *\n     * @param userId\n     *            id of the user to use as candidate, cannot be null.\n     * @throws FlowableObjectNotFoundException\n     *             when the task or user doesn't exist.\n     */\n    public deleteCandidateUser(userId: string): void {\n        this.task.deleteCandidateUser(userId);\n    }\n\n    /**\n     * Convenience shorthand for {@link #deleteGroupIdentityLink(String, String)}; with type {@link IdentityLinkType#CANDIDATE}\n     *\n     * @param groupId\n     *            id of the group to use as candidate, cannot be null.\n     * @throws FlowableObjectNotFoundException\n     *             when the task or group doesn't exist.\n     */\n\tpublic deleteCandidateGroup(groupId: string): void {\n\t\tthis.task.deleteCandidateGroup(groupId);\n\t}\n\n\t/**\n     * Removes the association between a user and a task for the given identityLinkType.\n     *\n     * @param userId\n     *            id of the user involve, cannot be null.\n     * @param identityLinkType\n     *            type of identityLink, cannot be null (@see {@link IdentityLinkType}).\n     * @throws FlowableObjectNotFoundException\n     *             when the task or user doesn't exist.\n     */\n\tpublic deleteUserIdentityLink(userId: string, identityLinkType: string): void {\n\t\tthis.task.deleteUserIdentityLink(userId, identityLinkType);\n\t}\n\n    /**\n     * Removes the association between a group and a task for the given identityLinkType.\n     *\n     * @param groupId\n     *            id of the group to involve, cannot be null.\n     * @param identityLinkType\n     *            type of identity, cannot be null (@see {@link IdentityLinkType}).\n     * @throws FlowableObjectNotFoundException\n     *             when the task or group doesn't exist.\n     */\n    public deleteGroupIdentityLink(groupId: string, identityLinkType: string): void {\n        this.task.deleteGroupIdentityLink(groupId, identityLinkType);\n    }\n\n\n    /**\n     * Retrieves the candidate users and groups associated with the task.\n     *\n     * @return set of {@link IdentityLink}s of type {@link IdentityLinkType#CANDIDATE}.\n     */\n\tpublic getCandidates(): IdentityLink[] {\n\t\treturn this.task.getCandidates();\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Process;\n}\n"],
  "mappings": "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",
  "names": ["DelegationState"]
}
