@io-orkes/conductor-javascript 1.1.0 → 1.2.0-rc.1

package/dist/index.mjs

@@ -1,211 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-// src/task/helpers.ts
-var noopLogger = {
-  debug: (...args) => {
-  },
-  info: (...args) => {
-  },
-  error: (...args) => {
-  }
-};
-
-// src/task/Poller.ts
-var Poller = class {
-  constructor(pollFunction, pollerOptions, logger) {
-    this.concurrentCalls = [];
-    this.pollFunction = async () => {
-    };
-    this.isPolling = false;
-    this.options = {
-      pollInterval: 1e3,
-      concurrency: 1
-    };
-    this.logger = noopLogger;
-    this.startPolling = () => {
-      if (this.isPolling) {
-        throw new Error("Runner is already started");
-      }
-      return this.poll();
-    };
-    this.stopPolling = () => {
-      this.isPolling = false;
-      this.concurrentCalls.forEach((call) => call.stop());
-    };
-    this.poll = async () => {
-      if (!this.isPolling) {
-        this.isPolling = true;
-        for (let i = 0; i < this.options.concurrency; i++) {
-          this.concurrentCalls.push(this.singlePoll());
-        }
-      }
-    };
-    this.singlePoll = () => {
-      let poll = this.isPolling;
-      let timeout;
-      const pollingCall = async () => {
-        while (poll) {
-          await this.pollFunction();
-          await new Promise((r) => timeout = setTimeout(() => r(true), this.options.pollInterval));
-        }
-      };
-      return {
-        promise: pollingCall(),
-        stop: () => {
-          clearTimeout(timeout);
-          poll = false;
-          this.logger.debug("stopping single poll call");
-        }
-      };
-    };
-    this.pollFunction = pollFunction;
-    this.options = __spreadValues(__spreadValues({}, this.options), pollerOptions);
-    this.logger = logger || noopLogger;
-  }
-  updateConcurrency(concurrency) {
-    if (concurrency > 0 && concurrency !== this.options.concurrency) {
-      if (concurrency < this.options.concurrency) {
-        const result = this.concurrentCalls.splice(0, this.options.concurrency - concurrency);
-        result.forEach((call) => {
-          call.stop();
-          this.logger.debug("stopping some spawned calls");
-        });
-      } else {
-        for (let i = 0; i < concurrency - this.options.concurrency; i++) {
-          this.concurrentCalls.push(this.singlePoll());
-          this.logger.debug("spawning additional poll calls");
-        }
-      }
-      this.options.concurrency = concurrency;
-    }
-  }
-  updateOptions(options) {
-    const newOptions = __spreadValues(__spreadValues({}, this.options), options);
-    this.updateConcurrency(newOptions.concurrency);
-    this.options = newOptions;
-  }
-};
-
-// src/task/TaskRunner.ts
-var DEFAULT_ERROR_MESSAGE = "An unknown error occurred";
-var MAX_RETRIES = 3;
-var noopErrorHandler = (__error) => {
-};
-var TaskRunner = class {
-  constructor({
-    worker,
-    taskResource,
-    options,
-    logger = noopLogger,
-    onError: errorHandler = noopErrorHandler
-  }) {
-    this.startPolling = () => {
-      this.poller.startPolling();
-    };
-    this.stopPolling = () => {
-      this.poller.stopPolling();
-    };
-    this.pollAndExecute = async () => {
-      try {
-        const { workerID } = this.options;
-        const task = await this.taskResource.poll(this.worker.taskDefName, workerID, this.worker.domain ?? this.options.domain);
-        if (task && task.taskId) {
-          await this.executeTask(task);
-        } else {
-          this.logger.debug(`No tasks for ${this.worker.taskDefName}`);
-        }
-      } catch (unknownError) {
-        this.handleUnknownError(unknownError);
-        this.errorHandler(unknownError);
-      }
-    };
-    this.updateTaskWithRetry = async (task, taskResult) => {
-      let retryCount = 0;
-      while (retryCount < MAX_RETRIES) {
-        try {
-          await this.taskResource.updateTask1(taskResult);
-          return;
-        } catch (error) {
-          this.errorHandler(error, task);
-          this.logger.error(`Error updating task ${taskResult.taskId} on retry ${retryCount}`, error);
-          retryCount++;
-          await new Promise((r) => setTimeout(() => r(true), retryCount * 10));
-        }
-      }
-      this.logger.error(`Unable to update task ${taskResult.taskId} after ${retryCount} retries`);
-    };
-    this.executeTask = async (task) => {
-      try {
-        const result = await this.worker.execute(task);
-        await this.updateTaskWithRetry(task, __spreadProps(__spreadValues({}, result), {
-          workflowInstanceId: task.workflowInstanceId,
-          taskId: task.taskId
-        }));
-        this.logger.debug(`Finished polling for task ${task.taskId}`);
-      } catch (error) {
-        await this.updateTaskWithRetry(task, {
-          workflowInstanceId: task.workflowInstanceId,
-          taskId: task.taskId,
-          reasonForIncompletion: error?.message ?? DEFAULT_ERROR_MESSAGE,
-          status: "FAILED",
-          outputData: {}
-        });
-        this.errorHandler(error, task);
-        this.logger.error(`Error executing ${task.taskId}`, error);
-      }
-    };
-    this.handleUnknownError = (unknownError) => {
-      let message = "";
-      let stack = "";
-      if (unknownError.stack) {
-        stack = unknownError.stack;
-      }
-      if (unknownError.message) {
-        message = unknownError.message;
-      }
-      this.logger.error(`Error for ${this.worker.taskDefName}: error: ${message}, stack: ${stack}`);
-    };
-    this.taskResource = taskResource;
-    this.logger = logger;
-    this.worker = worker;
-    this.options = options;
-    this.errorHandler = errorHandler;
-    this.poller = new Poller(this.pollAndExecute, { concurrency: options.concurrency, pollInterval: options.pollInterval }, this.logger);
-  }
-  updateOptions(options) {
-    const newOptions = __spreadValues(__spreadValues({}, this.options), options);
-    this.poller.updateOptions({
-      concurrency: newOptions.concurrency,
-      pollInterval: newOptions.pollInterval
-    });
-    this.options = newOptions;
-  }
-  get getOptions() {
-    return this.options;
-  }
-};
-
-// src/task/TaskManager.ts
-import os from "os";
-
 // src/common/ConductorLogger.ts
 var LOG_LEVELS = {
   DEBUG: 10,
@@ -245,106 +37,75 @@ var DefaultLogger = class {
     }
   }
 };
+var noopLogger = {
+  //eslint-disable-next-line
+  debug: (...args) => {
+  },
+  //eslint-disable-next-line
+  info: (...args) => {
+  },
+  //eslint-disable-next-line
+  error: (...args) => {
+  }
+};
 
-// src/common/open-api/core/CancelablePromise.ts
-var CancelError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CancelError";
+// src/common/types.ts
+var TaskType = /* @__PURE__ */ ((TaskType2) => {
+  TaskType2["START"] = "START";
+  TaskType2["SIMPLE"] = "SIMPLE";
+  TaskType2["DYNAMIC"] = "DYNAMIC";
+  TaskType2["FORK_JOIN"] = "FORK_JOIN";
+  TaskType2["FORK_JOIN_DYNAMIC"] = "FORK_JOIN_DYNAMIC";
+  TaskType2["DECISION"] = "DECISION";
+  TaskType2["SWITCH"] = "SWITCH";
+  TaskType2["JOIN"] = "JOIN";
+  TaskType2["DO_WHILE"] = "DO_WHILE";
+  TaskType2["SUB_WORKFLOW"] = "SUB_WORKFLOW";
+  TaskType2["EVENT"] = "EVENT";
+  TaskType2["WAIT"] = "WAIT";
+  TaskType2["USER_DEFINED"] = "USER_DEFINED";
+  TaskType2["HTTP"] = "HTTP";
+  TaskType2["LAMBDA"] = "LAMBDA";
+  TaskType2["INLINE"] = "INLINE";
+  TaskType2["EXCLUSIVE_JOIN"] = "EXCLUSIVE_JOIN";
+  TaskType2["TERMINAL"] = "TERMINAL";
+  TaskType2["TERMINATE"] = "TERMINATE";
+  TaskType2["KAFKA_PUBLISH"] = "KAFKA_PUBLISH";
+  TaskType2["JSON_JQ_TRANSFORM"] = "JSON_JQ_TRANSFORM";
+  TaskType2["SET_VARIABLE"] = "SET_VARIABLE";
+  return TaskType2;
+})(TaskType || {});
+
+// src/common/open-api/services/EventResourceService.ts
+var EventResourceService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
   }
-  get isCancelled() {
-    return true;
-  }
-};
-var CancelablePromise = class {
-  constructor(executor) {
-    this._isResolved = false;
-    this._isRejected = false;
-    this._isCancelled = false;
-    this._cancelHandlers = [];
-    this._promise = new Promise((resolve2, reject) => {
-      this._resolve = resolve2;
-      this._reject = reject;
-      const onResolve = (value) => {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
-          return;
-        }
-        this._isResolved = true;
-        this._resolve?.(value);
-      };
-      const onReject = (reason) => {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
-          return;
-        }
-        this._isRejected = true;
-        this._reject?.(reason);
-      };
-      const onCancel = (cancelHandler) => {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
-          return;
-        }
-        this._cancelHandlers.push(cancelHandler);
-      };
-      Object.defineProperty(onCancel, "isResolved", {
-        get: () => this._isResolved
-      });
-      Object.defineProperty(onCancel, "isRejected", {
-        get: () => this._isRejected
-      });
-      Object.defineProperty(onCancel, "isCancelled", {
-        get: () => this._isCancelled
-      });
-      return executor(onResolve, onReject, onCancel);
-    });
-  }
-  then(onFulfilled, onRejected) {
-    return this._promise.then(onFulfilled, onRejected);
-  }
-  catch(onRejected) {
-    return this._promise.catch(onRejected);
-  }
-  finally(onFinally) {
-    return this._promise.finally(onFinally);
-  }
-  cancel() {
-    if (this._isResolved || this._isRejected || this._isCancelled) {
-      return;
-    }
-    this._isCancelled = true;
-    if (this._cancelHandlers.length) {
-      try {
-        for (const cancelHandler of this._cancelHandlers) {
-          cancelHandler();
-        }
-      } catch (error) {
-        console.warn("Cancellation threw an error", error);
-        return;
-      }
-    }
-    this._cancelHandlers.length = 0;
-    this._reject?.(new CancelError("Request aborted"));
-  }
-  get isCancelled() {
-    return this._isCancelled;
-  }
-};
-Symbol.toStringTag;
-
-// src/common/open-api/services/EventResourceService.ts
-var EventResourceService = class {
-  constructor(httpRequest) {
-    this.httpRequest = httpRequest;
-  }
-  getQueueConfig(queueType, queueName) {
-    return this.httpRequest.request({
-      method: "GET",
-      url: "/event/queue/config/{queueType}/{queueName}",
-      path: {
-        "queueType": queueType,
-        "queueName": queueName
-      }
-    });
+  /**
+   * Get queue config by name
+   * @param queueType
+   * @param queueName
+   * @returns any OK
+   * @throws ApiError
+   */
+  getQueueConfig(queueType, queueName) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/event/queue/config/{queueType}/{queueName}",
+      path: {
+        "queueType": queueType,
+        "queueName": queueName
+      }
+    });
   }
+  /**
+   * Create or update queue config by name
+   * @param queueType
+   * @param queueName
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   putQueueConfig(queueType, queueName, requestBody) {
     return this.httpRequest.request({
       method: "PUT",
@@ -357,6 +118,13 @@ var EventResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Delete queue config by name
+   * @param queueType
+   * @param queueName
+   * @returns any OK
+   * @throws ApiError
+   */
   deleteQueueConfig(queueType, queueName) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -367,12 +135,23 @@ var EventResourceService = class {
       }
     });
   }
+  /**
+   * Get all the event handlers
+   * @returns EventHandler OK
+   * @throws ApiError
+   */
   getEventHandlers() {
     return this.httpRequest.request({
       method: "GET",
       url: "/event"
     });
   }
+  /**
+   * Update an existing event handler.
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   updateEventHandler(requestBody) {
     return this.httpRequest.request({
       method: "PUT",
@@ -381,6 +160,12 @@ var EventResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Add a new event handler.
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   addEventHandler(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -389,12 +174,23 @@ var EventResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Get all queue configs
+   * @returns any OK
+   * @throws ApiError
+   */
   getQueueNames() {
     return this.httpRequest.request({
       method: "GET",
       url: "/event/queue/config"
     });
   }
+  /**
+   * Remove an event handler
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
   removeEventHandlerStatus(name) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -404,6 +200,13 @@ var EventResourceService = class {
       }
     });
   }
+  /**
+   * Get event handlers for a given event
+   * @param event
+   * @param activeOnly
+   * @returns EventHandler OK
+   * @throws ApiError
+   */
   getEventHandlersForEvent(event, activeOnly = true) {
     return this.httpRequest.request({
       method: "GET",
@@ -423,6 +226,10 @@ var HealthCheckResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * @returns any OK
+   * @throws ApiError
+   */
   doCheck() {
     return this.httpRequest.request({
       method: "GET",
@@ -436,6 +243,13 @@ var MetadataResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Gets the task definition
+   * @param tasktype
+   * @param metadata
+   * @returns TaskDef OK
+   * @throws ApiError
+   */
   getTaskDef(tasktype, metadata = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -448,6 +262,12 @@ var MetadataResourceService = class {
       }
     });
   }
+  /**
+   * Remove a task definition
+   * @param tasktype
+   * @returns any OK
+   * @throws ApiError
+   */
   unregisterTaskDef(tasktype) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -457,6 +277,15 @@ var MetadataResourceService = class {
       }
     });
   }
+  /**
+   * Retrieves all workflow definition along with blueprint
+   * @param access
+   * @param metadata
+   * @param tagKey
+   * @param tagValue
+   * @returns WorkflowDef OK
+   * @throws ApiError
+   */
   getAllWorkflows(access = "READ", metadata = false, tagKey, tagValue) {
     return this.httpRequest.request({
       method: "GET",
@@ -469,6 +298,13 @@ var MetadataResourceService = class {
       }
     });
   }
+  /**
+   * Create or update workflow definition(s)
+   * @param requestBody
+   * @param overwrite
+   * @returns any OK
+   * @throws ApiError
+   */
   update(requestBody, overwrite = true) {
     return this.httpRequest.request({
       method: "PUT",
@@ -480,6 +316,13 @@ var MetadataResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Create a new workflow definition
+   * @param requestBody
+   * @param overwrite
+   * @returns any OK
+   * @throws ApiError
+   */
   create(requestBody, overwrite = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -491,6 +334,15 @@ var MetadataResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Gets all task definition
+   * @param access
+   * @param metadata
+   * @param tagKey
+   * @param tagValue
+   * @returns TaskDef OK
+   * @throws ApiError
+   */
   getTaskDefs(access = "READ", metadata = false, tagKey, tagValue) {
     return this.httpRequest.request({
       method: "GET",
@@ -503,6 +355,12 @@ var MetadataResourceService = class {
       }
     });
   }
+  /**
+   * Update an existing task
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   updateTaskDef(requestBody) {
     return this.httpRequest.request({
       method: "PUT",
@@ -511,6 +369,12 @@ var MetadataResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Create or update task definition(s)
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   registerTaskDef(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -519,6 +383,13 @@ var MetadataResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Removes workflow definition. It does not remove workflows associated with the definition.
+   * @param name
+   * @param version
+   * @returns any OK
+   * @throws ApiError
+   */
   unregisterWorkflowDef(name, version) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -529,6 +400,14 @@ var MetadataResourceService = class {
       }
     });
   }
+  /**
+   * Retrieves workflow definition along with blueprint
+   * @param name
+   * @param version
+   * @param metadata
+   * @returns WorkflowDef OK
+   * @throws ApiError
+   */
   get(name, version, metadata = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -549,6 +428,12 @@ var SchedulerResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Get an existing workflow schedule by name
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
   getSchedule(name) {
     return this.httpRequest.request({
       method: "GET",
@@ -558,6 +443,12 @@ var SchedulerResourceService = class {
       }
     });
   }
+  /**
+   * Deletes an existing workflow schedule by name
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
   deleteSchedule(name) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -567,6 +458,15 @@ var SchedulerResourceService = class {
       }
     });
   }
+  /**
+   * Get list of the next x (default 3, max 5) execution times for a scheduler
+   * @param cronExpression
+   * @param scheduleStartTime
+   * @param scheduleEndTime
+   * @param limit
+   * @returns number OK
+   * @throws ApiError
+   */
   getNextFewSchedules(cronExpression, scheduleStartTime, scheduleEndTime, limit = 3) {
     return this.httpRequest.request({
       method: "GET",
@@ -579,6 +479,12 @@ var SchedulerResourceService = class {
       }
     });
   }
+  /**
+   * Pauses an existing schedule by name
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
   pauseSchedule(name) {
     return this.httpRequest.request({
       method: "GET",
@@ -588,12 +494,23 @@ var SchedulerResourceService = class {
       }
     });
   }
+  /**
+   * Pause all scheduling in a single conductor server instance (for debugging only)
+   * @returns any OK
+   * @throws ApiError
+   */
   pauseAllSchedules() {
     return this.httpRequest.request({
       method: "GET",
       url: "/scheduler/admin/pause"
     });
   }
+  /**
+   * Resume a paused schedule by name
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
   resumeSchedule(name) {
     return this.httpRequest.request({
       method: "GET",
@@ -603,18 +520,34 @@ var SchedulerResourceService = class {
       }
     });
   }
+  /**
+   * Requeue all execution records
+   * @returns any OK
+   * @throws ApiError
+   */
   requeueAllExecutionRecords() {
     return this.httpRequest.request({
       method: "GET",
       url: "/scheduler/admin/requeue"
     });
   }
+  /**
+   * Resume all scheduling
+   * @returns any OK
+   * @throws ApiError
+   */
   resumeAllSchedules() {
     return this.httpRequest.request({
       method: "GET",
       url: "/scheduler/admin/resume"
     });
   }
+  /**
+   * Get all existing workflow schedules and optionally filter by workflow name
+   * @param workflowName
+   * @returns WorkflowSchedule OK
+   * @throws ApiError
+   */
   getAllSchedules(workflowName) {
     return this.httpRequest.request({
       method: "GET",
@@ -624,6 +557,12 @@ var SchedulerResourceService = class {
       }
     });
   }
+  /**
+   * Create or update a schedule for a specified workflow with a corresponding start workflow request
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   saveSchedule(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -632,12 +571,28 @@ var SchedulerResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Test timeout - do not use in production
+   * @returns any OK
+   * @throws ApiError
+   */
   testTimeout() {
     return this.httpRequest.request({
       method: "GET",
       url: "/scheduler/test/timeout"
     });
   }
+  /**
+   * Search for workflows based on payload and other parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultWorkflowScheduleExecutionModel OK
+   * @throws ApiError
+   */
   searchV21(start, size = 100, sort, freeText = "*", query) {
     return this.httpRequest.request({
       method: "GET",
@@ -658,6 +613,14 @@ var TaskResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Poll for a task of a certain type
+   * @param tasktype
+   * @param workerid
+   * @param domain
+   * @returns Task OK
+   * @throws ApiError
+   */
   poll(tasktype, workerid, domain) {
     return this.httpRequest.request({
       method: "GET",
@@ -671,12 +634,26 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Get the details about each queue
+   * @returns number OK
+   * @throws ApiError
+   */
   allVerbose() {
     return this.httpRequest.request({
       method: "GET",
       url: "/tasks/queue/all/verbose"
     });
   }
+  /**
+   * Update a task By Ref Name
+   * @param workflowId
+   * @param taskRefName
+   * @param status
+   * @param requestBody
+   * @returns string OK
+   * @throws ApiError
+   */
   updateTask(workflowId, taskRefName, status, requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -690,6 +667,12 @@ var TaskResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Get task by Id
+   * @param taskId
+   * @returns Task OK
+   * @throws ApiError
+   */
   getTask(taskId) {
     return this.httpRequest.request({
       method: "GET",
@@ -699,12 +682,23 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Get the details about each queue
+   * @returns number OK
+   * @throws ApiError
+   */
   all() {
     return this.httpRequest.request({
       method: "GET",
       url: "/tasks/queue/all"
     });
   }
+  /**
+   * Requeue pending tasks
+   * @param taskType
+   * @returns string OK
+   * @throws ApiError
+   */
   requeuePendingTask(taskType) {
     return this.httpRequest.request({
       method: "POST",
@@ -714,6 +708,17 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Search for tasks based in payload and other parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultTaskSummary OK
+   * @throws ApiError
+   */
   search(start, size = 100, sort, freeText = "*", query) {
     return this.httpRequest.request({
       method: "GET",
@@ -727,6 +732,17 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Search for tasks based in payload and other parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultTask OK
+   * @throws ApiError
+   */
   searchV22(start, size = 100, sort, freeText = "*", query) {
     return this.httpRequest.request({
       method: "GET",
@@ -740,6 +756,12 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Get the last poll data for a given task type
+   * @param taskType
+   * @returns PollData OK
+   * @throws ApiError
+   */
   getPollData(taskType) {
     return this.httpRequest.request({
       method: "GET",
@@ -749,6 +771,12 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Get Task Execution Logs
+   * @param taskId
+   * @returns TaskExecLog OK
+   * @throws ApiError
+   */
   getTaskLogs(taskId) {
     return this.httpRequest.request({
       method: "GET",
@@ -758,6 +786,13 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Log Task Execution Details
+   * @param taskId
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   log(taskId, requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -769,12 +804,27 @@ var TaskResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Get the last poll data for all task types
+   * @returns PollData OK
+   * @throws ApiError
+   */
   getAllPollData() {
     return this.httpRequest.request({
       method: "GET",
       url: "/tasks/queue/polldata/all"
     });
   }
+  /**
+   * Batch poll for a task of a certain type
+   * @param tasktype
+   * @param workerid
+   * @param domain
+   * @param count
+   * @param timeout
+   * @returns Task OK
+   * @throws ApiError
+   */
   batchPoll(tasktype, workerid, domain, count = 1, timeout = 100) {
     return this.httpRequest.request({
       method: "GET",
@@ -790,6 +840,12 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Update a task
+   * @param requestBody
+   * @returns string OK
+   * @throws ApiError
+   */
   updateTask1(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -798,6 +854,12 @@ var TaskResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Get Task type queue sizes
+   * @param taskType
+   * @returns number OK
+   * @throws ApiError
+   */
   size1(taskType) {
     return this.httpRequest.request({
       method: "GET",
@@ -807,6 +869,14 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Get the external uri where the task payload is to be stored
+   * @param path
+   * @param operation
+   * @param payloadType
+   * @returns ExternalStorageLocation OK
+   * @throws ApiError
+   */
   getExternalStorageLocation1(path, operation, payloadType) {
     return this.httpRequest.request({
       method: "GET",
@@ -825,6 +895,12 @@ var TokenResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Generate JWT with the given access key
+   * @param requestBody
+   * @returns Response OK
+   * @throws ApiError
+   */
   generateToken(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -833,6 +909,11 @@ var TokenResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Get the user info from the token
+   * @returns any OK
+   * @throws ApiError
+   */
   getUserInfo() {
     return this.httpRequest.request({
       method: "GET",
@@ -846,6 +927,12 @@ var WorkflowBulkResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Retry the last failed task for each workflow from the list
+   * @param requestBody
+   * @returns BulkResponse OK
+   * @throws ApiError
+   */
   retry(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -854,6 +941,13 @@ var WorkflowBulkResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Restart the list of completed workflow
+   * @param requestBody
+   * @param useLatestDefinitions
+   * @returns BulkResponse OK
+   * @throws ApiError
+   */
   restart(requestBody, useLatestDefinitions = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -865,6 +959,13 @@ var WorkflowBulkResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Terminate workflows execution
+   * @param requestBody
+   * @param reason
+   * @returns BulkResponse OK
+   * @throws ApiError
+   */
   terminate(requestBody, reason) {
     return this.httpRequest.request({
       method: "POST",
@@ -876,6 +977,12 @@ var WorkflowBulkResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Resume the list of workflows
+   * @param requestBody
+   * @returns BulkResponse OK
+   * @throws ApiError
+   */
   resumeWorkflow(requestBody) {
     return this.httpRequest.request({
       method: "PUT",
@@ -884,6 +991,12 @@ var WorkflowBulkResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Pause the list of workflows
+   * @param requestBody
+   * @returns BulkResponse OK
+   * @throws ApiError
+   */
   pauseWorkflow1(requestBody) {
     return this.httpRequest.request({
       method: "PUT",
@@ -899,6 +1012,15 @@ var WorkflowResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Retrieve all the running workflows
+   * @param name
+   * @param version
+   * @param startTime
+   * @param endTime
+   * @returns string OK
+   * @throws ApiError
+   */
   getRunningWorkflow(name, version = 1, startTime, endTime) {
     return this.httpRequest.request({
       method: "GET",
@@ -913,6 +1035,17 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Execute a workflow synchronously
+   * @param body 
+   * @param name 
+   * @param version 
+   * @param requestId 
+   * @param waitUntilTaskRef 
+   * @param callback 
+   * @returns workflowRun
+   * @throws ApiError
+   */
   executeWorkflow(body, name, version, requestId, waitUntilTaskRef) {
     return this.httpRequest.request({
       method: "POST",
@@ -929,6 +1062,12 @@ var WorkflowResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Start a new workflow with StartWorkflowRequest, which allows task to be executed in a domain
+   * @param requestBody
+   * @returns string OK
+   * @throws ApiError
+   */
   startWorkflow(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -937,6 +1076,12 @@ var WorkflowResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Starts the decision task for a workflow
+   * @param workflowId
+   * @returns any OK
+   * @throws ApiError
+   */
   decide(workflowId) {
     return this.httpRequest.request({
       method: "PUT",
@@ -946,6 +1091,13 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Reruns the workflow from a specific task
+   * @param workflowId
+   * @param requestBody
+   * @returns string OK
+   * @throws ApiError
+   */
   rerun(workflowId, requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -957,6 +1109,17 @@ var WorkflowResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Search for workflows based on payload and other parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultWorkflow OK
+   * @throws ApiError
+   */
   searchV21(start, size = 100, sort, freeText = "*", query) {
     return this.httpRequest.request({
       method: "GET",
@@ -970,6 +1133,12 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Pauses the workflow
+   * @param workflowId
+   * @returns any OK
+   * @throws ApiError
+   */
   pauseWorkflow(workflowId) {
     return this.httpRequest.request({
       method: "PUT",
@@ -979,6 +1148,14 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Skips a given task from a current running workflow
+   * @param workflowId
+   * @param taskReferenceName
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   skipTaskFromWorkflow(workflowId, taskReferenceName, requestBody) {
     return this.httpRequest.request({
       method: "PUT",
@@ -991,6 +1168,15 @@ var WorkflowResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Lists workflows for the given correlation id list
+   * @param name
+   * @param requestBody
+   * @param includeClosed
+   * @param includeTasks
+   * @returns Workflow OK
+   * @throws ApiError
+   */
   getWorkflows(name, requestBody, includeClosed = false, includeTasks = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -1006,6 +1192,14 @@ var WorkflowResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Gets the workflow by workflow id
+   * @param workflowId
+   * @param includeOutput
+   * @param includeVariables
+   * @returns WorkflowStatus OK
+   * @throws ApiError
+   */
   getWorkflowStatusSummary(workflowId, includeOutput = false, includeVariables = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -1019,6 +1213,15 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Lists workflows for the given correlation id
+   * @param name
+   * @param correlationId
+   * @param includeClosed
+   * @param includeTasks
+   * @returns Workflow OK
+   * @throws ApiError
+   */
   getWorkflows1(name, correlationId, includeClosed = false, includeTasks = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -1033,6 +1236,13 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Retries the last failed task
+   * @param workflowId
+   * @param resumeSubworkflowTasks
+   * @returns void
+   * @throws ApiError
+   */
   retry1(workflowId, resumeSubworkflowTasks = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -1045,6 +1255,13 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Gets the workflow by workflow id
+   * @param workflowId
+   * @param includeTasks
+   * @returns Workflow OK
+   * @throws ApiError
+   */
   getExecutionStatus(workflowId, includeTasks = true) {
     return this.httpRequest.request({
       method: "GET",
@@ -1057,6 +1274,13 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Terminate workflow execution
+   * @param workflowId
+   * @param reason
+   * @returns any OK
+   * @throws ApiError
+   */
   terminate1(workflowId, reason) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -1069,6 +1293,12 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Resumes the workflow
+   * @param workflowId
+   * @returns any OK
+   * @throws ApiError
+   */
   resumeWorkflow(workflowId) {
     return this.httpRequest.request({
       method: "PUT",
@@ -1078,6 +1308,13 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Removes the workflow from the system
+   * @param workflowId
+   * @param archiveWorkflow
+   * @returns any OK
+   * @throws ApiError
+   */
   delete(workflowId, archiveWorkflow = true) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -1090,6 +1327,17 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Search for workflows based on task parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultWorkflowSummary OK
+   * @throws ApiError
+   */
   searchWorkflowsByTasks(start, size = 100, sort, freeText = "*", query) {
     return this.httpRequest.request({
       method: "GET",
@@ -1103,6 +1351,14 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Get the uri and path of the external storage where the workflow payload is to be stored
+   * @param path
+   * @param operation
+   * @param payloadType
+   * @returns ExternalStorageLocation OK
+   * @throws ApiError
+   */
   getExternalStorageLocation(path, operation, payloadType) {
     return this.httpRequest.request({
       method: "GET",
@@ -1114,6 +1370,16 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Start a new workflow. Returns the ID of the workflow instance that can be later used for tracking
+   * @param name
+   * @param requestBody
+   * @param version
+   * @param correlationId
+   * @param priority
+   * @returns string OK
+   * @throws ApiError
+   */
   startWorkflow1(name, requestBody, version, correlationId, priority) {
     return this.httpRequest.request({
       method: "POST",
@@ -1130,6 +1396,13 @@ var WorkflowResourceService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Restarts a completed workflow
+   * @param workflowId
+   * @param useLatestDefinitions
+   * @returns void
+   * @throws ApiError
+   */
   restart1(workflowId, useLatestDefinitions = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -1142,6 +1415,19 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Search for workflows based on payload and other parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+   * @param queryId
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @param skipCache
+   * @returns ScrollableSearchResultWorkflowSummary OK
+   * @throws ApiError
+   */
   search1(queryId, start, size = 100, sort, freeText = "*", query, skipCache = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -1157,6 +1443,17 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Search for workflows based on task parameters
+   * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+   * @param start
+   * @param size
+   * @param sort
+   * @param freeText
+   * @param query
+   * @returns SearchResultWorkflow OK
+   * @throws ApiError
+   */
   searchWorkflowsByTasksV2(start, size = 100, sort, freeText = "*", query) {
     return this.httpRequest.request({
       method: "GET",
@@ -1170,6 +1467,12 @@ var WorkflowResourceService = class {
       }
     });
   }
+  /**
+   * Resets callback times of all non-terminal SIMPLE tasks to 0
+   * @param workflowId
+   * @returns void
+   * @throws ApiError
+   */
   resetWorkflow(workflowId) {
     return this.httpRequest.request({
       method: "POST",
@@ -1183,14 +1486,100 @@ var WorkflowResourceService = class {
 
 // src/common/open-api/core/ApiError.ts
 var ApiError = class extends Error {
-  constructor(request2, response, message) {
+  constructor(request3, response, message) {
     super(message);
     this.name = "ApiError";
     this.url = response.url;
     this.status = response.status;
     this.statusText = response.statusText;
     this.body = response.body;
-    this.request = request2;
+    this.request = request3;
+  }
+};
+
+// src/common/open-api/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  static {
+    Symbol.toStringTag;
+  }
+  constructor(executor) {
+    this._isResolved = false;
+    this._isRejected = false;
+    this._isCancelled = false;
+    this._cancelHandlers = [];
+    this._promise = new Promise((resolve3, reject) => {
+      this._resolve = resolve3;
+      this._reject = reject;
+      const onResolve = (value) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        this._resolve?.(value);
+      };
+      const onReject = (reason) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        this._reject?.(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this._isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this._isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this._isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  then(onFulfilled, onRejected) {
+    return this._promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this._promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this._promise.finally(onFinally);
+  }
+  cancel() {
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return;
+    }
+    this._isCancelled = true;
+    if (this._cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this._cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this._cancelHandlers.length = 0;
+    this._reject?.(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this._isCancelled;
   }
 };
 
@@ -1291,11 +1680,17 @@ var getHeaders = async (config, options) => {
   const username = await resolve(options, config.USERNAME);
   const password = await resolve(options, config.PASSWORD);
   const additionalHeaders = await resolve(options, config.HEADERS);
-  const headers = Object.entries(__spreadValues(__spreadValues({
-    Accept: "application/json"
-  }, additionalHeaders), options.headers)).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => __spreadProps(__spreadValues({}, headers2), {
-    [key]: String(value)
-  }), {});
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce(
+    (headers2, [key, value]) => ({
+      ...headers2,
+      [key]: String(value)
+    }),
+    {}
+  );
   if (isStringWithValue(token)) {
     headers["X-AUTHORIZATION"] = token;
   }
@@ -1330,14 +1725,14 @@ var getRequestBody = (options) => {
 };
 var sendRequest = async (options, url, body, formData, headers, onCancel) => {
   const controller = new AbortController();
-  const request2 = {
+  const request3 = {
     headers,
     method: options.method,
     body: body ?? formData,
     signal: controller.signal
   };
   onCancel(() => controller.abort());
-  return await fetch(url, request2);
+  return await fetch(url, request3);
 };
 var getResponseHeader = (response, responseHeader) => {
   if (responseHeader) {
@@ -1367,15 +1762,16 @@ var getResponseBody = async (response) => {
   return void 0;
 };
 var catchErrorCodes = (options, result) => {
-  const errors = __spreadValues({
+  const errors = {
     400: "Bad Request",
     401: "Unauthorized",
     403: "Forbidden",
     404: "Not Found",
     500: "Internal Server Error",
     502: "Bad Gateway",
-    503: "Service Unavailable"
-  }, options.errors);
+    503: "Service Unavailable",
+    ...options.errors
+  };
   const error = errors[result.status];
   if (error) {
     throw new ApiError(options, result, error);
@@ -1385,16 +1781,26 @@ var catchErrorCodes = (options, result) => {
   }
 };
 var request = (config, options) => {
-  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+  return new CancelablePromise(async (resolve3, reject, onCancel) => {
     try {
       const url = getUrl(config, options);
       const formData = getFormData(options);
       const body = getRequestBody(options);
       const headers = await getHeaders(config, options);
       if (!onCancel.isCancelled) {
-        const response = await sendRequest(options, url, body, formData, headers, onCancel);
+        const response = await sendRequest(
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel
+        );
         const responseBody = await getResponseBody(response);
-        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
         const result = {
           url,
           ok: response.ok,
@@ -1403,7 +1809,7 @@ var request = (config, options) => {
           body: responseHeader ?? responseBody
         };
         catchErrorCodes(options, result);
-        resolve2(result.body);
+        resolve3(result.body);
       }
     } catch (error) {
       reject(error);
@@ -1416,6 +1822,18 @@ var HumanTaskService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * List tasks by filters - task name, state, assignee, assignee type, claimed
+   * @param state
+   * @param assignee
+   * @param assigneeType
+   * @param claimedBy
+   * @param taskName
+   * @param freeText
+   * @param includeInputOutput
+   * @returns SearchResultHumanTaskEntry OK
+   * @throws ApiError
+   */
   getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -1431,12 +1849,29 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Get task load grouped by workflow name and task ref name per user
+   * @returns HumanTaskLoad OK
+   * @throws ApiError
+   */
   getTaskLoad() {
     return this.httpRequest.request({
       method: "GET",
       url: "/human/tasks/load"
     });
   }
+  /**
+   * Search human tasks
+   * @param queryId
+   * @param start
+   * @param size
+   * @param freeText
+   * @param query
+   * @param jsonQuery
+   * @param includeInputOutput
+   * @returns HTScrollableSearchResultHumanTaskEntry OK
+   * @throws ApiError
+   */
   search1(queryId, start, size = 100, freeText = "*", query, jsonQuery, includeInputOutput = false) {
     return this.httpRequest.request({
       method: "GET",
@@ -1452,6 +1887,12 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * If the workflow is disconnected from tasks, this API can be used to clean up
+   * @param taskId
+   * @returns any OK
+   * @throws ApiError
+   */
   updateTaskOutput1(taskId) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -1461,6 +1902,12 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Get a task
+   * @param taskId
+   * @returns HumanTaskEntry OK
+   * @throws ApiError
+   */
   getTask1(taskId) {
     return this.httpRequest.request({
       method: "GET",
@@ -1470,6 +1917,12 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Get human task action log entries by task id
+   * @param taskId
+   * @returns HumanTaskActionLogEntry OK
+   * @throws ApiError
+   */
   getActionLogs(taskId) {
     return this.httpRequest.request({
       method: "GET",
@@ -1479,6 +1932,12 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Claim a task by authenticated Conductor user
+   * @param taskId
+   * @returns any OK
+   * @throws ApiError
+   */
   claimTask(taskId) {
     return this.httpRequest.request({
       method: "POST",
@@ -1488,6 +1947,13 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Claim a task to an external user
+   * @param taskId
+   * @param userId
+   * @returns any OK
+   * @throws ApiError
+   */
   assignAndClaim(taskId, userId) {
     return this.httpRequest.request({
       method: "POST",
@@ -1498,6 +1964,13 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Release a task without completing it
+   * @param taskId
+   * @param requestBody
+   * @returns any OK
+   * @throws ApiError
+   */
   reassignTask(taskId, requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -1509,6 +1982,12 @@ var HumanTaskService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Release a task without completing it
+   * @param taskId
+   * @returns any OK
+   * @throws ApiError
+   */
   releaseTask(taskId) {
     return this.httpRequest.request({
       method: "POST",
@@ -1518,6 +1997,12 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Get human task state log entries by task id
+   * @param taskId
+   * @returns HumanTaskStateLogEntry OK
+   * @throws ApiError
+   */
   getStateLogs(taskId) {
     return this.httpRequest.request({
       method: "GET",
@@ -1527,6 +2012,14 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Update task output, optionally complete
+   * @param taskId
+   * @param requestBody
+   * @param complete
+   * @returns any OK
+   * @throws ApiError
+   */
   updateTaskOutput(taskId, requestBody, complete = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -1541,6 +2034,12 @@ var HumanTaskService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Delete human task templates by name
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
   deleteTemplatesByName(name) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -1550,6 +2049,13 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * List all human task templates or get templates by name, or a template by name and version
+   * @param name
+   * @param version
+   * @returns HumanTaskTemplateEntry OK
+   * @throws ApiError
+   */
   getAllTemplates(name, version) {
     return this.httpRequest.request({
       method: "GET",
@@ -1560,6 +2066,13 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Save human task template
+   * @param requestBody
+   * @param newVersion
+   * @returns string OK
+   * @throws ApiError
+   */
   saveTemplate(requestBody, newVersion = false) {
     return this.httpRequest.request({
       method: "POST",
@@ -1571,6 +2084,12 @@ var HumanTaskService = class {
       mediaType: "application/json"
     });
   }
+  /**
+   * Delete human task template
+   * @param id
+   * @returns any OK
+   * @throws ApiError
+   */
   deleteTemplateById(id) {
     return this.httpRequest.request({
       method: "DELETE",
@@ -1580,6 +2099,12 @@ var HumanTaskService = class {
       }
     });
   }
+  /**
+   * Get human task template by id
+   * @param id
+   * @returns HumanTaskTemplateEntry OK
+   * @throws ApiError
+   */
   getTemplateById(id) {
     return this.httpRequest.request({
       method: "GET",
@@ -1596,6 +2121,12 @@ var HumanTaskResourceService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
+  /**
+   * Get Conductor task by id (for human tasks only)
+   * @param taskId
+   * @returns Task OK
+   * @throws ApiError
+   */
   getConductorTaskById(taskId) {
     return this.httpRequest.request({
       method: "GET",
@@ -1608,7 +2139,7 @@ var HumanTaskResourceService = class {
 };
 
 // src/common/open-api/ConductorClient.ts
-var defaultRequestHandler = (request2, config, options) => request2(config, options);
+var defaultRequestHandler = (request3, config, options) => request3(config, options);
 var ConductorClient = class {
   constructor(config, requestHandler = defaultRequestHandler) {
     const resolvedConfig = {
@@ -1642,128 +2173,839 @@ var ConductorClient = class {
   }
 };
 
-// src/common/orkes/OrkesConductorClient.ts
-var defaultRequestHandler2 = (request2, config, options) => request2(config, options);
-var orkesConductorClient = async (config, requestHandler = defaultRequestHandler2) => {
-  if (config?.keySecret != null && config?.keyId != null) {
-    const { serverUrl, keyId, keySecret } = config;
-    const tokenUrl = `${serverUrl}/token`;
-    const res = await fetch(tokenUrl, {
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      body: JSON.stringify({ keyId, keySecret }),
-      method: "POST"
-    });
-    const { token } = await res.json();
-    return new ConductorClient(__spreadProps(__spreadValues({}, config), { TOKEN: token }), requestHandler);
-  } else {
-    return Promise.resolve(new ConductorClient(config, requestHandler));
+// src/common/open-api/core/BaseHttpRequest.ts
+var BaseHttpRequest = class {
+  constructor(config) {
+    this.config = config;
   }
 };
 
-// src/common/types.ts
-var TaskType = /* @__PURE__ */ ((TaskType2) => {
-  TaskType2["START"] = "START";
-  TaskType2["SIMPLE"] = "SIMPLE";
-  TaskType2["DYNAMIC"] = "DYNAMIC";
-  TaskType2["FORK_JOIN"] = "FORK_JOIN";
-  TaskType2["FORK_JOIN_DYNAMIC"] = "FORK_JOIN_DYNAMIC";
-  TaskType2["DECISION"] = "DECISION";
-  TaskType2["SWITCH"] = "SWITCH";
-  TaskType2["JOIN"] = "JOIN";
-  TaskType2["DO_WHILE"] = "DO_WHILE";
-  TaskType2["SUB_WORKFLOW"] = "SUB_WORKFLOW";
-  TaskType2["EVENT"] = "EVENT";
-  TaskType2["WAIT"] = "WAIT";
-  TaskType2["USER_DEFINED"] = "USER_DEFINED";
-  TaskType2["HTTP"] = "HTTP";
-  TaskType2["LAMBDA"] = "LAMBDA";
-  TaskType2["INLINE"] = "INLINE";
-  TaskType2["EXCLUSIVE_JOIN"] = "EXCLUSIVE_JOIN";
-  TaskType2["TERMINAL"] = "TERMINAL";
-  TaskType2["TERMINATE"] = "TERMINATE";
-  TaskType2["KAFKA_PUBLISH"] = "KAFKA_PUBLISH";
-  TaskType2["JSON_JQ_TRANSFORM"] = "JSON_JQ_TRANSFORM";
-  TaskType2["SET_VARIABLE"] = "SET_VARIABLE";
-  return TaskType2;
-})(TaskType || {});
-
-// src/common/generators/common.ts
-var randomChars = (n = 7) => (Math.random() + 1).toString(36).substring(n);
-var taskNameGenerator = (taskType) => `${taskType}__task_${randomChars(7)}`;
-var taskReferenceNameGenerator = (taskName) => `${taskName}_ref`;
-var nameTaskNameGenerator = (taskType, maybeOverrides = {}) => {
-  const name = maybeOverrides?.name ?? taskNameGenerator(taskType);
-  return {
-    name,
-    taskReferenceName: taskReferenceNameGenerator(name)
-  };
+// src/task/Poller.ts
+var Poller = class {
+  constructor(pollFunction, pollerOptions, logger) {
+    this.concurrentCalls = [];
+    this.pollFunction = async () => {
+    };
+    this.polling = false;
+    this.options = {
+      pollInterval: 1e3,
+      concurrency: 1
+    };
+    this.logger = noopLogger;
+    /**
+     * Starts polling for work
+     */
+    this.startPolling = () => {
+      if (this.polling) {
+        throw new Error("Runner is already started");
+      }
+      return this.poll();
+    };
+    /**
+     * Stops Polling for work
+     */
+    this.stopPolling = () => {
+      this.polling = false;
+      this.concurrentCalls.forEach((call) => call.stop());
+    };
+    this.poll = async () => {
+      if (!this.polling) {
+        this.polling = true;
+        for (let i = 0; i < this.options.concurrency; i++) {
+          this.concurrentCalls.push(this.singlePoll());
+        }
+      }
+    };
+    this.singlePoll = () => {
+      let poll = this.polling;
+      let timeout;
+      const pollingCall = async () => {
+        while (poll) {
+          await this.pollFunction();
+          await new Promise(
+            (r) => timeout = setTimeout(() => r(true), this.options.pollInterval)
+          );
+        }
+      };
+      return {
+        promise: pollingCall(),
+        stop: () => {
+          clearTimeout(timeout);
+          poll = false;
+          this.logger.debug("stopping single poll call");
+        }
+      };
+    };
+    this.pollFunction = pollFunction;
+    this.options = { ...this.options, ...pollerOptions };
+    this.logger = logger || noopLogger;
+  }
+  get isPolling() {
+    return this.polling;
+  }
+  /**
+   * adds or shuts down concurrent calls based on the concurrency setting
+   * @param concurrency
+   */
+  updateConcurrency(concurrency) {
+    if (concurrency > 0 && concurrency !== this.options.concurrency) {
+      if (concurrency < this.options.concurrency) {
+        const result = this.concurrentCalls.splice(
+          0,
+          this.options.concurrency - concurrency
+        );
+        result.forEach((call) => {
+          call.stop();
+          this.logger.debug("stopping some spawned calls");
+        });
+      } else {
+        for (let i = 0; i < concurrency - this.options.concurrency; i++) {
+          this.concurrentCalls.push(this.singlePoll());
+          this.logger.debug("spawning additional poll calls");
+        }
+      }
+      this.options.concurrency = concurrency;
+    }
+  }
+  updateOptions(options) {
+    const newOptions = { ...this.options, ...options };
+    this.updateConcurrency(newOptions.concurrency);
+    this.options = newOptions;
+  }
 };
-function mapArrValues(arrayTransformer, mapWithValues) {
-  return Object.fromEntries(Object.entries(mapWithValues).map(([key, value]) => [
-    key,
-    arrayTransformer(value)
-  ]));
-}
 
-// src/common/generators/SimpleTask.ts
-var generateSimpleTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("simple", overrides)), {
-  inputParameters: {}
-}), overrides), {
-  type: "SIMPLE" /* SIMPLE */
-});
-
-// src/common/generators/DoWhileTask.ts
-var generateDoWhileTask = (overrides = {}, nestedTasksMapper) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("doWhile", overrides)), {
-  inputParameters: {},
+// src/task/TaskRunner.ts
+var DEFAULT_ERROR_MESSAGE = "An unknown error occurred";
+var MAX_RETRIES = 3;
+var noopErrorHandler = (__error) => {
+};
+var TaskRunner = class {
+  constructor({
+    worker,
+    taskResource,
+    options,
+    logger = noopLogger,
+    onError: errorHandler = noopErrorHandler
+  }) {
+    /**
+     * Starts polling for work
+     */
+    this.startPolling = () => {
+      this.poller.startPolling();
+    };
+    /**
+     * Stops Polling for work
+     */
+    this.stopPolling = () => {
+      this.poller.stopPolling();
+    };
+    this.pollAndExecute = async () => {
+      try {
+        const { workerID } = this.options;
+        const task = await this.taskResource.poll(
+          this.worker.taskDefName,
+          workerID,
+          this.worker.domain ?? this.options.domain
+        );
+        if (task && task.taskId) {
+          await this.executeTask(task);
+        } else {
+          this.logger.debug(`No tasks for ${this.worker.taskDefName}`);
+        }
+      } catch (unknownError) {
+        this.handleUnknownError(unknownError);
+        this.errorHandler(unknownError);
+      }
+    };
+    this.updateTaskWithRetry = async (task, taskResult) => {
+      let retryCount = 0;
+      while (retryCount < MAX_RETRIES) {
+        try {
+          await this.taskResource.updateTask1(taskResult);
+          return;
+        } catch (error) {
+          this.errorHandler(error, task);
+          this.logger.error(
+            `Error updating task ${taskResult.taskId} on retry ${retryCount}`,
+            error
+          );
+          retryCount++;
+          await new Promise((r) => setTimeout(() => r(true), retryCount * 10));
+        }
+      }
+      this.logger.error(
+        `Unable to update task ${taskResult.taskId} after ${retryCount} retries`
+      );
+    };
+    this.executeTask = async (task) => {
+      try {
+        const result = await this.worker.execute(task);
+        await this.updateTaskWithRetry(task, {
+          ...result,
+          workflowInstanceId: task.workflowInstanceId,
+          taskId: task.taskId
+        });
+        this.logger.debug(`Finished polling for task ${task.taskId}`);
+      } catch (error) {
+        await this.updateTaskWithRetry(task, {
+          workflowInstanceId: task.workflowInstanceId,
+          taskId: task.taskId,
+          reasonForIncompletion: error?.message ?? DEFAULT_ERROR_MESSAGE,
+          status: "FAILED",
+          outputData: {}
+        });
+        this.errorHandler(error, task);
+        this.logger.error(`Error executing ${task.taskId}`, error);
+      }
+    };
+    this.handleUnknownError = (unknownError) => {
+      let message = "";
+      let stack = "";
+      if (unknownError.stack) {
+        stack = unknownError.stack;
+      }
+      if (unknownError.message) {
+        message = unknownError.message;
+      }
+      this.logger.error(
+        `Error for ${this.worker.taskDefName}: error: ${message}, stack: ${stack}`
+      );
+    };
+    this.taskResource = taskResource;
+    this.logger = logger;
+    this.worker = worker;
+    this.options = options;
+    this.errorHandler = errorHandler;
+    this.poller = new Poller(
+      this.pollAndExecute,
+      { concurrency: options.concurrency, pollInterval: options.pollInterval },
+      this.logger
+    );
+  }
+  get isPolling() {
+    return this.poller.isPolling;
+  }
+  updateOptions(options) {
+    const newOptions = { ...this.options, ...options };
+    this.poller.updateOptions({
+      concurrency: newOptions.concurrency,
+      pollInterval: newOptions.pollInterval
+    });
+    this.options = newOptions;
+  }
+  get getOptions() {
+    return this.options;
+  }
+};
+
+// src/task/TaskManager.ts
+import os from "os";
+var defaultManagerOptions = {
+  workerID: "",
+  pollInterval: 1e3,
+  domain: void 0,
+  concurrency: 1
+};
+function workerId(options) {
+  return options.workerID ?? os.hostname();
+}
+var TaskManager = class {
+  constructor(client, workers, config = {}) {
+    this.tasks = {};
+    this.polling = false;
+    this.workerManagerWorkerOptions = (worker) => {
+      return {
+        ...this.options,
+        concurrency: worker.concurrency ?? this.options.concurrency,
+        domain: worker.domain ?? this.options.domain
+      };
+    };
+    /**
+     * new options will get merged to existing options
+     * @param options new options to update polling options
+     */
+    this.updatePollingOptions = (options) => {
+      this.workers.forEach((worker) => {
+        const newOptions = {
+          ...this.workerManagerWorkerOptions(worker),
+          ...options
+        };
+        const runners = this.tasks[worker.taskDefName];
+        runners.forEach((runner) => {
+          runner.updateOptions(newOptions);
+        });
+      });
+      this.options.concurrency = options.concurrency ?? this.options.concurrency;
+      this.options.pollInterval = options.pollInterval ?? this.options.pollInterval;
+    };
+    /**
+     * Start polling for tasks
+     */
+    this.startPolling = () => {
+      this.workers.forEach((worker) => {
+        this.tasks[worker.taskDefName] = [];
+        const options = this.workerManagerWorkerOptions(worker);
+        this.logger.debug(
+          `Starting taskDefName=${worker.taskDefName} concurrency=${options.concurrency} domain=${options.domain}`
+        );
+        const runner = new TaskRunner({
+          worker,
+          options,
+          taskResource: this.client.taskResource,
+          logger: this.logger,
+          onError: this.errorHandler
+        });
+        runner.startPolling();
+        this.tasks[worker.taskDefName].push(runner);
+      });
+      this.polling = true;
+    };
+    /**
+     * Stops polling for tasks
+     */
+    this.stopPolling = () => {
+      for (const taskType in this.tasks) {
+        this.tasks[taskType].forEach((runner) => runner.stopPolling());
+        this.tasks[taskType] = [];
+      }
+      this.polling = false;
+    };
+    if (!workers) {
+      throw new Error(
+        "No workers supplied to TaskManager. Please pass an array of workers."
+      );
+    }
+    this.client = client;
+    this.logger = config.logger ?? new DefaultLogger();
+    this.errorHandler = config.onError ?? noopErrorHandler;
+    this.workers = workers;
+    const providedOptions = config.options ?? {};
+    this.options = {
+      ...defaultManagerOptions,
+      ...providedOptions,
+      workerID: workerId(providedOptions)
+    };
+  }
+  get isPolling() {
+    return this.polling;
+  }
+};
+
+// src/core/types.ts
+var ConductorError = class extends Error {
+  constructor(message, innerError) {
+    super(message);
+    this._trace = innerError;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
+    }
+  }
+};
+
+// src/core/helpers.ts
+var errorMapper = (error) => new ConductorError(error?.body?.message, error);
+var tryCatchReThrow = (fn) => {
+  try {
+    return fn();
+  } catch (error) {
+    throw errorMapper(error);
+  }
+};
+
+// src/core/executor.ts
+var RETRY_TIME_IN_MILLISECONDS = 1e4;
+var WorkflowExecutor = class {
+  constructor(client) {
+    this._client = client;
+  }
+  /**
+   * Will persist a workflow in conductor
+   * @param override If true will override the existing workflow with the definition
+   * @param workflow Complete workflow definition
+   * @returns null
+   */
+  registerWorkflow(override, workflow2) {
+    return tryCatchReThrow(
+      () => this._client.metadataResource.create(workflow2, override)
+    );
+  }
+  /**
+   * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
+   * @param workflowRequest
+   * @returns
+   */
+  startWorkflow(workflowRequest) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.startWorkflow(workflowRequest)
+    );
+  }
+  /**
+   * Execute a workflow synchronously. returns a Promise<WorkflowRun> with details of the running workflow
+   * @param workflowRequest
+   * @returns
+   */
+  executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef = "") {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef)
+    );
+  }
+  startWorkflows(workflowsRequest) {
+    return tryCatchReThrow(() => workflowsRequest.map(this.startWorkflow));
+  }
+  /**
+   * Takes an workflowInstanceId and an includeTasks and an optional retry parameter returns the whole execution status.
+   * If includeTasks flag is provided. Details of tasks execution will be returned as well,
+   * retry specifies the amount of retrys before throwing an error.
+   *
+   * @param workflowInstanceId
+   * @param includeTasks
+   * @param retry
+   * @returns
+   */
+  async getWorkflow(workflowInstanceId, includeTasks, retry = 0) {
+    try {
+      const workflowStatus = await this._client.workflowResource.getExecutionStatus(
+        workflowInstanceId,
+        includeTasks
+      );
+      return workflowStatus;
+    } catch (error) {
+      if (![500, 404, 403].includes(error.status) || retry === 0) {
+        throw errorMapper(error);
+      }
+    }
+    await new Promise(
+      (res) => setTimeout(() => res(true), RETRY_TIME_IN_MILLISECONDS)
+    );
+    return this.getWorkflow(workflowInstanceId, includeTasks, retry - 1);
+  }
+  /**
+   *  Returns a summary of the current workflow status.
+   *
+   * @param workflowInstanceId current running workflow
+   * @param includeOutput flag to include output
+   * @param includeVariables flag to include variable
+   * @returns Promise<WorkflowStatus>
+   */
+  getWorkflowStatus(workflowInstanceId, includeOutput, includeVariables) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.getWorkflowStatusSummary(
+        workflowInstanceId,
+        includeOutput,
+        includeVariables
+      )
+    );
+  }
+  /**
+   * Pauses a running workflow
+   * @param workflowInstanceId current workflow execution
+   * @returns
+   */
+  pause(workflowInstanceId) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.pauseWorkflow(workflowInstanceId)
+    );
+  }
+  /**
+   * Reruns workflowInstanceId workflow. with new parameters
+   *
+   * @param workflowInstanceId current workflow execution
+   * @param rerunWorkflowRequest Rerun Workflow Execution Request
+   * @returns
+   */
+  reRun(workflowInstanceId, rerunWorkflowRequest = {}) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.rerun(
+        workflowInstanceId,
+        rerunWorkflowRequest
+      )
+    );
+  }
+  /**
+   * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
+   * @param workflowInstanceId
+   * @param useLatestDefinitions
+   * @returns
+   */
+  restart(workflowInstanceId, useLatestDefinitions) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.restart1(
+        workflowInstanceId,
+        useLatestDefinitions
+      )
+    );
+  }
+  /**
+   * Resumes a previously paused execution
+   *
+   * @param workflowInstanceId Running workflow workflowInstanceId
+   * @returns
+   */
+  resume(workflowInstanceId) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.resumeWorkflow(workflowInstanceId)
+    );
+  }
+  /**
+   * Retrys workflow from last failing task
+   * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows
+   *
+   * @param workflowInstanceId
+   * @param resumeSubworkflowTasks
+   * @returns
+   */
+  retry(workflowInstanceId, resumeSubworkflowTasks) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.retry1(
+        workflowInstanceId,
+        resumeSubworkflowTasks
+      )
+    );
+  }
+  /**
+   * Searches for existing workflows given the following querys
+   *
+   * @param start
+   * @param size
+   * @param query
+   * @param freeText
+   * @param sort
+   * @param skipCache
+   * @returns
+   */
+  search(start, size, query, freeText, sort = "", skipCache = false) {
+    const queryId = void 0;
+    return tryCatchReThrow(
+      () => this._client.workflowResource.search1(
+        queryId,
+        start,
+        size,
+        sort,
+        freeText,
+        query,
+        skipCache
+      )
+    );
+  }
+  /**
+   * Skips a task of a running workflow.
+   * by providing a skipTaskRequest you can set the input and the output of the skipped tasks
+   * @param workflowInstanceId
+   * @param taskReferenceName
+   * @param skipTaskRequest
+   * @returns
+   */
+  skipTasksFromWorkflow(workflowInstanceId, taskReferenceName, skipTaskRequest) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.skipTaskFromWorkflow(
+        workflowInstanceId,
+        taskReferenceName,
+        skipTaskRequest
+      )
+    );
+  }
+  /**
+   * Takes an workflowInstanceId, and terminates a running workflow
+   * @param workflowInstanceId
+   * @param reason
+   * @returns
+   */
+  terminate(workflowInstanceId, reason) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.terminate1(workflowInstanceId, reason)
+    );
+  }
+  /**
+   * Takes a taskId and a workflowInstanceId. Will update the task for the corresponding taskId
+   * @param taskId
+   * @param workflowInstanceId
+   * @param taskStatus
+   * @param taskOutput
+   * @returns
+   */
+  updateTask(taskId, workflowInstanceId, taskStatus, outputData) {
+    const taskUpdates = {
+      status: taskStatus,
+      taskId,
+      workflowInstanceId
+    };
+    return tryCatchReThrow(
+      () => this._client.taskResource.updateTask1({
+        outputData,
+        ...taskUpdates
+      })
+    );
+  }
+  /**
+   * Updates a task by reference Name
+   * @param taskReferenceName
+   * @param workflowInstanceId
+   * @param status
+   * @param taskOutput
+   * @returns
+   */
+  updateTaskByRefName(taskReferenceName, workflowInstanceId, status, taskOutput) {
+    return tryCatchReThrow(
+      () => this._client.taskResource.updateTask(
+        workflowInstanceId,
+        taskReferenceName,
+        status,
+        taskOutput
+      )
+    );
+  }
+  /**
+   *
+   * @param taskId
+   * @returns
+   */
+  getTask(taskId) {
+    return tryCatchReThrow(() => this._client.taskResource.getTask(taskId));
+  }
+};
+
+// src/core/human.ts
+var HumanExecutor = class {
+  constructor(client) {
+    this._client = client;
+  }
+  /**
+   * Takes a set of filter parameters. return matches of human tasks for that set of parameters
+   * @param state
+   * @param assignee
+   * @param assigneeType
+   * @param claimedBy
+   * @param taskName
+   * @param freeText
+   * @param includeInputOutput
+   * @returns
+   */
+  async getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
+    const response = await this._client.humanTask.getTasksByFilter(
+      state,
+      assignee,
+      assigneeType,
+      claimedBy,
+      taskName,
+      freeText,
+      includeInputOutput
+    );
+    if (response.results != void 0) {
+      return response.results;
+    }
+    return [];
+  }
+  /**
+   * Returns task for a given task id
+   * @param taskId
+   * @returns
+   */
+  getTaskById(taskId) {
+    return tryCatchReThrow(() => this._client.humanTask.getTask1(taskId));
+  }
+  /**
+   * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
+   * @param taskId
+   * @param assignee
+   * @returns
+   */
+  async claimTaskAsExternalUser(taskId, assignee) {
+    try {
+      await this._client.humanTask.assignAndClaim(taskId, assignee);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  /**
+   * Claim task as conductor user
+   * @param taskId
+   * @returns
+   */
+  async claimTaskAsConductorUser(taskId) {
+    try {
+      await this._client.humanTask.claimTask(taskId);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  /**
+   * Claim task as conductor user
+   * @param taskId
+   * @param assignee
+   * @returns
+   */
+  async releaseTask(taskId) {
+    try {
+      await this._client.humanTask.releaseTask(taskId);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  /**
+   * Returns a HumanTaskTemplateEntry for a given templateId
+   * @param templateId
+   * @returns
+   */
+  async getTemplateById(templateId) {
+    return tryCatchReThrow(
+      () => this._client.humanTask.getTemplateById(templateId)
+    );
+  }
+  /**
+   * Takes a taskId and a partial body. will update with given body
+   * @param taskId
+   * @param requestBody
+   */
+  async updateTaskOutput(taskId, requestBody) {
+    try {
+      await this._client.humanTask.updateTaskOutput(taskId, requestBody, false);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  /**
+   * Takes a taskId and an optional partial body. will complete the task with the given body
+   * @param taskId
+   * @param requestBody
+   */
+  async completeTask(taskId, requestBody = {}) {
+    try {
+      await this._client.humanTask.updateTaskOutput(taskId, requestBody, true);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+};
+
+// src/core/sdk/doWhile.ts
+var doWhileTask = (taskRefName, terminationCondition, tasks) => ({
+  name: taskRefName,
+  taskReferenceName: taskRefName,
+  loopCondition: terminationCondition,
+  inputParameters: {},
+  type: "DO_WHILE" /* DO_WHILE */,
+  loopOver: tasks
+});
+var loopForCondition = (taskRefName, valueKey) => `if ( $.${taskRefName}['iteration'] < $.${valueKey} ) { true; } else { false; }`;
+var newLoopTask = (taskRefName, iterations, tasks) => ({
+  name: taskRefName,
+  taskReferenceName: taskRefName,
+  loopCondition: loopForCondition(taskRefName, "value"),
+  inputParameters: {
+    value: iterations
+  },
+  type: "DO_WHILE" /* DO_WHILE */,
+  loopOver: tasks
+});
+
+// src/core/sdk/dynamicFork.ts
+var dynamicForkTask = (taskReferenceName, preForkTasks = [], dynamicTasksInput = "") => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    dynamicTasks: preForkTasks,
+    dynamicTasksInput
+  },
+  type: "FORK_JOIN_DYNAMIC" /* FORK_JOIN_DYNAMIC */,
+  dynamicForkTasksParam: "dynamicTasks",
+  dynamicForkTasksInputParamName: "dynamicTasksInput"
+});
+
+// src/core/sdk/event.ts
+var eventTask = (taskReferenceName, eventPrefix, eventSuffix) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  sink: `${eventPrefix}:${eventSuffix}`,
+  type: "EVENT" /* EVENT */
+});
+var sqsEventTask = (taskReferenceName, queueName) => eventTask(taskReferenceName, "sqs", queueName);
+var conductorEventTask = (taskReferenceName, eventName) => eventTask(taskReferenceName, "conductor", eventName);
+
+// src/core/generators/common.ts
+var randomChars = (n = 7) => (Math.random() + 1).toString(36).substring(n);
+var taskNameGenerator = (taskType) => `${taskType}__task_${randomChars(7)}`;
+var taskReferenceNameGenerator = (taskName) => `${taskName}_ref`;
+var nameTaskNameGenerator = (taskType, maybeOverrides = {}) => {
+  const name = maybeOverrides?.name ?? taskNameGenerator(taskType);
+  return {
+    name,
+    taskReferenceName: taskReferenceNameGenerator(name)
+  };
+};
+function mapArrValues(arrayTransformer, mapWithValues) {
+  return Object.fromEntries(
+    Object.entries(mapWithValues).map(([key, value]) => [
+      key,
+      arrayTransformer(value)
+    ])
+  );
+}
+
+// src/core/generators/SimpleTask.ts
+var generateSimpleTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("simple", overrides),
+  inputParameters: {},
+  ...overrides,
+  type: "SIMPLE" /* SIMPLE */
+});
+
+// src/core/generators/DoWhileTask.ts
+var generateDoWhileTask = (overrides = {}, nestedTasksMapper) => ({
+  ...nameTaskNameGenerator("doWhile", overrides),
+  inputParameters: {},
   startDelay: 0,
   optional: false,
   asyncComplete: false,
-  loopCondition: ""
-}), overrides), {
+  loopCondition: "",
+  ...overrides,
   loopOver: nestedTasksMapper(overrides?.loopOver || []),
   type: "DO_WHILE" /* DO_WHILE */
 });
 
-// src/common/generators/EventTask.ts
-var generateEventTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("event", overrides)), {
+// src/core/generators/EventTask.ts
+var generateEventTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("event", overrides),
   sink: "sqs:sqs_queue_name",
-  asyncComplete: false
-}), overrides), {
+  asyncComplete: false,
+  ...overrides,
   type: "EVENT" /* EVENT */
 });
 
-// src/common/generators/ForkJoin.ts
-var generateForkJoinTask = (overrides = {}, nestedMapper) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("forkJoin", overrides)), {
-  inputParameters: {}
-}), overrides), {
+// src/core/generators/ForkJoin.ts
+var generateForkJoinTask = (overrides = {}, nestedMapper) => ({
+  ...nameTaskNameGenerator("forkJoin", overrides),
+  inputParameters: {},
+  ...overrides,
   type: "FORK_JOIN" /* FORK_JOIN */,
   forkTasks: (overrides?.forkTasks || []).map(nestedMapper)
 });
-var generateJoinTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("join", overrides)), {
+var generateJoinTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("join", overrides),
   inputParameters: {},
   joinOn: [],
   optional: false,
-  asyncComplete: false
-}), overrides), {
+  asyncComplete: false,
+  ...overrides,
   type: "JOIN" /* JOIN */
 });
 
-// src/common/generators/HttpTask.ts
-var generateHTTPTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("httpTask", overrides)), {
+// src/core/generators/HttpTask.ts
+var generateHTTPTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("httpTask", overrides),
   inputParameters: {
     http_request: {
       uri: "https://jsonplaceholder.typicode.com/posts/${workflow.input.queryid}",
       method: "GET"
     }
-  }
-}), overrides), {
+  },
+  ...overrides,
   type: "HTTP" /* HTTP */
 });
 
-// src/common/generators/InlineTask.ts
+// src/core/generators/InlineTask.ts
 var defaultInputParams = {
   value: "${workflow.input.value}",
   evaluatorType: "graaljs",
@@ -1775,24 +3017,29 @@ var generateEvaluationCode = (inputParametersPartial = {}) => {
   if (inlineExpression !== void 0 && typeof inlineExpression === "function") {
     const resultingFunction = inlineExpression();
     const resultingFunctionAsString = resultingFunction.toString();
-    const toReturn = __spreadProps(__spreadValues({
-      evaluatorType: "graaljs"
-    }, inputParametersPartial || { value: "true" }), {
+    const toReturn = {
+      evaluatorType: "graaljs",
+      ...inputParametersPartial || { value: "true" },
       expression: `(${resultingFunctionAsString})();`
-    });
+    };
     return toReturn;
   }
-  return __spreadValues(__spreadProps(__spreadValues({}, defaultInputParams), {
-    evaluatorType: "graaljs"
-  }), inputParametersPartial);
+  return {
+    ...defaultInputParams,
+    evaluatorType: "graaljs",
+    ...inputParametersPartial
+  };
 };
-var generateInlineTask = (override = {}) => __spreadProps(__spreadValues(__spreadValues({}, nameTaskNameGenerator("inline", override)), override), {
+var generateInlineTask = (override = {}) => ({
+  ...nameTaskNameGenerator("inline", override),
+  ...override,
   inputParameters: generateEvaluationCode(override?.inputParameters || {}),
   type: "INLINE" /* INLINE */
 });
 
-// src/common/generators/JsonJQTransform.ts
-var generateJQTransformTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("jqTransform", overrides)), {
+// src/core/generators/JsonJQTransform.ts
+var generateJQTransformTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("jqTransform", overrides),
   inputParameters: {
     key1: {
       value1: ["a", "b"]
@@ -1801,13 +3048,14 @@ var generateJQTransformTask = (overrides = {}) => __spreadProps(__spreadValues(_
       value2: ["c", "d"]
     },
     queryExpression: "{ key3: (.key1.value1 + .key2.value2) }"
-  }
-}), overrides), {
+  },
+  ...overrides,
   type: "JSON_JQ_TRANSFORM" /* JSON_JQ_TRANSFORM */
 });
 
-// src/common/generators/KafkaTask.ts
-var generateKafkaPublishTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("kafka", overrides)), {
+// src/core/generators/KafkaTask.ts
+var generateKafkaPublishTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("kafka", overrides),
   inputParameters: {
     kafka_request: {
       topic: "topic",
@@ -1817,65 +3065,72 @@ var generateKafkaPublishTask = (overrides = {}) => __spreadProps(__spreadValues(
       key: "123",
       keySerializer: "org.apache.kafka.common.serialization.IntegerSerializer"
     }
-  }
-}), overrides), {
+  },
+  ...overrides,
   type: "KAFKA_PUBLISH" /* KAFKA_PUBLISH */
 });
 
-// src/common/generators/SubWorkflowTask.ts
-var generateSubWorkflowTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("subWorkflow", overrides)), {
+// src/core/generators/SubWorkflowTask.ts
+var generateSubWorkflowTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("subWorkflow", overrides),
   inputParameters: {},
   subWorkflowParam: {
     name: "name",
     version: 1,
     taskToDomain: {}
-  }
-}), overrides), {
+  },
+  ...overrides,
   type: "SUB_WORKFLOW" /* SUB_WORKFLOW */
 });
 
-// src/common/generators/SetVariableTask.ts
-var generateSetVariableTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("setVariable", overrides)), {
-  inputParameters: {}
-}), overrides), {
+// src/core/generators/SetVariableTask.ts
+var generateSetVariableTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("setVariable", overrides),
+  inputParameters: {},
+  ...overrides,
   type: "SET_VARIABLE" /* SET_VARIABLE */
 });
 
-// src/common/generators/TerminateTask.ts
-var generateTerminateTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("terminate", overrides)), {
+// src/core/generators/TerminateTask.ts
+var generateTerminateTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("terminate", overrides),
   inputParameters: {
     terminationStatus: "COMPLETED",
     workflowOutput: {}
   },
   startDelay: 0,
-  optional: false
-}), overrides), {
+  optional: false,
+  ...overrides,
   type: "TERMINATE" /* TERMINATE */
 });
 
-// src/common/generators/WaitTask.ts
-var generateWaitTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadValues({}, nameTaskNameGenerator("wait", overrides)), overrides), {
+// src/core/generators/WaitTask.ts
+var generateWaitTask = (overrides = {}) => ({
+  ...nameTaskNameGenerator("wait", overrides),
+  ...overrides,
   inputParameters: {},
   type: "WAIT" /* WAIT */
 });
 
-// src/common/generators/SwitchTask.ts
+// src/core/generators/SwitchTask.ts
 var fillSwitchTaskBranches = (task, mapper) => ({
   decisionCases: mapArrValues(mapper, task?.decisionCases || {}),
   defaultCase: mapper(task?.defaultCase || [])
 });
-var generateSwitchTask = (overrides = {}, nestedTasksMapper) => __spreadProps(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("switch", overrides)), {
+var generateSwitchTask = (overrides = {}, nestedTasksMapper) => ({
+  ...nameTaskNameGenerator("switch", overrides),
   inputParameters: {
     switchCaseValue: ""
   },
   evaluatorType: "value-param",
-  expression: "switchCaseValue"
-}), overrides), fillSwitchTaskBranches(overrides, nestedTasksMapper)), {
+  expression: "switchCaseValue",
+  ...overrides,
+  ...fillSwitchTaskBranches(overrides, nestedTasksMapper),
   type: "SWITCH" /* SWITCH */
 });
 
-// src/common/generators/WorkflowGenerator.ts
-var workflowGenerator = (overrides) => __spreadValues({
+// src/core/generators/WorkflowGenerator.ts
+var workflowGenerator = (overrides) => ({
   name: "NewWorkflow_3nxbi",
   description: "Edit or extend this sample workflow. Set the workflow name to get started",
   version: 1,
@@ -1887,11 +3142,13 @@ var workflowGenerator = (overrides) => __spreadValues({
   workflowStatusListenerEnabled: false,
   ownerEmail: "james.stuart@orkes.io",
   timeoutPolicy: "ALERT_ONLY",
-  timeoutSeconds: 0
-}, overrides);
+  timeoutSeconds: 0,
+  ...overrides
+});
 
-// src/common/generators/ForkJoinDynamicTask.ts
-var generateForkJoinDynamic = (overrides = {}) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("forkJoinDynamic", overrides)), {
+// src/core/generators/ForkJoinDynamicTask.ts
+var generateForkJoinDynamic = (overrides = {}) => ({
+  ...nameTaskNameGenerator("forkJoinDynamic", overrides),
   inputParameters: {
     dynamicTasks: "",
     dynamicTasksInput: ""
@@ -1900,12 +3157,12 @@ var generateForkJoinDynamic = (overrides = {}) => __spreadProps(__spreadValues(_
   dynamicForkTasksInputParamName: "dynamicTasksInput",
   startDelay: 0,
   optional: false,
-  asyncComplete: false
-}), overrides), {
+  asyncComplete: false,
+  ...overrides,
   type: "FORK_JOIN_DYNAMIC" /* FORK_JOIN_DYNAMIC */
 });
 
-// src/common/generators/generator.ts
+// src/core/generators/generator.ts
 var filledTaskDef = (task) => {
   const taskType = task.type;
   switch (taskType) {
@@ -1957,59 +3214,15 @@ var maybeAddJoinTask = (currentTask, maybeNextTask) => {
 var generate = (overrides) => {
   const maybeTasks = overrides.tasks || [];
   const generatedTasks = taskGenMapper(maybeTasks);
-  return workflowGenerator(__spreadProps(__spreadValues({}, overrides), { tasks: generatedTasks }));
+  return workflowGenerator({ ...overrides, tasks: generatedTasks });
 };
 
-// src/common/generators/index.ts
+// src/core/generators/index.ts
 var generateSwitchTask2 = (overrides = {}, nestedTasksMapper = taskGenMapper) => generateSwitchTask(overrides, nestedTasksMapper);
 var generateDoWhileTask2 = (overrides = {}, nestedTasksMapper = taskGenMapper) => generateDoWhileTask(overrides, nestedTasksMapper);
 var generateForkJoinTask2 = (overrides = {}, nestedMapper = taskGenMapper) => generateForkJoinTask(overrides, nestedMapper);
 
-// src/common/sdk/doWhile.ts
-var doWhileTask = (taskRefName, terminationCondition, tasks) => ({
-  name: taskRefName,
-  taskReferenceName: taskRefName,
-  loopCondition: terminationCondition,
-  inputParameters: {},
-  type: "DO_WHILE" /* DO_WHILE */,
-  loopOver: tasks
-});
-var loopForCondition = (taskRefName, valueKey) => `if ( $.${taskRefName}['iteration'] < $.${valueKey} ) { true; } else { false; }`;
-var newLoopTask = (taskRefName, iterations, tasks) => ({
-  name: taskRefName,
-  taskReferenceName: taskRefName,
-  loopCondition: loopForCondition(taskRefName, "value"),
-  inputParameters: {
-    value: iterations
-  },
-  type: "DO_WHILE" /* DO_WHILE */,
-  loopOver: tasks
-});
-
-// src/common/sdk/dynamicFork.ts
-var dynamicForkTask = (taskReferenceName, preForkTasks = [], dynamicTasksInput = "") => ({
-  name: taskReferenceName,
-  taskReferenceName,
-  inputParameters: {
-    dynamicTasks: preForkTasks,
-    dynamicTasksInput
-  },
-  type: "FORK_JOIN_DYNAMIC" /* FORK_JOIN_DYNAMIC */,
-  dynamicForkTasksParam: "dynamicTasks",
-  dynamicForkTasksInputParamName: "dynamicTasksInput"
-});
-
-// src/common/sdk/event.ts
-var eventTask = (taskReferenceName, eventPrefix, eventSuffix) => ({
-  name: taskReferenceName,
-  taskReferenceName,
-  sink: `${eventPrefix}:${eventSuffix}`,
-  type: "EVENT" /* EVENT */
-});
-var sqsEventTask = (taskReferenceName, queueName) => eventTask(taskReferenceName, "sqs", queueName);
-var conductorEventTask = (taskReferenceName, eventName) => eventTask(taskReferenceName, "conductor", eventName);
-
-// src/common/sdk/forkJoin.ts
+// src/core/sdk/forkJoin.ts
 var forkTask = (taskReferenceName, forkTasks) => ({
   taskReferenceName,
   name: taskReferenceName,
@@ -2021,7 +3234,7 @@ var forkTaskJoin = (taskReferenceName, forkTasks) => [
   generateJoinTask({ name: `${taskReferenceName}_join` })
 ];
 
-// src/common/sdk/http.ts
+// src/core/sdk/http.ts
 var httpTask = (taskReferenceName, inputParameters) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2031,7 +3244,7 @@ var httpTask = (taskReferenceName, inputParameters) => ({
   type: "HTTP" /* HTTP */
 });
 
-// src/common/sdk/inline.ts
+// src/core/sdk/inline.ts
 var inlineTask = (taskReferenceName, script, evaluatorType = "javascript") => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2042,7 +3255,7 @@ var inlineTask = (taskReferenceName, script, evaluatorType = "javascript") => ({
   type: "INLINE" /* INLINE */
 });
 
-// src/common/sdk/join.ts
+// src/core/sdk/join.ts
 var joinTask = (taskReferenceName, joinOn) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2050,7 +3263,7 @@ var joinTask = (taskReferenceName, joinOn) => ({
   type: "JOIN" /* JOIN */
 });
 
-// src/common/sdk/jsonJq.ts
+// src/core/sdk/jsonJq.ts
 var jsonJqTask = (taskReferenceName, script) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2060,7 +3273,7 @@ var jsonJqTask = (taskReferenceName, script) => ({
   }
 });
 
-// src/common/sdk/kafkaPublish.ts
+// src/core/sdk/kafkaPublish.ts
 var kafkaPublishTask = (taskReferenceName, kafka_request) => ({
   taskReferenceName,
   name: taskReferenceName,
@@ -2070,7 +3283,7 @@ var kafkaPublishTask = (taskReferenceName, kafka_request) => ({
   }
 });
 
-// src/common/sdk/setVariable.ts
+// src/core/sdk/setVariable.ts
 var setVariableTask = (taskReferenceName, inputParameters) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2078,7 +3291,7 @@ var setVariableTask = (taskReferenceName, inputParameters) => ({
   inputParameters
 });
 
-// src/common/sdk/simple.ts
+// src/core/sdk/simple.ts
 var simpleTask = (taskReferenceName, name, inputParameters) => ({
   name,
   taskReferenceName,
@@ -2086,7 +3299,7 @@ var simpleTask = (taskReferenceName, name, inputParameters) => ({
   type: "SIMPLE" /* SIMPLE */
 });
 
-// src/common/sdk/subWorkflow.ts
+// src/core/sdk/subWorkflow.ts
 var subWorkflowTask = (taskReferenceName, workflowName, version) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2097,7 +3310,7 @@ var subWorkflowTask = (taskReferenceName, workflowName, version) => ({
   type: "SUB_WORKFLOW" /* SUB_WORKFLOW */
 });
 
-// src/common/sdk/switch.ts
+// src/core/sdk/switch.ts
 var switchTask = (taskReferenceName, expression, decisionCases = {}, defaultCase = []) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2111,7 +3324,7 @@ var switchTask = (taskReferenceName, expression, decisionCases = {}, defaultCase
   type: "SWITCH" /* SWITCH */
 });
 
-// src/common/sdk/terminate.ts
+// src/core/sdk/terminate.ts
 var terminateTask = (taskReferenceName, status, terminationReason) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2122,7 +3335,7 @@ var terminateTask = (taskReferenceName, status, terminationReason) => ({
   type: "TERMINATE" /* TERMINATE */
 });
 
-// src/common/sdk/wait.ts
+// src/core/sdk/wait.ts
 var waitTaskDuration = (taskReferenceName, duration) => ({
   name: taskReferenceName,
   taskReferenceName,
@@ -2140,240 +3353,369 @@ var waitTaskUntil = (taskReferenceName, until) => ({
   type: "WAIT" /* WAIT */
 });
 
-// src/common/sdk/workflow.ts
-var workflow = (name, tasks) => ({
-  name,
-  version: 1,
-  tasks,
-  inputParameters: [],
-  timeoutSeconds: 0
-});
-
-// src/common/open-api/core/BaseHttpRequest.ts
-var BaseHttpRequest = class {
-  constructor(config) {
-    this.config = config;
-  }
-};
-
-// src/task/TaskManager.ts
-var defaultManagerOptions = {
-  workerID: "",
-  pollInterval: 1e3,
-  domain: void 0,
-  concurrency: 1
-};
-function workerId(options) {
-  return options.workerID ?? os.hostname();
-}
-var TaskManager = class {
-  constructor(client, workers, config = {}) {
-    this.tasks = {};
-    this.workerManagerWorkerOptions = (worker) => {
-      return __spreadProps(__spreadValues({}, this.taskManageOptions), {
-        concurrency: worker.concurrency ?? this.taskManageOptions.concurrency,
-        domain: worker.domain ?? this.taskManageOptions.domain
-      });
-    };
-    this.updatePollingOptions = (options) => {
-      this.workers.forEach((worker) => {
-        const newOptions = __spreadValues(__spreadValues({}, this.workerManagerWorkerOptions(worker)), options);
-        const runners = this.tasks[worker.taskDefName];
-        runners.forEach((runner) => {
-          runner.updateOptions(newOptions);
-        });
-      });
-    };
-    this.startPolling = () => {
-      this.workers.forEach((worker) => {
-        this.tasks[worker.taskDefName] = [];
-        const options = this.workerManagerWorkerOptions(worker);
-        this.logger.debug(`Starting taskDefName=${worker.taskDefName} concurrency=${options.concurrency} domain=${options.domain}`);
-        const runner = new TaskRunner({
-          worker,
-          options,
-          taskResource: this.client.taskResource,
-          logger: this.logger,
-          onError: this.errorHandler
-        });
-        runner.startPolling();
-        this.tasks[worker.taskDefName].push(runner);
-      });
-    };
-    this.stopPolling = () => {
-      for (const taskType in this.tasks) {
-        this.tasks[taskType].forEach((runner) => runner.stopPolling());
-        this.tasks[taskType] = [];
-      }
-    };
-    if (!workers) {
-      throw new Error("No workers supplied to TaskManager. Please pass an array of workers.");
-    }
-    this.client = client;
-    this.logger = config.logger ?? new DefaultLogger();
-    this.errorHandler = config.onError ?? noopErrorHandler;
-    this.workers = workers;
-    const providedOptions = config.options ?? {};
-    this.taskManageOptions = __spreadProps(__spreadValues(__spreadValues({}, defaultManagerOptions), providedOptions), {
-      workerID: workerId(providedOptions)
-    });
-  }
-};
-
-// src/core/types.ts
-var ConductorError = class extends Error {
-  constructor(message, innerError) {
-    super(message);
-    this._trace = innerError;
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      this.__proto__ = actualProto;
-    }
-  }
-};
-
-// src/core/helpers.ts
-var errorMapper = (error) => new ConductorError(error?.body?.message, error);
-var tryCatchReThrow = (fn) => {
+// src/core/sdk/workflow.ts
+var workflow = (name, tasks) => ({
+  name,
+  version: 1,
+  tasks,
+  inputParameters: [],
+  timeoutSeconds: 0
+});
+
+// src/orkes/request/fetchCatchDns/DnsResolver.ts
+import { promises } from "dns";
+var DEFAULT_OPTIONS = {
+  logger: noopLogger,
+  resolver: promises.resolve4
+};
+var dnsResolver = async (host, { resolver = promises.resolve4, logger = console } = DEFAULT_OPTIONS) => {
   try {
-    return fn();
-  } catch (error) {
-    throw errorMapper(error);
+    const addresses = await resolver(host);
+    if (addresses.length > 0)
+      return addresses[0];
+  } catch (e) {
+    logger.error("Could not resolve host: " + host + " error: " + e);
   }
+  return void 0;
 };
 
-// src/core/executor.ts
-var RETRY_TIME_IN_MILLISECONDS = 1e4;
-var WorkflowExecutor = class {
-  constructor(client) {
-    this._client = client;
-  }
-  registerWorkflow(override, workflow2) {
-    return tryCatchReThrow(() => this._client.metadataResource.create(workflow2, override));
+// src/orkes/request/fetchCatchDns/DnsCache.ts
+var DnsCacheResolver = class {
+  constructor({ initialCache = /* @__PURE__ */ new Map() } = {}) {
+    this._cache = /* @__PURE__ */ new Map();
+    this._cache = initialCache;
+  }
+  async resolve(host) {
+    const cachedIp = this._cache.get(host);
+    if (cachedIp) {
+      return cachedIp;
+    }
+    const ip = await dnsResolver(host);
+    if (ip != void 0) {
+      this._cache.set(host, ip);
+    }
+    return ip;
   }
-  startWorkflow(workflowRequest) {
-    return tryCatchReThrow(() => this._client.workflowResource.startWorkflow(workflowRequest));
+  clearCache() {
+    this._cache.clear();
   }
-  executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef = "") {
-    return tryCatchReThrow(() => this._client.workflowResource.executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef));
+  get cache() {
+    return this._cache;
   }
-  startWorkflows(workflowsRequest) {
-    return tryCatchReThrow(() => workflowsRequest.map(this.startWorkflow));
+};
+
+// src/orkes/request/fetchCatchDns/fetchCatchDns.ts
+import { isIP } from "net";
+var isEmpty = (value) => {
+  return value === void 0 || value.trim().length === 0;
+};
+var toMaybeUrl = (originalUrl, modifiedParams) => {
+  const urlToHit = new URL(originalUrl.toString());
+  urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
+  return urlToHit;
+};
+var DEFAULT_OPTIONS2 = {
+  dnsCache: new DnsCacheResolver(),
+  headerFactory: (headers) => new Headers(headers || {})
+};
+var fetchCatchDns = (fetch2, {
+  dnsCache = new DnsCacheResolver(),
+  headerFactory = (headers) => new Headers(headers || {})
+} = DEFAULT_OPTIONS2) => {
+  const fetchWithDns = async (input, options) => {
+    const parsedUrl = new URL(input.toString());
+    const { hostname, host, port } = parsedUrl;
+    if (isIP(hostname)) {
+      return await fetch2(input, options);
+    }
+    const maybeTargetIp = await dnsCache.resolve(hostname);
+    if (isEmpty(maybeTargetIp)) {
+      return await fetch2(input, options);
+    }
+    const target = toMaybeUrl(input, {
+      ...parsedUrl,
+      host: maybeTargetIp,
+      port
+    });
+    const headersOverride = headerFactory(options?.headers ?? {});
+    if (!headersOverride.has("Host")) {
+      headersOverride.set("Host", host);
+    }
+    const optionsOverride = {
+      ...options,
+      headers: headersOverride
+    };
+    const res = await fetch2(target.toString(), optionsOverride);
+    return res;
+  };
+  return fetchWithDns;
+};
+
+// src/orkes/request/request.ts
+var isDefined2 = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString2 = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue2 = (value) => {
+  return isString2(value) && value !== "";
+};
+var isBlob2 = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData2 = (value) => {
+  return value instanceof FormData;
+};
+var base642 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
   }
-  async getWorkflow(workflowInstanceId, includeTasks, retry = 0) {
-    try {
-      const workflowStatus = await this._client.workflowResource.getExecutionStatus(workflowInstanceId, includeTasks);
-      return workflowStatus;
-    } catch (error) {
-      if (![500, 404, 403].includes(error.status) || retry === 0) {
-        throw errorMapper(error);
+};
+var getQueryString2 = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined2(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
       }
     }
-    await new Promise((res) => setTimeout(() => res(true), RETRY_TIME_IN_MILLISECONDS));
-    return this.getWorkflow(workflowInstanceId, includeTasks, retry - 1);
-  }
-  getWorkflowStatus(workflowInstanceId, includeOutput, includeVariables) {
-    return tryCatchReThrow(() => this._client.workflowResource.getWorkflowStatusSummary(workflowInstanceId, includeOutput, includeVariables));
-  }
-  pause(workflowInstanceId) {
-    return tryCatchReThrow(() => this._client.workflowResource.pauseWorkflow(workflowInstanceId));
-  }
-  reRun(workflowInstanceId, rerunWorkflowRequest = {}) {
-    return tryCatchReThrow(() => this._client.workflowResource.rerun(workflowInstanceId, rerunWorkflowRequest));
-  }
-  restart(workflowInstanceId, useLatestDefinitions) {
-    return tryCatchReThrow(() => this._client.workflowResource.restart1(workflowInstanceId, useLatestDefinitions));
-  }
-  resume(workflowInstanceId) {
-    return tryCatchReThrow(() => this._client.workflowResource.resumeWorkflow(workflowInstanceId));
-  }
-  retry(workflowInstanceId, resumeSubworkflowTasks) {
-    return tryCatchReThrow(() => this._client.workflowResource.retry1(workflowInstanceId, resumeSubworkflowTasks));
-  }
-  search(start, size, query, freeText, sort = "", skipCache = false) {
-    const queryId = void 0;
-    return tryCatchReThrow(() => this._client.workflowResource.search1(queryId, start, size, sort, freeText, query, skipCache));
-  }
-  skipTasksFromWorkflow(workflowInstanceId, taskReferenceName, skipTaskRequest) {
-    return tryCatchReThrow(() => this._client.workflowResource.skipTaskFromWorkflow(workflowInstanceId, taskReferenceName, skipTaskRequest));
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
   }
-  terminate(workflowInstanceId, reason) {
-    return tryCatchReThrow(() => this._client.workflowResource.terminate1(workflowInstanceId, reason));
+  return "";
+};
+var getUrl2 = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString2(options.query)}`;
   }
-  updateTask(taskId, workflowInstanceId, taskStatus, outputData) {
-    const taskUpdates = {
-      status: taskStatus,
-      taskId,
-      workflowInstanceId
+  return url;
+};
+var getFormData2 = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString2(value) || isBlob2(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
     };
-    return tryCatchReThrow(() => this._client.taskResource.updateTask1(__spreadValues({
-      outputData
-    }, taskUpdates)));
-  }
-  updateTaskByRefName(taskReferenceName, workflowInstanceId, status, taskOutput) {
-    return tryCatchReThrow(() => this._client.taskResource.updateTask(workflowInstanceId, taskReferenceName, status, taskOutput));
+    Object.entries(options.formData).filter(([_, value]) => isDefined2(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
   }
-  getTask(taskId) {
-    return tryCatchReThrow(() => this._client.taskResource.getTask(taskId));
+  return void 0;
+};
+var resolve2 = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
   }
+  return resolver;
 };
-
-// src/core/human.ts
-var HumanExecutor = class {
-  constructor(client) {
-    this._client = client;
+var getHeaders2 = async (config, options) => {
+  const token = await resolve2(options, config.TOKEN);
+  const username = await resolve2(options, config.USERNAME);
+  const password = await resolve2(options, config.PASSWORD);
+  const additionalHeaders = await resolve2(options, config.HEADERS);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined2(value)).reduce(
+    (headers2, [key, value]) => ({
+      ...headers2,
+      [key]: String(value)
+    }),
+    {}
+  );
+  if (isStringWithValue2(token)) {
+    headers["X-AUTHORIZATION"] = token;
   }
-  async getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
-    const response = await this._client.humanTask.getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput);
-    if (response.results != void 0) {
-      return response.results;
-    }
-    return [];
+  if (isStringWithValue2(username) && isStringWithValue2(password)) {
+    const credentials = base642(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
   }
-  getTaskById(taskId) {
-    return tryCatchReThrow(() => this._client.humanTask.getTask1(taskId));
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob2(options.body)) {
+      headers["Content-Type"] = "application/octet-stream";
+    } else if (isString2(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData2(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
   }
-  async claimTaskAsExternalUser(taskId, assignee) {
-    try {
-      await this._client.humanTask.assignAndClaim(taskId, assignee);
-    } catch (error) {
-      throw errorMapper(error);
+  return new Headers(headers);
+};
+var getRequestBody2 = (options) => {
+  if (options.body) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString2(options.body) || isBlob2(options.body) || isFormData2(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
     }
   }
-  async claimTaskAsConductorUser(taskId) {
-    try {
-      await this._client.humanTask.claimTask(taskId);
-    } catch (error) {
-      throw errorMapper(error);
+  return void 0;
+};
+var sendRequest2 = async (options, url, body, formData, headers, onCancel, fetchFn = fetch) => {
+  const controller = new AbortController();
+  const request3 = {
+    headers,
+    method: options.method,
+    body: body ?? formData,
+    signal: controller.signal
+  };
+  onCancel(() => controller.abort());
+  return await fetchFn(url, request3);
+};
+var getResponseHeader2 = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString2(content)) {
+      return content;
     }
   }
-  async releaseTask(taskId) {
+  return void 0;
+};
+var getResponseBody2 = async (response) => {
+  if (response.status !== 204) {
     try {
-      await this._client.humanTask.releaseTask(taskId);
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const isJSON = contentType.toLowerCase().startsWith("application/json");
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
     } catch (error) {
-      throw errorMapper(error);
+      console.error(error);
     }
   }
-  async getTemplateById(templateId) {
-    return tryCatchReThrow(() => this._client.humanTask.getTemplateById(templateId));
+  return void 0;
+};
+var catchErrorCodes2 = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
   }
-  async updateTaskOutput(taskId, requestBody) {
-    try {
-      await this._client.humanTask.updateTaskOutput(taskId, requestBody, false);
-    } catch (error) {
-      throw errorMapper(error);
-    }
+  if (!result.ok) {
+    throw new ApiError(options, result, "Generic Error");
   }
-  async completeTask(taskId, requestBody = {}) {
+};
+var request2 = (config, options, fetchFn = fetch) => {
+  return new CancelablePromise(async (resolve3, reject, onCancel) => {
     try {
-      await this._client.humanTask.updateTaskOutput(taskId, requestBody, true);
+      const url = getUrl2(config, options);
+      const formData = getFormData2(options);
+      const body = getRequestBody2(options);
+      const headers = await getHeaders2(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest2(
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel,
+          fetchFn
+        );
+        const responseBody = await getResponseBody2(response);
+        const responseHeader = getResponseHeader2(
+          response,
+          options.responseHeader
+        );
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes2(options, result);
+        resolve3(result.body);
+      }
     } catch (error) {
-      throw errorMapper(error);
+      reject(error);
     }
-  }
+  });
+};
+
+// src/orkes/BaseOrkesConductorClient.ts
+var defaultRequestHandler2 = (request3, config, options) => request3(config, options);
+var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHandler2) => {
+  return async (config, requestHandler = baseRequestHandler) => {
+    if (config?.keySecret != null && config?.keyId != null) {
+      const { serverUrl, keyId, keySecret } = config;
+      const tokenUrl = `${serverUrl}/token`;
+      const res = await fetchFn(tokenUrl, {
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({ keyId, keySecret }),
+        method: "POST"
+      });
+      const { token } = await res.json();
+      return new ConductorClient({ ...config, TOKEN: token }, requestHandler);
+    } else {
+      return new ConductorClient(config, requestHandler);
+    }
+  };
 };
+
+// src/orkes/OrkesConductorClient.ts
+var fetchCache = fetchCatchDns(fetch);
+var defaultRequestHandler3 = (__request, config, options) => request2(config, options, fetchCache);
+var orkesConductorClient = baseOrkesConductorClient(
+  fetchCache,
+  defaultRequestHandler3
+);
 export {
   ApiError,
   BaseHttpRequest,
@@ -2382,6 +3724,7 @@ export {
   ConductorClient,
   ConductorError,
   DefaultLogger,
+  DnsCacheResolver,
   EventResourceService,
   HealthCheckResourceService,
   HumanExecutor,
@@ -2395,10 +3738,12 @@ export {
   WorkflowBulkResourceService,
   WorkflowExecutor,
   WorkflowResourceService,
+  baseOrkesConductorClient,
   conductorEventTask,
   doWhileTask,
   dynamicForkTask,
   eventTask,
+  fetchCatchDns,
   forkTask,
   forkTaskJoin,
   generate,
@@ -2423,7 +3768,9 @@ export {
   kafkaPublishTask,
   newLoopTask,
   noopErrorHandler,
+  noopLogger,
   orkesConductorClient,
+  request2 as request,
   setVariableTask,
   simpleTask,
   sqsEventTask,
@@ -2431,6 +3778,7 @@ export {
   switchTask,
   taskGenMapper,
   terminateTask,
+  toMaybeUrl,
   waitTaskDuration,
   waitTaskUntil,
   workflow