@io-orkes/conductor-javascript 2.1.3 → 2.1.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-declare type ApiRequestOptions = {
+type ApiRequestOptions = {
     readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
     readonly url: string;
     readonly path?: Record<string, any>;
@@ -39,9 +39,9 @@ declare class CancelablePromise<T> implements Promise<T> {
     get isCancelled(): boolean;
 }
 
-declare type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
-declare type Headers = Record<string, string>;
-declare type OpenAPIConfig = {
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
     BASE: string;
     VERSION: string;
     WITH_CREDENTIALS: boolean;
@@ -59,7 +59,7 @@ declare abstract class BaseHttpRequest {
     abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
 }
 
-declare type StartWorkflow = {
+type StartWorkflow = {
     name?: string;
     version?: number;
     correlationId?: string;
@@ -67,14 +67,14 @@ declare type StartWorkflow = {
     taskToDomain?: Record<string, string>;
 };
 
-declare type TaskDetails = {
+type TaskDetails = {
     workflowId?: string;
     taskRefName?: string;
     output?: Record<string, any>;
     taskId?: string;
 };
 
-declare type Action = {
+type Action = {
     action?: 'start_workflow' | 'complete_task' | 'fail_task';
     start_workflow?: StartWorkflow;
     complete_task?: TaskDetails;
@@ -82,7 +82,7 @@ declare type Action = {
     expandInlineJSON?: boolean;
 };
 
-declare type EventHandler = {
+type EventHandler = {
     name: string;
     event: string;
     condition?: string;
@@ -172,7 +172,7 @@ declare class HealthCheckResourceService {
     doCheck(): CancelablePromise<Record<string, any>>;
 }
 
-declare type TaskDef = {
+type TaskDef = {
     ownerApp?: string;
     createTime?: number;
     updateTime?: number;
@@ -199,7 +199,7 @@ declare type TaskDef = {
     backoffScaleFactor?: number;
 };
 
-declare type SubWorkflowParams = {
+type SubWorkflowParams = {
     name: string;
     version?: number;
     taskToDomain?: Record<string, string>;
@@ -208,7 +208,7 @@ declare type SubWorkflowParams = {
     idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING';
 };
 
-declare type WorkflowTask = {
+type WorkflowTask = {
     name: string;
     taskReferenceName: string;
     description?: string;
@@ -250,7 +250,7 @@ declare type WorkflowTask = {
     workflowTaskType?: 'SIMPLE' | 'DYNAMIC' | 'FORK_JOIN' | 'FORK_JOIN_DYNAMIC' | 'DECISION' | 'SWITCH' | 'JOIN' | 'DO_WHILE' | 'SUB_WORKFLOW' | 'START_WORKFLOW' | 'EVENT' | 'WAIT' | 'HUMAN' | 'USER_DEFINED' | 'HTTP' | 'LAMBDA' | 'INLINE' | 'EXCLUSIVE_JOIN' | 'TERMINATE' | 'KAFKA_PUBLISH' | 'JSON_JQ_TRANSFORM' | 'SET_VARIABLE';
 };
 
-declare type WorkflowDef$1 = {
+type WorkflowDef$1 = {
     ownerApp?: string;
     createTime?: number;
     updateTime?: number;
@@ -360,7 +360,7 @@ declare class MetadataResourceService {
     get(name: string, version?: number, metadata?: boolean): CancelablePromise<WorkflowDef$1>;
 }
 
-declare type StartWorkflowRequest = {
+type StartWorkflowRequest = {
     name: string;
     version?: number;
     correlationId?: string;
@@ -374,7 +374,7 @@ declare type StartWorkflowRequest = {
     createdBy?: string;
 };
 
-declare type SaveScheduleRequest = {
+type SaveScheduleRequest = {
     name: string;
     cronExpression: string;
     runCatchupScheduleInstances?: boolean;
@@ -386,7 +386,7 @@ declare type SaveScheduleRequest = {
     scheduleEndTime?: number;
 };
 
-declare type WorkflowScheduleExecutionModel = {
+type WorkflowScheduleExecutionModel = {
     executionId?: string;
     scheduleName?: string;
     scheduledTime?: number;
@@ -399,12 +399,12 @@ declare type WorkflowScheduleExecutionModel = {
     state?: 'POLLED' | 'FAILED' | 'EXECUTED';
 };
 
-declare type SearchResultWorkflowScheduleExecutionModel = {
+type SearchResultWorkflowScheduleExecutionModel = {
     totalHits?: number;
     results?: Array<WorkflowScheduleExecutionModel>;
 };
 
-declare type WorkflowSchedule = {
+type WorkflowSchedule = {
     name?: string;
     cronExpression?: string;
     runCatchupScheduleInstances?: boolean;
@@ -511,19 +511,19 @@ declare class SchedulerResourceService {
     searchV21(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflowScheduleExecutionModel>;
 }
 
-declare type ExternalStorageLocation = {
+type ExternalStorageLocation = {
     uri?: string;
     path?: string;
 };
 
-declare type PollData = {
+type PollData = {
     queueName?: string;
     domain?: string;
     workerId?: string;
     lastPollTime?: number;
 };
 
-declare type Task = {
+type Task = {
     taskType?: string;
     status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
     inputData?: Record<string, any>;
@@ -567,12 +567,12 @@ declare type Task = {
     loopOverTask?: boolean;
 };
 
-declare type SearchResultTask = {
+type SearchResultTask = {
     totalHits?: number;
     results?: Array<Task>;
 };
 
-declare type TaskSummary = {
+type TaskSummary = {
     workflowId?: string;
     workflowType?: string;
     correlationId?: string;
@@ -594,18 +594,18 @@ declare type TaskSummary = {
     workflowPriority?: number;
 };
 
-declare type SearchResultTaskSummary = {
+type SearchResultTaskSummary = {
     totalHits?: number;
     results?: Array<TaskSummary>;
 };
 
-declare type TaskExecLog = {
+type TaskExecLog = {
     log?: string;
     taskId?: string;
     createdTime?: number;
 };
 
-declare type TaskResult = {
+type TaskResult = {
     workflowInstanceId: string;
     taskId: string;
     reasonForIncompletion?: string;
@@ -618,6 +618,340 @@ declare type TaskResult = {
     subWorkflowId?: string;
 };
 
+type Workflow = {
+    ownerApp?: string;
+    createTime?: number;
+    updateTime?: number;
+    createdBy?: string;
+    updatedBy?: string;
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    idempotencyKey?: string;
+    endTime?: number;
+    workflowId?: string;
+    parentWorkflowId?: string;
+    parentWorkflowTaskId?: string;
+    tasks?: Array<Task>;
+    input?: Record<string, any>;
+    output?: Record<string, any>;
+    correlationId?: string;
+    reRunFromWorkflowId?: string;
+    reasonForIncompletion?: string;
+    event?: string;
+    taskToDomain?: Record<string, string>;
+    failedReferenceTaskNames?: Array<string>;
+    workflowDefinition?: WorkflowDef$1;
+    externalInputPayloadStoragePath?: string;
+    externalOutputPayloadStoragePath?: string;
+    priority?: number;
+    variables?: Record<string, any>;
+    lastRetriedTime?: number;
+    startTime?: number;
+    workflowVersion?: number;
+    workflowName?: string;
+};
+
+interface CommonTaskDef {
+    name: string;
+    taskReferenceName: string;
+}
+declare enum Consistency {
+    SYNCHRONOUS = "SYNCHRONOUS",
+    DURABLE = "DURABLE",
+    REGION_DURABLE = "REGION_DURABLE"
+}
+declare enum ReturnStrategy {
+    TARGET_WORKFLOW = "TARGET_WORKFLOW",
+    BLOCKING_WORKFLOW = "BLOCKING_WORKFLOW",
+    BLOCKING_TASK = "BLOCKING_TASK",
+    BLOCKING_TASK_INPUT = "BLOCKING_TASK_INPUT"
+}
+declare enum TaskType {
+    START = "START",
+    SIMPLE = "SIMPLE",
+    DYNAMIC = "DYNAMIC",
+    FORK_JOIN = "FORK_JOIN",
+    FORK_JOIN_DYNAMIC = "FORK_JOIN_DYNAMIC",
+    DECISION = "DECISION",
+    SWITCH = "SWITCH",
+    JOIN = "JOIN",
+    DO_WHILE = "DO_WHILE",
+    SUB_WORKFLOW = "SUB_WORKFLOW",
+    EVENT = "EVENT",
+    WAIT = "WAIT",
+    USER_DEFINED = "USER_DEFINED",
+    HTTP = "HTTP",
+    LAMBDA = "LAMBDA",
+    INLINE = "INLINE",
+    EXCLUSIVE_JOIN = "EXCLUSIVE_JOIN",
+    TERMINAL = "TERMINAL",
+    TERMINATE = "TERMINATE",
+    KAFKA_PUBLISH = "KAFKA_PUBLISH",
+    JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
+    SET_VARIABLE = "SET_VARIABLE"
+}
+type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
+interface DoWhileTaskDef extends CommonTaskDef {
+    inputParameters: Record<string, unknown>;
+    type: TaskType.DO_WHILE;
+    startDelay?: number;
+    optional?: boolean;
+    asyncComplete?: boolean;
+    loopCondition: string;
+    loopOver: TaskDefTypes[];
+}
+interface EventTaskDef extends CommonTaskDef {
+    type: TaskType.EVENT;
+    sink: string;
+    asyncComplete?: boolean;
+}
+interface ForkJoinTaskDef extends CommonTaskDef {
+    type: TaskType.FORK_JOIN;
+    inputParameters?: Record<string, string>;
+    forkTasks: Array<Array<TaskDefTypes>>;
+}
+interface JoinTaskDef extends CommonTaskDef {
+    type: TaskType.JOIN;
+    inputParameters?: Record<string, string>;
+    joinOn: string[];
+    optional?: boolean;
+    asyncComplete?: boolean;
+}
+interface ForkJoinDynamicDef extends CommonTaskDef {
+    inputParameters: {
+        dynamicTasks: any;
+        dynamicTasksInput: any;
+    };
+    type: TaskType.FORK_JOIN_DYNAMIC;
+    dynamicForkTasksParam: string;
+    dynamicForkTasksInputParamName: string;
+    startDelay?: number;
+    optional?: boolean;
+    asyncComplete?: boolean;
+}
+interface HttpInputParameters {
+    uri: string;
+    method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
+    accept?: string;
+    contentType?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    connectionTimeOut?: number;
+    readTimeOut?: string;
+}
+interface HttpTaskDef extends CommonTaskDef {
+    inputParameters: {
+        [x: string]: unknown;
+        http_request: HttpInputParameters;
+    };
+    type: TaskType.HTTP;
+    asyncComplete?: boolean;
+}
+interface InlineTaskInputParameters {
+    evaluatorType: "javascript" | "graaljs";
+    expression: string;
+    [x: string]: unknown;
+}
+interface InlineTaskDef extends CommonTaskDef {
+    type: TaskType.INLINE;
+    inputParameters: InlineTaskInputParameters;
+}
+interface ContainingQueryExpression {
+    queryExpression: string;
+    [x: string | number | symbol]: unknown;
+}
+interface JsonJQTransformTaskDef extends CommonTaskDef {
+    type: TaskType.JSON_JQ_TRANSFORM;
+    inputParameters: ContainingQueryExpression;
+}
+interface KafkaPublishInputParameters {
+    topic: string;
+    value: string;
+    bootStrapServers: string;
+    headers: Record<string, string>;
+    key: string;
+    keySerializer: string;
+}
+interface KafkaPublishTaskDef extends CommonTaskDef {
+    inputParameters: {
+        kafka_request: KafkaPublishInputParameters;
+    };
+    type: TaskType.KAFKA_PUBLISH;
+}
+interface SetVariableTaskDef extends CommonTaskDef {
+    type: TaskType.SET_VARIABLE;
+    inputParameters: Record<string, unknown>;
+}
+interface SimpleTaskDef extends CommonTaskDef {
+    type: TaskType.SIMPLE;
+    inputParameters?: Record<string, unknown>;
+}
+interface SubWorkflowTaskDef extends CommonTaskDef {
+    type: TaskType.SUB_WORKFLOW;
+    inputParameters?: Record<string, unknown>;
+    subWorkflowParam: {
+        name: string;
+        version?: number;
+        taskToDomain?: Record<string, string>;
+    };
+}
+interface SwitchTaskDef extends CommonTaskDef {
+    inputParameters: Record<string, unknown>;
+    type: TaskType.SWITCH;
+    decisionCases: Record<string, TaskDefTypes[]>;
+    defaultCase: TaskDefTypes[];
+    evaluatorType: "value-param" | "javascript";
+    expression: string;
+}
+interface TerminateTaskDef extends CommonTaskDef {
+    inputParameters: {
+        terminationStatus: "COMPLETED" | "FAILED";
+        workflowOutput?: Record<string, string>;
+        terminationReason?: string;
+    };
+    type: TaskType.TERMINATE;
+    startDelay?: number;
+    optional?: boolean;
+}
+interface WaitTaskDef extends CommonTaskDef {
+    type: TaskType.WAIT;
+    inputParameters: {
+        duration?: string;
+        until?: string;
+    };
+}
+interface WorkflowDef extends Omit<WorkflowDef$1, "tasks" | "version" | "inputParameters"> {
+    inputParameters: string[];
+    version: number;
+    tasks: TaskDefTypes[];
+}
+
+/**
+ * SignalResponse represents a unified response from the signal API
+ */
+declare class SignalResponse {
+    /** Type of response based on return strategy */
+    responseType?: string;
+    /** ID of the target workflow */
+    targetWorkflowId?: string;
+    /** Status of the target workflow */
+    targetWorkflowStatus?: string;
+    /** ID of the workflow */
+    workflowId?: string;
+    /** Input data for the workflow/task */
+    input?: Record<string, any>;
+    /** Output data from the workflow/task */
+    output?: Record<string, any>;
+    /** Priority of the workflow */
+    priority?: number;
+    /** Workflow variables */
+    variables?: Record<string, any>;
+    /** Array of tasks in the workflow */
+    tasks?: Array<Task>;
+    /** User who created the workflow */
+    createdBy?: string;
+    /** Timestamp when workflow was created */
+    createTime?: number;
+    /** Current status of the workflow */
+    status?: string;
+    /** Timestamp when workflow was last updated */
+    updateTime?: number;
+    /** Type of the blocking task */
+    taskType?: string;
+    /** ID of the blocking task */
+    taskId?: string;
+    /** Reference name of the blocking task */
+    referenceTaskName?: string;
+    /** Number of retries for the task */
+    retryCount?: number;
+    /** Definition name of the task */
+    taskDefName?: string;
+    /** Type of the workflow containing the task */
+    workflowType?: string;
+    /**
+     * Returns true if the response contains target workflow details
+     */
+    isTargetWorkflow(): boolean;
+    /**
+     * Returns true if the response contains blocking workflow details
+     */
+    isBlockingWorkflow(): boolean;
+    /**
+     * Returns true if the response contains blocking task details
+     */
+    isBlockingTask(): boolean;
+    /**
+     * Returns true if the response contains blocking task input
+     */
+    isBlockingTaskInput(): boolean;
+    /**
+     * Extracts workflow details from a SignalResponse
+     * @throws Error if the response type doesn't contain workflow details
+     */
+    getWorkflow(): Workflow;
+    /**
+     * Extracts task details from a SignalResponse
+     * @throws Error if the response type doesn't contain task details
+     */
+    getBlockingTask(): Task;
+    /**
+     * Extracts task input from a SignalResponse
+     * Only valid for BLOCKING_TASK_INPUT responses
+     * @throws Error if the response type doesn't contain task input details
+     */
+    getTaskInput(): Record<string, any>;
+    /**
+     * Get the workflow ID from the response
+     */
+    getWorkflowId(): string;
+    /**
+     * Get the target workflow ID from the response
+     */
+    getTargetWorkflowId(): string;
+    /**
+     * Check if the response has workflow data
+     */
+    hasWorkflowData(): boolean;
+    /**
+     * Check if the response has task data
+     */
+    hasTaskData(): boolean;
+    /**
+     * Get response type as string
+     */
+    getResponseType(): string;
+    /**
+     * Check if the workflow/task is in a terminal state
+     */
+    isTerminal(): boolean;
+    /**
+     * Check if the workflow/task is currently running
+     */
+    isRunning(): boolean;
+    /**
+     * Check if the workflow/task is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Get a summary of the response for logging
+     */
+    getSummary(): string;
+    /**
+     * Convert to JSON for debugging (excludes large objects)
+     */
+    toDebugJSON(): Record<string, any>;
+    /**
+     * String representation for debugging
+     */
+    toString(): string;
+}
+
+declare enum TaskResultStatusEnum {
+    IN_PROGRESS = "IN_PROGRESS",
+    FAILED = "FAILED",
+    FAILED_WITH_TERMINAL_ERROR = "FAILED_WITH_TERMINAL_ERROR",
+    COMPLETED = "COMPLETED"
+}
+
 declare class TaskResourceService {
     readonly httpRequest: BaseHttpRequest;
     constructor(httpRequest: BaseHttpRequest);
@@ -752,15 +1086,45 @@ declare class TaskResourceService {
      * @throws ApiError
      */
     getExternalStorageLocation1(path: string, operation: string, payloadType: string): CancelablePromise<ExternalStorageLocation>;
+    /**
+     * Update a task By Ref Name synchronously. The output data is merged if data from a previous API call already exists.
+     * @param workflowId
+     * @param taskRefName
+     * @param status
+     * @param output
+     * @param workerId - Optional
+     * @returns Workflow
+     * @throws ApiError
+     */
+    updateTaskSync(workflowId: string, taskRefName: string, status: TaskResultStatusEnum, output: Record<string, any>, workerId?: string): CancelablePromise<Workflow>;
+    /**
+     * Signals a task in a workflow synchronously and returns data based on the specified return strategy
+     * @param workflowId - Workflow ID of the workflow to be signaled
+     * @param status - Signal status to be set for the workflow
+     * @param output - Output for the task
+     * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
+     * @returns SignalResponse with data based on the return strategy
+     * @throws ApiError
+     */
+    signal(workflowId: string, status: TaskResultStatusEnum, output: Record<string, any>, returnStrategy?: ReturnStrategy): CancelablePromise<SignalResponse>;
+    /**
+     * Signals a task in a workflow asynchronously (fire-and-forget)
+     * @param workflowId - Workflow ID of the workflow to be signaled
+     * @param status - Signal status to be set for the workflow
+     * @param output - Output for the task
+     * @returns Promise<void>
+     * @throws ApiError
+     */
+    signalAsync(workflowId: string, status: TaskResultStatusEnum, output: Record<string, any>): CancelablePromise<void>;
 }
 
-declare type GenerateTokenRequest = {
+type GenerateTokenRequest = {
     keyId: string;
     keySecret: string;
     refreshTokenInterval?: number;
 };
 
-declare type Response$1 = {};
+type Response$1 = {};
 
 declare class TokenResourceService {
     readonly httpRequest: BaseHttpRequest;
@@ -780,7 +1144,7 @@ declare class TokenResourceService {
     getUserInfo(): CancelablePromise<any>;
 }
 
-declare type BulkResponse = {
+type BulkResponse = {
     bulkErrorResults?: Record<string, string>;
     bulkSuccessfulResults?: Array<string>;
 };
@@ -827,7 +1191,7 @@ declare class WorkflowBulkResourceService {
     pauseWorkflow1(requestBody: Array<string>): CancelablePromise<BulkResponse>;
 }
 
-declare type RerunWorkflowRequest = {
+type RerunWorkflowRequest = {
     reRunFromWorkflowId?: string;
     workflowInput?: Record<string, any>;
     reRunFromTaskId?: string;
@@ -835,7 +1199,7 @@ declare type RerunWorkflowRequest = {
     correlationId?: string;
 };
 
-declare type WorkflowSummary = {
+type WorkflowSummary = {
     workflowType?: string;
     version?: number;
     workflowId?: string;
@@ -858,74 +1222,27 @@ declare type WorkflowSummary = {
     inputSize?: number;
 };
 
-declare type ScrollableSearchResultWorkflowSummary = {
+type ScrollableSearchResultWorkflowSummary = {
     results?: Array<WorkflowSummary>;
     totalHits?: number;
 };
 
-declare type Workflow = {
-    ownerApp?: string;
-    createTime?: number;
-    updateTime?: number;
-    createdBy?: string;
-    updatedBy?: string;
-    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
-    idempotencyKey?: string;
-    endTime?: number;
-    workflowId?: string;
-    parentWorkflowId?: string;
-    parentWorkflowTaskId?: string;
-    tasks?: Array<Task>;
-    input?: Record<string, any>;
-    output?: Record<string, any>;
-    correlationId?: string;
-    reRunFromWorkflowId?: string;
-    reasonForIncompletion?: string;
-    event?: string;
-    taskToDomain?: Record<string, string>;
-    failedReferenceTaskNames?: Array<string>;
-    workflowDefinition?: WorkflowDef$1;
-    externalInputPayloadStoragePath?: string;
-    externalOutputPayloadStoragePath?: string;
-    priority?: number;
-    variables?: Record<string, any>;
-    lastRetriedTime?: number;
-    startTime?: number;
-    workflowVersion?: number;
-    workflowName?: string;
-};
-
-declare type SearchResultWorkflow = {
+type SearchResultWorkflow = {
     totalHits?: number;
     results?: Array<Workflow>;
 };
 
-declare type SearchResultWorkflowSummary = {
+type SearchResultWorkflowSummary = {
     totalHits?: number;
     results?: Array<WorkflowSummary>;
 };
 
-declare type SkipTaskRequest = {
+type SkipTaskRequest = {
     taskInput?: Record<string, any>;
     taskOutput?: Record<string, any>;
 };
 
-declare type WorkflowRun = {
-    correlationId?: string;
-    createTime?: number;
-    createdBy?: string;
-    priority?: number;
-    requestId?: string;
-    status?: string;
-    tasks?: Array<Task>;
-    updateTime?: number;
-    workflowId?: string;
-    variables?: Record<string, object>;
-    input?: Record<string, object>;
-    output?: Record<string, object>;
-};
-
-declare type WorkflowStatus = {
+type WorkflowStatus = {
     workflowId?: string;
     correlationId?: string;
     output?: Record<string, any>;
@@ -933,14 +1250,14 @@ declare type WorkflowStatus = {
     status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
 };
 
-declare type TaskMock = {
+type TaskMock = {
     executionTime?: number;
     output: Record<string, any>;
     queueWaitTime?: number;
     status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED";
 };
 
-declare type WorkflowTestRequest = {
+type WorkflowTestRequest = {
     correlationId?: string;
     createdBy?: string;
     externalInputPayloadStoragePath?: string;
@@ -976,11 +1293,13 @@ declare class WorkflowResourceService {
      * @param version
      * @param requestId
      * @param waitUntilTaskRef
-     * @param callback
-     * @returns workflowRun
+     * @param waitForSeconds - Optional, defaults to 10
+     * @param consistency - Optional, defaults to "DURABLE"
+     * @param returnStrategy - Optional, defaults to "TARGET_WORKFLOW"
+     * @returns SignalResponse
      * @throws ApiError
      */
-    executeWorkflow(body: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string): CancelablePromise<WorkflowRun>;
+    executeWorkflow(body: StartWorkflowRequest, name: string, version: number, requestId?: string, waitUntilTaskRef?: string, waitForSeconds?: number, consistency?: string, returnStrategy?: string): CancelablePromise<SignalResponse>;
     /**
      * Start a new workflow with StartWorkflowRequest, which allows task to be executed in a domain
      * @param requestBody
@@ -1209,37 +1528,37 @@ declare const request$1: <T>(config: OpenAPIConfig, options: ApiRequestOptions)
  * @param config @see OpenAPIConfig
  * @param options {see ApiRequestOptions}
  */
-declare type RequestType = typeof request$1;
-declare type ConductorHttpRequest = <T>(request: RequestType, config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+type RequestType = typeof request$1;
+type ConductorHttpRequest = <T>(request: RequestType, config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
 
-declare type HumanTaskUser = {
+type HumanTaskUser = {
     user?: string;
     userType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
 };
 
-declare type HumanTaskAssignment = {
+type HumanTaskAssignment = {
     assignee?: HumanTaskUser;
     slaMinutes?: number;
 };
 
-declare type HumanTaskTrigger = {
+type HumanTaskTrigger = {
     startWorkflowRequest?: StartWorkflowRequest;
     triggerType?: 'ASSIGNEE_CHANGED' | 'PENDING' | 'IN_PROGRESS' | 'ASSIGNED' | 'COMPLETED' | 'TIMED_OUT';
 };
 
-declare type UserFormTemplate = {
+type UserFormTemplate = {
     name?: string;
     version?: number;
 };
 
-declare type HumanTaskDefinition = {
+type HumanTaskDefinition = {
     assignmentCompletionStrategy?: 'LEAVE_OPEN' | 'TERMINATE';
     assignments?: Array<HumanTaskAssignment>;
     taskTriggers?: Array<HumanTaskTrigger>;
     userFormTemplate?: UserFormTemplate;
 };
 
-declare type HumanTaskEntry = {
+type HumanTaskEntry = {
     assignee?: HumanTaskUser;
     claimant?: HumanTaskUser;
     createdBy?: string;
@@ -1258,7 +1577,7 @@ declare type HumanTaskEntry = {
     workflowName?: string;
 };
 
-declare type HumanTaskSearch = {
+type HumanTaskSearch = {
     assignees?: Array<HumanTaskUser>;
     claimants?: Array<HumanTaskUser>;
     definitionNames?: Array<string>;
@@ -1272,12 +1591,12 @@ declare type HumanTaskSearch = {
     workflowNames?: Array<string>;
 };
 
-declare type HumanTaskSearchResult = {
+type HumanTaskSearchResult = {
     results?: Array<HumanTaskEntry>;
     totalHits?: number;
 };
 
-declare type HumanTaskTemplate = {
+type HumanTaskTemplate = {
     createdBy?: string;
     createdOn?: number;
     jsonSchema: Record<string, any>;
@@ -1354,94 +1673,265 @@ declare class HumanTaskService {
      * @returns any OK
      * @throws ApiError
      */
-    reassignTask(taskId: string, requestBody: Array<HumanTaskAssignment>): CancelablePromise<any>;
+    reassignTask(taskId: string, requestBody: Array<HumanTaskAssignment>): CancelablePromise<any>;
+    /**
+     * Release a task without completing it
+     * @param taskId
+     * @returns any OK
+     * @throws ApiError
+     */
+    releaseTask(taskId: string): CancelablePromise<any>;
+    /**
+     * If a task is assigned to a user, this API can be used to skip that assignment and move to the next assignee
+     * @param taskId
+     * @param reason
+     * @returns any OK
+     * @throws ApiError
+     */
+    skipTask(taskId: string, reason?: string): CancelablePromise<any>;
+    /**
+     * Update task output, optionally complete
+     * @param taskId
+     * @param requestBody
+     * @param complete
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateTaskOutput(taskId: string, requestBody: Record<string, any>, complete?: boolean): CancelablePromise<any>;
+    /**
+     * List all user form templates or get templates by name, or a template by name and version
+     * @param name
+     * @param version
+     * @returns HumanTaskTemplate OK
+     * @throws ApiError
+     */
+    getAllTemplates(name?: string, version?: number): CancelablePromise<Array<HumanTaskTemplate>>;
+    /**
+     * Save user form template
+     * @param requestBody
+     * @param newVersion
+     * @returns HumanTaskTemplate OK
+     * @throws ApiError
+     */
+    saveTemplate(requestBody: HumanTaskTemplate, newVersion?: boolean): CancelablePromise<HumanTaskTemplate>;
+    /**
+     * Save user form template
+     * @param requestBody
+     * @param newVersion
+     * @returns HumanTaskTemplate OK
+     * @throws ApiError
+     */
+    saveTemplates(requestBody: Array<HumanTaskTemplate>, newVersion?: boolean): CancelablePromise<Array<HumanTaskTemplate>>;
+    /**
+     * Delete all versions of user form template by name
+     * @param name
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteTemplateByName(name: string): CancelablePromise<any>;
+    /**
+     * Delete a version of form template by name
+     * @param name
+     * @param version
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteTemplatesByNameAndVersion(name: string, version: number): CancelablePromise<any>;
+    /**
+     * Get user form template by name and version
+     * @param name
+     * @param version
+     * @returns HumanTaskTemplate OK
+     * @throws ApiError
+     */
+    getTemplateByNameAndVersion(name: string, version: number): CancelablePromise<HumanTaskTemplate>;
+}
+
+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>;
+}
+
+declare enum ServiceType {
+    HTTP = "HTTP",
+    gRPC = "gRPC"
+}
+interface RequestParamSchema {
+    type: string;
+    format?: string;
+    defaultValue?: any;
+}
+interface RequestParam {
+    name: string;
+    type: string;
+    required: boolean;
+    schema?: RequestParamSchema;
+}
+interface ServiceMethod {
+    id?: number;
+    operationName: string;
+    methodName: string;
+    methodType: string;
+    inputType: string;
+    outputType: string;
+    requestParams?: RequestParam[];
+    exampleInput?: Record<string, any>;
+}
+interface OrkesCircuitBreakerConfig {
+    failureRateThreshold?: number;
+    slidingWindowSize?: number;
+    minimumNumberOfCalls?: number;
+    waitDurationInOpenState?: number;
+    permittedNumberOfCallsInHalfOpenState?: number;
+    slowCallRateThreshold?: number;
+    slowCallDurationThreshold?: number;
+    automaticTransitionFromOpenToHalfOpenEnabled?: boolean;
+    maxWaitDurationInHalfOpenState?: number;
+}
+interface ServiceRegistryConfig {
+    circuitBreakerConfig?: OrkesCircuitBreakerConfig;
+}
+interface ServiceRegistry {
+    name: string;
+    type: ServiceType;
+    serviceURI: string;
+    methods?: ServiceMethod[];
+    requestParams?: RequestParam[];
+    config?: ServiceRegistryConfig;
+}
+interface CircuitBreakerTransitionResponse {
+    service: string;
+    previousState: string;
+    currentState: string;
+    transitionTimestamp: number;
+    message: string;
+}
+interface ProtoRegistryEntry {
+    filename: string;
+    lastUpdated: number;
+}
+
+declare class ServiceRegistryResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Retrieve all registered services
+     * @returns Array<ServiceRegistryModels> List of all registered services
+     * @throws ApiError
+     */
+    getRegisteredServices(): CancelablePromise<Array<ServiceRegistry>>;
+    /**
+     * Remove a service by name
+     * @param name The name of the service to remove
+     * @returns void
+     * @throws ApiError
+     */
+    removeService(name: string): CancelablePromise<void>;
+    /**
+     * Get a service by name
+     * @param name The name of the service to retrieve
+     * @returns ServiceRegistryModels The requested service registry
+     * @throws ApiError
+     */
+    getService(name: string): CancelablePromise<ServiceRegistry>;
+    /**
+     * Open the circuit breaker for a service
+     * @param name The name of the service
+     * @returns CircuitBreakerTransitionResponse Response with circuit breaker status
+     * @throws ApiError
+     */
+    openCircuitBreaker(name: string): CancelablePromise<CircuitBreakerTransitionResponse>;
     /**
-     * Release a task without completing it
-     * @param taskId
-     * @returns any OK
+     * Close the circuit breaker for a service
+     * @param name The name of the service
+     * @returns CircuitBreakerTransitionResponse Response with circuit breaker status
      * @throws ApiError
      */
-    releaseTask(taskId: string): CancelablePromise<any>;
+    closeCircuitBreaker(name: string): CancelablePromise<CircuitBreakerTransitionResponse>;
     /**
-     * If a task is assigned to a user, this API can be used to skip that assignment and move to the next assignee
-     * @param taskId
-     * @param reason
-     * @returns any OK
+     * Get circuit breaker status for a service
+     * @param name The name of the service
+     * @returns CircuitBreakerTransitionResponse Response with circuit breaker status
      * @throws ApiError
      */
-    skipTask(taskId: string, reason?: string): CancelablePromise<any>;
+    getCircuitBreakerStatus(name: string): CancelablePromise<CircuitBreakerTransitionResponse>;
     /**
-     * Update task output, optionally complete
-     * @param taskId
-     * @param requestBody
-     * @param complete
-     * @returns any OK
+     * Add or update a service registry
+     * @param serviceRegistry The service registry to add or update
+     * @returns void
      * @throws ApiError
      */
-    updateTaskOutput(taskId: string, requestBody: Record<string, any>, complete?: boolean): CancelablePromise<any>;
+    addOrUpdateService(serviceRegistry: ServiceRegistry): CancelablePromise<void>;
     /**
-     * List all user form templates or get templates by name, or a template by name and version
-     * @param name
-     * @param version
-     * @returns HumanTaskTemplate OK
+     * Add or update a service method
+     * @param registryName The name of the registry
+     * @param method The service method to add or update
+     * @returns void
      * @throws ApiError
      */
-    getAllTemplates(name?: string, version?: number): CancelablePromise<Array<HumanTaskTemplate>>;
+    addOrUpdateServiceMethod(registryName: string, method: ServiceMethod): CancelablePromise<void>;
     /**
-     * Save user form template
-     * @param requestBody
-     * @param newVersion
-     * @returns HumanTaskTemplate OK
+     * Remove a service method
+     * @param registryName The name of the registry
+     * @param serviceName The name of the service
+     * @param method The name of the method
+     * @param methodType The type of the method
+     * @returns void
      * @throws ApiError
      */
-    saveTemplate(requestBody: HumanTaskTemplate, newVersion?: boolean): CancelablePromise<HumanTaskTemplate>;
+    removeMethod(registryName: string, serviceName: string, method: string, methodType: string): CancelablePromise<void>;
     /**
-     * Save user form template
-     * @param requestBody
-     * @param newVersion
-     * @returns HumanTaskTemplate OK
+     * Get proto data
+     * @param registryName The name of the registry
+     * @param filename The name of the proto file
+     * @returns binary The proto file data
      * @throws ApiError
      */
-    saveTemplates(requestBody: Array<HumanTaskTemplate>, newVersion?: boolean): CancelablePromise<Array<HumanTaskTemplate>>;
+    getProtoData(registryName: string, filename: string): CancelablePromise<Blob>;
     /**
-     * Delete all versions of user form template by name
-     * @param name
-     * @returns any OK
+     * Set proto data
+     * @param registryName The name of the registry
+     * @param filename The name of the proto file
+     * @param data The proto file data
+     * @returns void
      * @throws ApiError
      */
-    deleteTemplateByName(name: string): CancelablePromise<any>;
+    setProtoData(registryName: string, filename: string, data: Blob): CancelablePromise<void>;
     /**
-     * Delete a version of form template by name
-     * @param name
-     * @param version
-     * @returns any OK
+     * Delete a proto file
+     * @param registryName The name of the registry
+     * @param filename The name of the proto file
+     * @returns void
      * @throws ApiError
      */
-    deleteTemplatesByNameAndVersion(name: string, version: number): CancelablePromise<any>;
+    deleteProto(registryName: string, filename: string): CancelablePromise<void>;
     /**
-     * Get user form template by name and version
-     * @param name
-     * @param version
-     * @returns HumanTaskTemplate OK
+     * Get all proto files for a registry
+     * @param registryName The name of the registry
+     * @returns Array<ProtoRegistryEntry> List of proto registry entries
      * @throws ApiError
      */
-    getTemplateByNameAndVersion(name: string, version: number): CancelablePromise<HumanTaskTemplate>;
-}
-
-declare class HumanTaskResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
+    getAllProtos(registryName: string): CancelablePromise<Array<ProtoRegistryEntry>>;
     /**
-     * Get Conductor task by id (for human tasks only)
-     * @param taskId
-     * @returns Task OK
+     * Discover service methods
+     * @param name The name of the service
+     * @param create Whether to create the discovered methods (defaults to false)
+     * @returns Array<ServiceMethod> The discovered service methods
      * @throws ApiError
      */
-    getConductorTaskById(taskId: string): CancelablePromise<Task>;
+    discover(name: string, create?: boolean): CancelablePromise<Array<ServiceMethod>>;
 }
 
 interface ConductorClientAPIConfig extends Omit<OpenAPIConfig, "BASE"> {
     serverUrl: string;
+    useEnvVars: boolean;
 }
 declare class ConductorClient {
     readonly eventResource: EventResourceService;
@@ -1452,6 +1942,7 @@ declare class ConductorClient {
     readonly tokenResource: TokenResourceService;
     readonly workflowBulkResource: WorkflowBulkResourceService;
     readonly workflowResource: WorkflowResourceService;
+    readonly serviceRegistryResource: ServiceRegistryResourceService;
     readonly humanTask: HumanTaskService;
     readonly humanTaskResource: HumanTaskResourceService;
     readonly request: BaseHttpRequest;
@@ -1460,7 +1951,7 @@ declare class ConductorClient {
     stop(): void;
 }
 
-declare type ApiResult = {
+type ApiResult = {
     readonly url: string;
     readonly ok: boolean;
     readonly status: number;
@@ -1477,16 +1968,31 @@ declare class ApiError extends Error {
     constructor(request: ApiRequestOptions, response: ApiResult, message: string);
 }
 
-declare type HTScrollableSearchResultHumanTaskEntry = {
+type WorkflowRun = {
+    correlationId?: string;
+    createTime?: number;
+    createdBy?: string;
+    priority?: number;
+    requestId?: string;
+    status?: string;
+    tasks?: Array<Task>;
+    updateTime?: number;
+    workflowId?: string;
+    variables?: Record<string, object>;
+    input?: Record<string, object>;
+    output?: Record<string, object>;
+};
+
+type HTScrollableSearchResultHumanTaskEntry = {
     queryId?: string;
     results?: Array<HumanTaskEntry>;
 };
 
-declare type TimeoutPolicy = {
+type TimeoutPolicy = {
     type: string;
 };
 
-declare type Terminate = (TimeoutPolicy & {
+type Terminate = (TimeoutPolicy & {
     timeoutSeconds?: number;
 });
 
@@ -1510,7 +2016,7 @@ interface ConductorLogger {
     error(...args: any): void;
     debug(...args: any): void;
 }
-declare type ConductorLogLevel = keyof typeof LOG_LEVELS;
+type ConductorLogLevel = keyof typeof LOG_LEVELS;
 interface DefaultLoggerConfig {
     level?: ConductorLogLevel;
     tags?: Object[];
@@ -1531,170 +2037,7 @@ declare class DefaultLogger implements ConductorLogger {
 }
 declare const noopLogger: ConductorLogger;
 
-interface CommonTaskDef {
-    name: string;
-    taskReferenceName: string;
-}
-declare enum TaskType {
-    START = "START",
-    SIMPLE = "SIMPLE",
-    DYNAMIC = "DYNAMIC",
-    FORK_JOIN = "FORK_JOIN",
-    FORK_JOIN_DYNAMIC = "FORK_JOIN_DYNAMIC",
-    DECISION = "DECISION",
-    SWITCH = "SWITCH",
-    JOIN = "JOIN",
-    DO_WHILE = "DO_WHILE",
-    SUB_WORKFLOW = "SUB_WORKFLOW",
-    EVENT = "EVENT",
-    WAIT = "WAIT",
-    USER_DEFINED = "USER_DEFINED",
-    HTTP = "HTTP",
-    LAMBDA = "LAMBDA",
-    INLINE = "INLINE",
-    EXCLUSIVE_JOIN = "EXCLUSIVE_JOIN",
-    TERMINAL = "TERMINAL",
-    TERMINATE = "TERMINATE",
-    KAFKA_PUBLISH = "KAFKA_PUBLISH",
-    JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
-    SET_VARIABLE = "SET_VARIABLE"
-}
-declare type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
-interface DoWhileTaskDef extends CommonTaskDef {
-    inputParameters: Record<string, unknown>;
-    type: TaskType.DO_WHILE;
-    startDelay?: number;
-    optional?: boolean;
-    asyncComplete?: boolean;
-    loopCondition: string;
-    loopOver: TaskDefTypes[];
-}
-interface EventTaskDef extends CommonTaskDef {
-    type: TaskType.EVENT;
-    sink: string;
-    asyncComplete?: boolean;
-}
-interface ForkJoinTaskDef extends CommonTaskDef {
-    type: TaskType.FORK_JOIN;
-    inputParameters?: Record<string, string>;
-    forkTasks: Array<Array<TaskDefTypes>>;
-}
-interface JoinTaskDef extends CommonTaskDef {
-    type: TaskType.JOIN;
-    inputParameters?: Record<string, string>;
-    joinOn: string[];
-    optional?: boolean;
-    asyncComplete?: boolean;
-}
-interface ForkJoinDynamicDef extends CommonTaskDef {
-    inputParameters: {
-        dynamicTasks: any;
-        dynamicTasksInput: any;
-    };
-    type: TaskType.FORK_JOIN_DYNAMIC;
-    dynamicForkTasksParam: string;
-    dynamicForkTasksInputParamName: string;
-    startDelay?: number;
-    optional?: boolean;
-    asyncComplete?: boolean;
-}
-interface HttpInputParameters {
-    uri: string;
-    method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
-    accept?: string;
-    contentType?: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-    connectionTimeOut?: number;
-    readTimeOut?: string;
-}
-interface HttpTaskDef extends CommonTaskDef {
-    inputParameters: {
-        [x: string]: unknown;
-        http_request: HttpInputParameters;
-    };
-    type: TaskType.HTTP;
-}
-interface InlineTaskInputParameters {
-    evaluatorType: "javascript" | "graaljs";
-    expression: string;
-    [x: string]: unknown;
-}
-interface InlineTaskDef extends CommonTaskDef {
-    type: TaskType.INLINE;
-    inputParameters: InlineTaskInputParameters;
-}
-interface ContainingQueryExpression {
-    queryExpression: string;
-    [x: string | number | symbol]: unknown;
-}
-interface JsonJQTransformTaskDef extends CommonTaskDef {
-    type: TaskType.JSON_JQ_TRANSFORM;
-    inputParameters: ContainingQueryExpression;
-}
-interface KafkaPublishInputParameters {
-    topic: string;
-    value: string;
-    bootStrapServers: string;
-    headers: Record<string, string>;
-    key: string;
-    keySerializer: string;
-}
-interface KafkaPublishTaskDef extends CommonTaskDef {
-    inputParameters: {
-        kafka_request: KafkaPublishInputParameters;
-    };
-    type: TaskType.KAFKA_PUBLISH;
-}
-interface SetVariableTaskDef extends CommonTaskDef {
-    type: TaskType.SET_VARIABLE;
-    inputParameters: Record<string, unknown>;
-}
-interface SimpleTaskDef extends CommonTaskDef {
-    type: TaskType.SIMPLE;
-    inputParameters?: Record<string, unknown>;
-}
-interface SubWorkflowTaskDef extends CommonTaskDef {
-    type: TaskType.SUB_WORKFLOW;
-    inputParameters?: Record<string, unknown>;
-    subWorkflowParam: {
-        name: string;
-        version?: number;
-        taskToDomain?: Record<string, string>;
-    };
-}
-interface SwitchTaskDef extends CommonTaskDef {
-    inputParameters: Record<string, unknown>;
-    type: TaskType.SWITCH;
-    decisionCases: Record<string, TaskDefTypes[]>;
-    defaultCase: TaskDefTypes[];
-    evaluatorType: "value-param" | "javascript";
-    expression: string;
-}
-interface TerminateTaskDef extends CommonTaskDef {
-    inputParameters: {
-        terminationStatus: "COMPLETED" | "FAILED";
-        workflowOutput?: Record<string, string>;
-        terminationReason?: string;
-    };
-    type: TaskType.TERMINATE;
-    startDelay?: number;
-    optional?: boolean;
-}
-interface WaitTaskDef extends CommonTaskDef {
-    type: TaskType.WAIT;
-    inputParameters: {
-        duration?: string;
-        until?: string;
-    };
-}
-interface WorkflowDef extends Omit<WorkflowDef$1, "tasks" | "version" | "inputParameters"> {
-    inputParameters: string[];
-    version: number;
-    tasks: TaskDefTypes[];
-}
-
-declare type TaskErrorHandler = (error: Error, task?: Task) => void;
+type TaskErrorHandler = (error: Error, task?: Task) => void;
 interface TaskRunnerOptions {
     workerID: string;
     domain: string | undefined;
@@ -1749,7 +2092,7 @@ declare class TaskRunner {
     handleUnknownError: (unknownError: unknown) => void;
 }
 
-declare type TaskManagerOptions = TaskRunnerOptions;
+type TaskManagerOptions = TaskRunnerOptions;
 interface TaskManagerConfig {
     logger?: ConductorLogger;
     options?: Partial<TaskManagerOptions>;
@@ -1793,9 +2136,9 @@ declare class ConductorError extends Error {
     private __proto__;
     constructor(message?: string, innerError?: Error);
 }
-declare type TaskResultStatus = NonNullable<TaskResult['status']>;
+type TaskResultStatus = NonNullable<TaskResult['status']>;
 
-declare type TaskFinderPredicate = (task: Task) => boolean;
+type TaskFinderPredicate = (task: Task) => boolean;
 declare const completedTaskMatchingType: (taskType: string) => TaskFinderPredicate;
 declare class WorkflowExecutor {
     readonly _client: ConductorClient;
@@ -1814,11 +2157,13 @@ declare class WorkflowExecutor {
      */
     startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
     /**
-     * Execute a workflow synchronously. returns a Promise<WorkflowRun> with details of the running workflow
-     * @param workflowRequest
-     * @returns
+     * Execute a workflow synchronously (original method - backward compatible)
      */
     executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
+    /**
+     * Execute a workflow with return strategy support (new method)
+     */
+    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string, waitForSeconds: number, consistency: Consistency, returnStrategy: ReturnStrategy): Promise<SignalResponse>;
     startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise<string>[];
     goBackToTask(workflowInstanceId: string, taskFinderPredicate: TaskFinderPredicate, rerunWorkflowRequestOverrides?: Partial<RerunWorkflowRequest>): Promise<void>;
     goBackToFirstTaskMatchingType(workflowInstanceId: string, taskType: string): Promise<void>;
@@ -1940,9 +2285,36 @@ declare class WorkflowExecutor {
      * @returns
      */
     getTask(taskId: string): Promise<Task>;
+    /**
+     * Updates a task by reference name synchronously and returns the complete workflow
+     * @param taskReferenceName
+     * @param workflowInstanceId
+     * @param status
+     * @param taskOutput
+     * @param workerId - Optional
+     * @returns Promise<Workflow>
+     */
+    updateTaskSync(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: Record<string, any>, workerId?: string): Promise<Workflow>;
+    /**
+     * Signals a workflow task and returns data based on the specified return strategy
+     * @param workflowInstanceId - Workflow instance ID to signal
+     * @param status - Task status to set
+     * @param taskOutput - Output data for the task
+     * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
+     * @returns Promise<SignalResponse> with data based on the return strategy
+     */
+    signal(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: Record<string, any>, returnStrategy?: ReturnStrategy): Promise<SignalResponse>;
+    /**
+     * Signals a workflow task asynchronously (fire-and-forget)
+     * @param workflowInstanceId - Workflow instance ID to signal
+     * @param status - Task status to set
+     * @param taskOutput - Output data for the task
+     * @returns Promise<void>
+     */
+    signalAsync(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: Record<string, any>): Promise<void>;
 }
 
-declare type PollIntervalOptions = {
+type PollIntervalOptions = {
     pollInterval: number;
     maxPollTimes: number;
 };
@@ -2051,7 +2423,7 @@ declare const conductorEventTask: (taskReferenceName: string, eventName: string)
 declare const forkTask: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => ForkJoinTaskDef;
 declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => [ForkJoinTaskDef, JoinTaskDef];
 
-declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters) => HttpTaskDef;
+declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters, asyncComplete?: boolean) => HttpTaskDef;
 
 declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs") => InlineTaskDef;
 
@@ -2065,13 +2437,13 @@ declare const setVariableTask: (taskReferenceName: string, inputParameters: Reco
 
 declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>) => SimpleTaskDef;
 
-declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number | undefined) => SubWorkflowTaskDef;
+declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number) => SubWorkflowTaskDef;
 
 declare const switchTask: (taskReferenceName: string, expression: string, decisionCases?: Record<string, TaskDefTypes[]>, defaultCase?: TaskDefTypes[]) => SwitchTaskDef;
 
 declare const taskDefinition: ({ name, ownerApp, description, retryCount, timeoutSeconds, inputKeys, outputKeys, timeoutPolicy, retryLogic, retryDelaySeconds, responseTimeoutSeconds, concurrentExecLimit, inputTemplate, rateLimitPerFrequency, rateLimitFrequencyInSeconds, ownerEmail, pollTimeoutSeconds, backoffScaleFactor, }: TaskDef) => TaskDef;
 
-declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string | undefined) => TerminateTaskDef;
+declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string) => TerminateTaskDef;
 
 declare const waitTaskDuration: (taskReferenceName: string, duration: string) => WaitTaskDef;
 declare const waitTaskUntil: (taskReferenceName: string, until: string) => WaitTaskDef;
@@ -2096,18 +2468,18 @@ declare const generateSimpleTask: (overrides?: Partial<SimpleTaskDef>) => Simple
  */
 declare const generateEventTask: (overrides?: Partial<EventTaskDef>) => EventTaskDef;
 
-declare type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
+type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
 interface WorkflowDefGen extends Omit<WorkflowDef, "tasks"> {
     tasks: Partial<TaskDefTypesGen>[];
 }
-declare type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
+type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
     forkTasks: Array<Array<Partial<TaskDefTypesGen>>>;
 };
-declare type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
+type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
     decisionCases: Record<string, Partial<TaskDefTypesGen>[]>;
     defaultCase: Partial<TaskDefTypesGen>[];
 };
-declare type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
+type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
     loopOver: Partial<TaskDefTypesGen>[];
 };
 interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "expression"> {
@@ -2116,7 +2488,7 @@ interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "
 interface InlineTaskDefGen extends Omit<InlineTaskDef, "inputParameters"> {
     inputParameters: InlineTaskInputParametersGen;
 }
-declare type NestedTaskMapper = {
+type NestedTaskMapper = {
     (tasks: Partial<TaskDefTypesGen>[]): TaskDefTypes[];
 };
 
@@ -2394,12 +2766,20 @@ declare class MetadataClient {
      * @returns
      */
     registerWorkflowDef(workflowDef: WorkflowDef$1, overwrite?: boolean): any;
+    /**
+     * Unregister (overwrite: true) a workflow definition
+     *
+     * @param workflowDef
+     * @param overwrite
+     * @returns
+     */
+    unregisterWorkflow(workflowName: string, version?: number): any;
 }
 
-declare type FetchFn<T = RequestInit, R extends {
+type FetchFn<T = RequestInit, R extends {
     json: () => Promise<any>;
 } = Response> = (input: RequestInfo, init?: T) => Promise<R>;
-declare type OrkesApiConfig = ConductorClientAPIConfig & GenerateTokenRequest;
+type OrkesApiConfig = ConductorClientAPIConfig & GenerateTokenRequest;
 
 /**
  * Takes a config with keyId and keySecret returns a promise with an instance of ConductorClient
@@ -2408,7 +2788,7 @@ declare type OrkesApiConfig = ConductorClientAPIConfig & GenerateTokenRequest;
  * @param requestHandler (optional) ConductorHttpRequest handler
  * @returns
  */
-declare const orkesConductorClient: (config?: Partial<OrkesApiConfig> | undefined, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
+declare const orkesConductorClient: (config?: Partial<OrkesApiConfig>, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
 
 declare class AuthConductorClient extends ConductorClient {
     intervalId?: NodeJS.Timeout;
@@ -2420,7 +2800,7 @@ declare class AuthConductorClient extends ConductorClient {
 }
 declare const baseOrkesConductorClient: <T = RequestInit, R extends {
     json: () => Promise<any>;
-} = Response>(fetchFn: FetchFn<T, R>, baseRequestHandler?: ConductorHttpRequest) => (config?: Partial<OrkesApiConfig> | undefined, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
+} = Response>(fetchFn: FetchFn<T, R>, baseRequestHandler?: ConductorHttpRequest) => (config?: Partial<OrkesApiConfig>, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
 
 /**
  * Request method
@@ -2431,4 +2811,4 @@ declare const baseOrkesConductorClient: <T = RequestInit, R extends {
  */
 declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions, fetchFn?: FetchFn) => CancelablePromise<T>;
 
-export { Action, ApiError, ApiRequestOptions, ApiResult, AuthConductorClient, BaseHttpRequest, CancelError, CancelablePromise, CommonTaskDef, ConductorClient, ConductorClientAPIConfig, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, EventHandler, EventResourceService, EventTaskDef, ExternalStorageLocation, FetchFn, ForkJoinDynamicDef, ForkJoinTaskDef, GenerateTokenRequest, HTScrollableSearchResultHumanTaskEntry, HealthCheckResourceService, HttpInputParameters, HttpTaskDef, HumanExecutor, HumanTaskAssignment, HumanTaskDefinition, HumanTaskEntry, HumanTaskSearch, HumanTaskSearchResult, HumanTaskTemplate, HumanTaskTrigger, HumanTaskUser, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishInputParameters, KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, MetadataResourceService, OnCancel, OpenAPIConfig, OrkesApiConfig, PollData, RequestType, RerunWorkflowRequest, Response$1 as Response, RunnerArgs, SaveScheduleRequest, SchedulerClient, SchedulerResourceService, ScrollableSearchResultWorkflowSummary, SearchResultTask, SearchResultTaskSummary, SearchResultWorkflow, SearchResultWorkflowScheduleExecutionModel, SearchResultWorkflowSummary, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflow, StartWorkflowRequest, SubWorkflowParams, SubWorkflowTaskDef, SwitchTaskDef, Task, TaskClient, TaskDef, TaskDefTypes, TaskDetails, TaskErrorHandler, TaskExecLog, TaskFinderPredicate, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResourceService, TaskResult, TaskResultStatus, TaskRunner, TaskRunnerOptions, TaskSummary, TaskType, TemplateClient, Terminate, TerminateTaskDef, TimeoutPolicy, TokenResourceService, UserFormTemplate, WaitTaskDef, Workflow, WorkflowBulkResourceService, WorkflowDef, WorkflowExecutor, WorkflowResourceService, WorkflowSchedule, WorkflowScheduleExecutionModel, WorkflowStatus, WorkflowSummary, WorkflowTask, baseOrkesConductorClient, completedTaskMatchingType, 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, noopLogger, orkesConductorClient, request, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };
+export { type Action, ApiError, type ApiRequestOptions, type ApiResult, AuthConductorClient, BaseHttpRequest, CancelError, CancelablePromise, type CommonTaskDef, ConductorClient, type ConductorClientAPIConfig, ConductorError, type ConductorHttpRequest, type ConductorLogLevel, type ConductorLogger, type ConductorWorker, Consistency, DefaultLogger, type DefaultLoggerConfig, type DoWhileTaskDef, type EventHandler, EventResourceService, type EventTaskDef, type ExternalStorageLocation, type FetchFn, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateTokenRequest, type HTScrollableSearchResultHumanTaskEntry, HealthCheckResourceService, type HttpInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type JoinTaskDef, type JsonJQTransformTaskDef, type KafkaPublishInputParameters, type KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, MetadataResourceService, type OnCancel, type OpenAPIConfig, type OrkesApiConfig, type PollData, type RequestType, type RerunWorkflowRequest, type Response$1 as Response, ReturnStrategy, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, SchedulerResourceService, type ScrollableSearchResultWorkflowSummary, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, type SetVariableTaskDef, type SimpleTaskDef, type SkipTaskRequest, type StartWorkflow, type StartWorkflowRequest, type SubWorkflowParams, type SubWorkflowTaskDef, type SwitchTaskDef, type Task, TaskClient, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskFinderPredicate, TaskManager, type TaskManagerConfig, type TaskManagerOptions, TaskResourceService, type TaskResult, type TaskResultStatus, TaskRunner, type TaskRunnerOptions, type TaskSummary, TaskType, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, TokenResourceService, type UserFormTemplate, type WaitTaskDef, type Workflow, WorkflowBulkResourceService, type WorkflowDef, WorkflowExecutor, WorkflowResourceService, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, baseOrkesConductorClient, completedTaskMatchingType, 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, noopLogger, orkesConductorClient, request, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };