@io-orkes/conductor-javascript 1.0.0 → 1.0.1

package/README.md

@@ -1,4 +1,4 @@
-# Netflix Conductor Javascript SDK
+# Netflix Conductor Javascript/Typescript SDK
 
 The `conductor-javascript` repository provides the client SDKs to build task workers in javascript/typescript.
 
@@ -52,4 +52,4 @@ orkesConductorClient(config).then(client => ..... );
 
 ```
 
-### Next: [Create and run task workers](workers_sdk.md)
+### Next: [Create and run task workers](workers_sdk.md)

package/dist/index.d.ts

@@ -1201,6 +1201,281 @@ declare class WorkflowResourceService {
     resetWorkflow(workflowId: string): CancelablePromise<void>;
 }
 
+declare type AssignmentPolicy = {
+    type: string;
+};
+
+declare type FFAAssignment = AssignmentPolicy;
+
+declare type Fixed = (AssignmentPolicy & {
+    assignee?: string;
+    assigneeType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
+});
+
+declare type TimeoutPolicy = {
+    type: string;
+};
+
+declare type BackToAssigment = (TimeoutPolicy & {
+    timeoutSeconds?: number;
+});
+
+declare type ClearAssigment = (TimeoutPolicy & {
+    timeoutSeconds?: number;
+});
+
+declare type Escalate = (TimeoutPolicy & {
+    subjects?: Array<string>;
+    timeoutSeconds?: number;
+} & {
+    subjects: Array<string>;
+});
+
+declare type LeastBusyGroupMemberAssignment = (AssignmentPolicy & {
+    groupId?: string;
+});
+
+declare type Never = TimeoutPolicy;
+
+declare type Terminate = (TimeoutPolicy & {
+    timeoutSeconds?: number;
+});
+
+declare type HumanTaskEntry = {
+    assignee?: string;
+    assigneeType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
+    assignmentPolicy?: (FFAAssignment | Fixed | LeastBusyGroupMemberAssignment);
+    claimedBy?: string;
+    createdBy?: string;
+    createdOn?: number;
+    escalatedAt?: number;
+    output?: Record<string, Record<string, any>>;
+    owners?: Array<string>;
+    predefinedInput?: Record<string, Record<string, any>>;
+    state?: 'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT';
+    taskId?: string;
+    taskName?: string;
+    taskRefName?: string;
+    templateId?: string;
+    timeoutPolicy?: (BackToAssigment | ClearAssigment | Escalate | Never | Terminate);
+    workflowId?: string;
+    workflowName?: string;
+};
+
+declare type HTScrollableSearchResultHumanTaskEntry = {
+    queryId?: string;
+    results?: Array<HumanTaskEntry>;
+};
+
+declare type HumanTaskActionLogEntry = {
+    action?: string;
+    actionTime?: number;
+    cause?: string;
+    id?: string;
+    taskId?: string;
+    taskRefName?: string;
+    workflowId?: string;
+    workflowName?: string;
+};
+
+declare type HumanTaskLoad = {
+    assignedUser?: string;
+    count?: number;
+    taskRefName?: string;
+    workflowName?: string;
+};
+
+declare type HumanTaskStateLogEntry = {
+    assignee?: string;
+    assigneeType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
+    claimedBy?: string;
+    id?: string;
+    state?: 'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT';
+    stateEnd?: number;
+    stateStart?: number;
+    taskId?: string;
+    taskRefName?: string;
+    workflowId?: string;
+    workflowName?: string;
+};
+
+declare type HumanTaskTemplate = {
+    jsonSchema: Record<string, Record<string, any>>;
+    name: string;
+    templateUI: Record<string, Record<string, any>>;
+    version?: number;
+};
+
+declare type HumanTaskTemplateEntry = {
+    createdBy?: string;
+    createdOn?: number;
+    id?: string;
+    jsonSchema?: Record<string, Record<string, any>>;
+    name?: string;
+    templateUI?: Record<string, Record<string, any>>;
+    updatedBy?: string;
+    updatedOn?: number;
+    version?: number;
+};
+
+declare type SearchResultHumanTaskEntry = {
+    results?: Array<HumanTaskEntry>;
+    totalHits?: number;
+};
+
+declare class HumanTaskService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * 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: 'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT', assignee?: string, assigneeType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP', claimedBy?: string, taskName?: string, freeText?: string, includeInputOutput?: boolean): CancelablePromise<SearchResultHumanTaskEntry>;
+    /**
+     * Get task load grouped by workflow name and task ref name per user
+     * @returns HumanTaskLoad OK
+     * @throws ApiError
+     */
+    getTaskLoad(): CancelablePromise<Array<HumanTaskLoad>>;
+    /**
+     * Search human tasks
+     * @param queryId
+     * @param start
+     * @param size
+     * @param freeText
+     * @param query
+     * @param jsonQuery
+     * @param includeInputOutput
+     * @returns HTScrollableSearchResultHumanTaskEntry OK
+     * @throws ApiError
+     */
+    search1(queryId?: string, start?: number, size?: number, freeText?: string, query?: string, jsonQuery?: string, includeInputOutput?: boolean): CancelablePromise<HTScrollableSearchResultHumanTaskEntry>;
+    /**
+     * If the workflow is disconnected from tasks, this API can be used to clean up
+     * @param taskId
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateTaskOutput1(taskId: string): CancelablePromise<any>;
+    /**
+     * Get a task
+     * @param taskId
+     * @returns HumanTaskEntry OK
+     * @throws ApiError
+     */
+    getTask1(taskId: string): CancelablePromise<HumanTaskEntry>;
+    /**
+     * Get human task action log entries by task id
+     * @param taskId
+     * @returns HumanTaskActionLogEntry OK
+     * @throws ApiError
+     */
+    getActionLogs(taskId: string): CancelablePromise<Array<HumanTaskActionLogEntry>>;
+    /**
+     * Claim a task by authenticated Conductor user
+     * @param taskId
+     * @returns any OK
+     * @throws ApiError
+     */
+    claimTask(taskId: string): CancelablePromise<any>;
+    /**
+     * Claim a task to an external user
+     * @param taskId
+     * @param userId
+     * @returns any OK
+     * @throws ApiError
+     */
+    assignAndClaim(taskId: string, userId: string): CancelablePromise<any>;
+    /**
+     * Release a task without completing it
+     * @param taskId
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    reassignTask(taskId: string, requestBody: (FFAAssignment | Fixed | LeastBusyGroupMemberAssignment)): CancelablePromise<any>;
+    /**
+     * Release a task without completing it
+     * @param taskId
+     * @returns any OK
+     * @throws ApiError
+     */
+    releaseTask(taskId: string): CancelablePromise<any>;
+    /**
+     * Get human task state log entries by task id
+     * @param taskId
+     * @returns HumanTaskStateLogEntry OK
+     * @throws ApiError
+     */
+    getStateLogs(taskId: string): CancelablePromise<Array<HumanTaskStateLogEntry>>;
+    /**
+     * Update task output, optionally complete
+     * @param taskId
+     * @param requestBody
+     * @param complete
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, any>>, complete?: boolean): CancelablePromise<any>;
+    /**
+     * Delete human task templates by name
+     * @param name
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteTemplatesByName(name: string): CancelablePromise<any>;
+    /**
+     * 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?: string, version?: number): CancelablePromise<Array<HumanTaskTemplateEntry>>;
+    /**
+     * Save human task template
+     * @param requestBody
+     * @param newVersion
+     * @returns string OK
+     * @throws ApiError
+     */
+    saveTemplate(requestBody: HumanTaskTemplate, newVersion?: boolean): CancelablePromise<string>;
+    /**
+     * Delete human task template
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteTemplateById(id: string): CancelablePromise<any>;
+    /**
+     * Get human task template by id
+     * @param id
+     * @returns HumanTaskTemplateEntry OK
+     * @throws ApiError
+     */
+    getTemplateById(id: string): CancelablePromise<HumanTaskTemplateEntry>;
+}
+
+declare class HumanTaskResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Conductor task by id (for human tasks only)
+     * @param taskId
+     * @returns Task OK
+     * @throws ApiError
+     */
+    getConductorTaskById(taskId: string): CancelablePromise<Task>;
+}
+
 interface ConductorClientAPIConfig extends Omit<OpenAPIConfig, "BASE"> {
     serverUrl: string;
 }
@@ -1213,6 +1488,8 @@ declare class ConductorClient {
     readonly tokenResource: TokenResourceService;
     readonly workflowBulkResource: WorkflowBulkResourceService;
     readonly workflowResource: WorkflowResourceService;
+    readonly humanTask: HumanTaskService;
+    readonly humanTaskResource: HumanTaskResourceService;
     readonly request: BaseHttpRequest;
     readonly token?: string | Resolver<string>;
     constructor(config?: Partial<ConductorClientAPIConfig>, requestHandler?: ConductorHttpRequest);
@@ -1402,13 +1679,6 @@ interface WaitTaskDef extends CommonTaskDef {
         until?: string;
     };
 }
-declare type U2O<U extends string> = {
-    [key in U]: U2O<Exclude<U, key>>;
-};
-declare type O2T<O extends {}> = {} extends O ? [] : {
-    [key in keyof O]: [key, ...O2T<O[key]>];
-}[keyof O];
-declare type WorkflowInputParameters<T extends string> = O2T<U2O<T>>;
 interface WorkflowDef extends Omit<WorkflowDef$1, "tasks" | "version" | "inputParameters"> {
     inputParameters: string[];
     version: number;
@@ -1836,4 +2106,65 @@ declare class WorkflowExecutor {
     getTask(taskId: string): Promise<Task>;
 }
 
-export { Action, ApiError, BaseHttpRequest, CancelError, CancelablePromise, CommonTaskDef, ConductorClient, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, EventHandler, EventResourceService, EventTaskDef, ExternalStorageLocation, ForkJoinDynamicDef, ForkJoinTaskDef, GenerateTokenRequest, HealthCheckResourceService, HttpInputParameters, HttpTaskDef, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishInputParameters, KafkaPublishTaskDef, MetadataResourceService, OnCancel, OpenAPIConfig, OrkesApiConfig, PollData, RequestType, RerunWorkflowRequest, Response, RunnerArgs, SaveScheduleRequest, SchedulerResourceService, ScrollableSearchResultWorkflowSummary, SearchResultTask, SearchResultTaskSummary, SearchResultWorkflow, SearchResultWorkflowScheduleExecutionModel, SearchResultWorkflowSummary, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflow, StartWorkflowRequest, SubWorkflowParams, SubWorkflowTaskDef, SwitchTaskDef, Task, TaskDef, TaskDefTypes, TaskDetails, TaskErrorHandler, TaskExecLog, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResourceService, TaskResult, TaskResultStatus, TaskRunner, TaskSummary, TaskType, TerminateTaskDef, TokenResourceService, WaitTaskDef, Workflow, WorkflowBulkResourceService, WorkflowDef, WorkflowExecutor, WorkflowInputParameters, WorkflowResourceService, WorkflowSchedule, WorkflowScheduleExecutionModel, WorkflowStatus, WorkflowSummary, WorkflowTask, conductorEventTask, doWhileTask, dynamicForkTask, eventTask, forkTask, forkTaskJoin, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, httpTask, inlineTask, joinTask, jsonJqTask, kafkaPublishTask, newLoopTask, noopErrorHandler, orkesConductorClient, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };
+declare class HumanExecutor {
+    readonly _client: ConductorClient;
+    constructor(client: ConductorClient);
+    /**
+     * 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
+     */
+    getTasksByFilter(state: "PENDING" | "ASSIGNED" | "IN_PROGRESS" | "COMPLETED" | "TIMED_OUT", assignee?: string, assigneeType?: "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP", claimedBy?: string, taskName?: string, freeText?: string, includeInputOutput?: boolean): Promise<HumanTaskEntry[]>;
+    /**
+     * Returns task for a given task id
+     * @param taskId
+     * @returns
+     */
+    getTaskById(taskId: string): Promise<HumanTaskEntry>;
+    /**
+     * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
+     * @param taskId
+     * @param assignee
+     * @returns
+     */
+    claimTaskAsExternalUser(taskId: string, assignee: string): Promise<void>;
+    /**
+     * Claim task as conductor user
+     * @param taskId
+     * @returns
+     */
+    claimTaskAsConductorUser(taskId: string): Promise<void>;
+    /**
+     * Claim task as conductor user
+     * @param taskId
+     * @param assignee
+     * @returns
+     */
+    releaseTask(taskId: string): Promise<void>;
+    /**
+     * Returns a HumanTaskTemplateEntry for a given templateId
+     * @param templateId
+     * @returns
+     */
+    getTemplateById(templateId: string): Promise<HumanTaskTemplateEntry>;
+    /**
+     * Takes a taskId and a partial body. will update with given body
+     * @param taskId
+     * @param requestBody
+     */
+    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, any>>): Promise<void>;
+    /**
+     * Takes a taskId and an optional partial body. will complete the task with the given body
+     * @param taskId
+     * @param requestBody
+     */
+    completeTask(taskId: string, requestBody?: Record<string, Record<string, any>>): Promise<void>;
+}
+
+export { Action, ApiError, AssignmentPolicy, BackToAssigment, BaseHttpRequest, CancelError, CancelablePromise, ClearAssigment, CommonTaskDef, ConductorClient, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, Escalate, EventHandler, EventResourceService, EventTaskDef, ExternalStorageLocation, FFAAssignment, Fixed, ForkJoinDynamicDef, ForkJoinTaskDef, GenerateTokenRequest, HTScrollableSearchResultHumanTaskEntry, HealthCheckResourceService, HttpInputParameters, HttpTaskDef, HumanExecutor, HumanTaskActionLogEntry, HumanTaskEntry, HumanTaskLoad, HumanTaskStateLogEntry, HumanTaskTemplate, HumanTaskTemplateEntry, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishInputParameters, KafkaPublishTaskDef, LeastBusyGroupMemberAssignment, MetadataResourceService, Never, OnCancel, OpenAPIConfig, OrkesApiConfig, PollData, RequestType, RerunWorkflowRequest, Response, RunnerArgs, SaveScheduleRequest, SchedulerResourceService, ScrollableSearchResultWorkflowSummary, SearchResultHumanTaskEntry, SearchResultTask, SearchResultTaskSummary, SearchResultWorkflow, SearchResultWorkflowScheduleExecutionModel, SearchResultWorkflowSummary, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflow, StartWorkflowRequest, SubWorkflowParams, SubWorkflowTaskDef, SwitchTaskDef, Task, TaskDef, TaskDefTypes, TaskDetails, TaskErrorHandler, TaskExecLog, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResourceService, TaskResult, TaskResultStatus, TaskRunner, TaskSummary, TaskType, Terminate, TerminateTaskDef, TimeoutPolicy, TokenResourceService, WaitTaskDef, Workflow, WorkflowBulkResourceService, WorkflowDef, WorkflowExecutor, WorkflowResourceService, WorkflowSchedule, WorkflowScheduleExecutionModel, WorkflowStatus, WorkflowSummary, WorkflowTask, conductorEventTask, doWhileTask, dynamicForkTask, eventTask, forkTask, forkTaskJoin, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, httpTask, inlineTask, joinTask, jsonJqTask, kafkaPublishTask, newLoopTask, noopErrorHandler, orkesConductorClient, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };

package/dist/index.js

@@ -48,6 +48,7 @@ __export(conductor_javascript_exports, {
   DefaultLogger: () => DefaultLogger,
   EventResourceService: () => EventResourceService,
   HealthCheckResourceService: () => HealthCheckResourceService,
+  HumanExecutor: () => HumanExecutor,
   MetadataResourceService: () => MetadataResourceService,
   SchedulerResourceService: () => SchedulerResourceService,
   TaskManager: () => TaskManager,
@@ -1411,6 +1412,202 @@ var request = (config, options) => {
   });
 };
 
+// src/common/open-api/services/HumanTaskService.ts
+var HumanTaskService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks",
+      query: {
+        "state": state,
+        "assignee": assignee,
+        "assigneeType": assigneeType,
+        "claimedBy": claimedBy,
+        "taskName": taskName,
+        "freeText": freeText,
+        "includeInputOutput": includeInputOutput
+      }
+    });
+  }
+  getTaskLoad() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/load"
+    });
+  }
+  search1(queryId, start, size = 100, freeText = "*", query, jsonQuery, includeInputOutput = false) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/search",
+      query: {
+        "queryId": queryId,
+        "start": start,
+        "size": size,
+        "freeText": freeText,
+        "query": query,
+        "jsonQuery": jsonQuery,
+        "includeInputOutput": includeInputOutput
+      }
+    });
+  }
+  updateTaskOutput1(taskId) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/tasks/{taskId}",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  getTask1(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  getActionLogs(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}/actionLogs",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  claimTask(taskId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/claim",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  assignAndClaim(taskId, userId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/externalUser/{userId}",
+      path: {
+        "taskId": taskId,
+        "userId": userId
+      }
+    });
+  }
+  reassignTask(taskId, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/reassign",
+      path: {
+        "taskId": taskId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  releaseTask(taskId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/release",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  getStateLogs(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}/stateLogs",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  updateTaskOutput(taskId, requestBody, complete = false) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/update",
+      path: {
+        "taskId": taskId
+      },
+      query: {
+        "complete": complete
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  deleteTemplatesByName(name) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/template",
+      query: {
+        "name": name
+      }
+    });
+  }
+  getAllTemplates(name, version) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/template",
+      query: {
+        "name": name,
+        "version": version
+      }
+    });
+  }
+  saveTemplate(requestBody, newVersion = false) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/template",
+      query: {
+        "newVersion": newVersion
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  deleteTemplateById(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/template/{id}",
+      path: {
+        "id": id
+      }
+    });
+  }
+  getTemplateById(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/template/{id}",
+      path: {
+        "id": id
+      }
+    });
+  }
+};
+
+// src/common/open-api/services/HumanTaskResourceService.ts
+var HumanTaskResourceService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getConductorTaskById(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}/conductorTask",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+};
+
 // src/common/open-api/ConductorClient.ts
 var defaultRequestHandler = (request2, config, options) => request2(config, options);
 var ConductorClient = class {
@@ -1441,6 +1638,8 @@ var ConductorClient = class {
     this.tokenResource = new TokenResourceService(this.request);
     this.workflowBulkResource = new WorkflowBulkResourceService(this.request);
     this.workflowResource = new WorkflowResourceService(this.request);
+    this.humanTask = new HumanTaskService(this.request);
+    this.humanTaskResource = new HumanTaskResourceService(this.request);
   }
 };
 
@@ -2026,8 +2225,7 @@ var ConductorError = class extends Error {
   }
 };
 
-// src/core/executor.ts
-var RETRY_TIME_IN_MILLISECONDS = 1e4;
+// src/core/helpers.ts
 var errorMapper = (error) => new ConductorError(error?.body?.message, error);
 var tryCatchReThrow = (fn) => {
   try {
@@ -2036,6 +2234,9 @@ var tryCatchReThrow = (fn) => {
     throw errorMapper(error);
   }
 };
+
+// src/core/executor.ts
+var RETRY_TIME_IN_MILLISECONDS = 1e4;
 var WorkflowExecutor = class {
   constructor(client) {
     this._client = client;
@@ -2109,6 +2310,61 @@ var WorkflowExecutor = class {
     return tryCatchReThrow(() => this._client.taskResource.getTask(taskId));
   }
 };
+
+// src/core/human.ts
+var HumanExecutor = class {
+  constructor(client) {
+    this._client = client;
+  }
+  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 [];
+  }
+  getTaskById(taskId) {
+    return tryCatchReThrow(() => this._client.humanTask.getTask1(taskId));
+  }
+  async claimTaskAsExternalUser(taskId, assignee) {
+    try {
+      await this._client.humanTask.assignAndClaim(taskId, assignee);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async claimTaskAsConductorUser(taskId) {
+    try {
+      await this._client.humanTask.claimTask(taskId);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async releaseTask(taskId) {
+    try {
+      await this._client.humanTask.releaseTask(taskId);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async getTemplateById(templateId) {
+    return tryCatchReThrow(() => this._client.humanTask.getTemplateById(templateId));
+  }
+  async updateTaskOutput(taskId, requestBody) {
+    try {
+      await this._client.humanTask.updateTaskOutput(taskId, requestBody, false);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async completeTask(taskId, requestBody = {}) {
+    try {
+      await this._client.humanTask.updateTaskOutput(taskId, requestBody, true);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiError,
@@ -2120,6 +2376,7 @@ var WorkflowExecutor = class {
   DefaultLogger,
   EventResourceService,
   HealthCheckResourceService,
+  HumanExecutor,
   MetadataResourceService,
   SchedulerResourceService,
   TaskManager,