declare type ApiRequestOptions = { readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH'; readonly url: string; readonly path?: Record; readonly cookies?: Record; readonly headers?: Record; readonly query?: Record; readonly formData?: Record; readonly body?: any; readonly mediaType?: string; readonly responseHeader?: string; readonly errors?: Record; }; declare class CancelError extends Error { constructor(message: string); get isCancelled(): boolean; } interface OnCancel { readonly isResolved: boolean; readonly isRejected: boolean; readonly isCancelled: boolean; (cancelHandler: () => void): void; } declare class CancelablePromise implements Promise { readonly [Symbol.toStringTag]: string; private _isResolved; private _isRejected; private _isCancelled; private readonly _cancelHandlers; private readonly _promise; private _resolve?; private _reject?; constructor(executor: (resolve: (value: T | PromiseLike) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void); then(onFulfilled?: ((value: T) => TResult1 | PromiseLike) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike) | null): Promise; catch(onRejected?: ((reason: any) => TResult | PromiseLike) | null): Promise; finally(onFinally?: (() => void) | null): Promise; cancel(): void; get isCancelled(): boolean; } declare type Resolver = (options: ApiRequestOptions) => Promise; declare type Headers = Record; declare type OpenAPIConfig = { BASE: string; VERSION: string; WITH_CREDENTIALS: boolean; CREDENTIALS: 'include' | 'omit' | 'same-origin'; TOKEN?: string | Resolver; USERNAME?: string | Resolver; PASSWORD?: string | Resolver; HEADERS?: Headers | Resolver; ENCODE_PATH?: (path: string) => string; }; declare abstract class BaseHttpRequest { readonly config: OpenAPIConfig; constructor(config: OpenAPIConfig); abstract request(options: ApiRequestOptions): CancelablePromise; } declare type StartWorkflow = { name?: string; version?: number; correlationId?: string; input?: Record; taskToDomain?: Record; }; declare type TaskDetails = { workflowId?: string; taskRefName?: string; output?: Record; taskId?: string; }; declare type Action = { action?: 'start_workflow' | 'complete_task' | 'fail_task'; start_workflow?: StartWorkflow; complete_task?: TaskDetails; fail_task?: TaskDetails; expandInlineJSON?: boolean; }; declare type EventHandler = { name: string; event: string; condition?: string; actions: Array; active?: boolean; evaluatorType?: string; }; declare class EventResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Get queue config by name * @param queueType * @param queueName * @returns any OK * @throws ApiError */ getQueueConfig(queueType: string, queueName: string): CancelablePromise; /** * Create or update queue config by name * @param queueType * @param queueName * @param requestBody * @returns any OK * @throws ApiError */ putQueueConfig(queueType: string, queueName: string, requestBody: string): CancelablePromise; /** * Delete queue config by name * @param queueType * @param queueName * @returns any OK * @throws ApiError */ deleteQueueConfig(queueType: string, queueName: string): CancelablePromise; /** * Get all the event handlers * @returns EventHandler OK * @throws ApiError */ getEventHandlers(): CancelablePromise>; /** * Update an existing event handler. * @param requestBody * @returns any OK * @throws ApiError */ updateEventHandler(requestBody: EventHandler): CancelablePromise; /** * Add a new event handler. * @param requestBody * @returns any OK * @throws ApiError */ addEventHandler(requestBody: EventHandler): CancelablePromise; /** * Get all queue configs * @returns any OK * @throws ApiError */ getQueueNames(): CancelablePromise; /** * Remove an event handler * @param name * @returns any OK * @throws ApiError */ removeEventHandlerStatus(name: string): CancelablePromise; /** * Get event handlers for a given event * @param event * @param activeOnly * @returns EventHandler OK * @throws ApiError */ getEventHandlersForEvent(event: string, activeOnly?: boolean): CancelablePromise>; } declare class HealthCheckResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * @returns any OK * @throws ApiError */ doCheck(): CancelablePromise>; } declare type TaskDef = { ownerApp?: string; createTime?: number; updateTime?: number; createdBy?: string; updatedBy?: string; name: string; description?: string; retryCount?: number; timeoutSeconds: number; inputKeys?: Array; outputKeys?: Array; timeoutPolicy?: 'RETRY' | 'TIME_OUT_WF' | 'ALERT_ONLY'; retryLogic?: 'FIXED' | 'EXPONENTIAL_BACKOFF' | 'LINEAR_BACKOFF'; retryDelaySeconds?: number; responseTimeoutSeconds?: number; concurrentExecLimit?: number; inputTemplate?: Record; rateLimitPerFrequency?: number; rateLimitFrequencyInSeconds?: number; isolationGroupId?: string; executionNameSpace?: string; ownerEmail?: string; pollTimeoutSeconds?: number; backoffScaleFactor?: number; }; declare type SubWorkflowParams = { name: string; version?: number; taskToDomain?: Record; workflowDefinition?: WorkflowDef$1; idempotencyKey?: string; idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING'; }; declare type WorkflowTask = { name: string; taskReferenceName: string; description?: string; inputParameters?: Record; type?: string; dynamicTaskNameParam?: string; /** * @deprecated */ caseValueParam?: string; /** * @deprecated */ caseExpression?: string; scriptExpression?: string; decisionCases?: Record>; /** * @deprecated */ dynamicForkJoinTasksParam?: string; dynamicForkTasksParam?: string; dynamicForkTasksInputParamName?: string; defaultCase?: Array; forkTasks?: Array>; startDelay?: number; subWorkflowParam?: SubWorkflowParams; joinOn?: Array; sink?: string; optional?: boolean; taskDefinition?: TaskDef; rateLimited?: boolean; defaultExclusiveJoinTask?: Array; asyncComplete?: boolean; loopCondition?: string; loopOver?: Array; retryCount?: number; evaluatorType?: string; expression?: string; 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 = { ownerApp?: string; createTime?: number; updateTime?: number; createdBy?: string; updatedBy?: string; name: string; description?: string; version?: number; tasks: Array; inputParameters?: Array; outputParameters?: Record; failureWorkflow?: string; schemaVersion?: number; restartable?: boolean; workflowStatusListenerEnabled?: boolean; ownerEmail?: string; timeoutPolicy?: 'TIME_OUT_WF' | 'ALERT_ONLY'; timeoutSeconds: number; variables?: Record; inputTemplate?: Record; }; declare class MetadataResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Gets the task definition * @param tasktype * @param metadata * @returns TaskDef OK * @throws ApiError */ getTaskDef(tasktype: string, metadata?: boolean): CancelablePromise; /** * Remove a task definition * @param tasktype * @returns any OK * @throws ApiError */ unregisterTaskDef(tasktype: string): CancelablePromise; /** * Retrieves all workflow definition along with blueprint * @param access * @param metadata * @param tagKey * @param tagValue * @returns WorkflowDef OK * @throws ApiError */ getAllWorkflows(access?: string, metadata?: boolean, tagKey?: string, tagValue?: string): CancelablePromise>; /** * Create or update workflow definition(s) * @param requestBody * @param overwrite * @returns any OK * @throws ApiError */ update(requestBody: Array, overwrite?: boolean): CancelablePromise; /** * Create a new workflow definition * @param requestBody * @param overwrite * @returns any OK * @throws ApiError */ create(requestBody: WorkflowDef$1, overwrite?: boolean): CancelablePromise; /** * Gets all task definition * @param access * @param metadata * @param tagKey * @param tagValue * @returns TaskDef OK * @throws ApiError */ getTaskDefs(access?: string, metadata?: boolean, tagKey?: string, tagValue?: string): CancelablePromise>; /** * Update an existing task * @param requestBody * @returns any OK * @throws ApiError */ updateTaskDef(requestBody: TaskDef): CancelablePromise; /** * Create or update task definition(s) * @param requestBody * @returns any OK * @throws ApiError */ registerTaskDef(requestBody: Array): CancelablePromise; /** * Removes workflow definition. It does not remove workflows associated with the definition. * @param name * @param version * @returns any OK * @throws ApiError */ unregisterWorkflowDef(name: string, version: number): CancelablePromise; /** * Retrieves workflow definition along with blueprint * @param name * @param version * @param metadata * @returns WorkflowDef OK * @throws ApiError */ get(name: string, version?: number, metadata?: boolean): CancelablePromise; } declare type StartWorkflowRequest = { name: string; version?: number; correlationId?: string; input?: Record; taskToDomain?: Record; workflowDef?: WorkflowDef$1; externalInputPayloadStoragePath?: string; idempotencyKey?: string; idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING'; priority?: number; createdBy?: string; }; declare type SaveScheduleRequest = { name: string; cronExpression: string; runCatchupScheduleInstances?: boolean; paused?: boolean; startWorkflowRequest?: StartWorkflowRequest; createdBy?: string; updatedBy?: string; scheduleStartTime?: number; scheduleEndTime?: number; }; declare type WorkflowScheduleExecutionModel = { executionId?: string; scheduleName?: string; scheduledTime?: number; executionTime?: number; workflowName?: string; workflowId?: string; reason?: string; stackTrace?: string; startWorkflowRequest?: StartWorkflowRequest; state?: 'POLLED' | 'FAILED' | 'EXECUTED'; }; declare type SearchResultWorkflowScheduleExecutionModel = { totalHits?: number; results?: Array; }; declare type WorkflowSchedule = { name?: string; cronExpression?: string; runCatchupScheduleInstances?: boolean; paused?: boolean; startWorkflowRequest?: StartWorkflowRequest; scheduleStartTime?: number; scheduleEndTime?: number; createTime?: number; updatedTime?: number; createdBy?: string; updatedBy?: string; }; declare class SchedulerResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Get an existing workflow schedule by name * @param name * @returns any OK * @throws ApiError */ getSchedule(name: string): CancelablePromise; /** * Deletes an existing workflow schedule by name * @param name * @returns any OK * @throws ApiError */ deleteSchedule(name: string): CancelablePromise; /** * 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: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): CancelablePromise>; /** * Pauses an existing schedule by name * @param name * @returns any OK * @throws ApiError */ pauseSchedule(name: string): CancelablePromise; /** * Pause all scheduling in a single conductor server instance (for debugging only) * @returns any OK * @throws ApiError */ pauseAllSchedules(): CancelablePromise>; /** * Resume a paused schedule by name * @param name * @returns any OK * @throws ApiError */ resumeSchedule(name: string): CancelablePromise; /** * Requeue all execution records * @returns any OK * @throws ApiError */ requeueAllExecutionRecords(): CancelablePromise>; /** * Resume all scheduling * @returns any OK * @throws ApiError */ resumeAllSchedules(): CancelablePromise>; /** * Get all existing workflow schedules and optionally filter by workflow name * @param workflowName * @returns WorkflowSchedule OK * @throws ApiError */ getAllSchedules(workflowName?: string): CancelablePromise>; /** * Create or update a schedule for a specified workflow with a corresponding start workflow request * @param requestBody * @returns any OK * @throws ApiError */ saveSchedule(requestBody: SaveScheduleRequest): CancelablePromise; /** * Test timeout - do not use in production * @returns any OK * @throws ApiError */ testTimeout(): CancelablePromise; /** * Search for workflows based on payload and other parameters * use sort options as sort=: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?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise; } declare type ExternalStorageLocation = { uri?: string; path?: string; }; declare type PollData = { queueName?: string; domain?: string; workerId?: string; lastPollTime?: number; }; declare type Task = { taskType?: string; status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED'; inputData?: Record; referenceTaskName?: string; retryCount?: number; seq?: number; correlationId?: string; pollCount?: number; taskDefName?: string; scheduledTime?: number; startTime?: number; endTime?: number; updateTime?: number; startDelayInSeconds?: number; retriedTaskId?: string; retried?: boolean; executed?: boolean; callbackFromWorker?: boolean; responseTimeoutSeconds?: number; workflowInstanceId?: string; workflowType?: string; taskId?: string; reasonForIncompletion?: string; callbackAfterSeconds?: number; workerId?: string; outputData?: Record; workflowTask?: WorkflowTask; domain?: string; rateLimitPerFrequency?: number; rateLimitFrequencyInSeconds?: number; externalInputPayloadStoragePath?: string; externalOutputPayloadStoragePath?: string; workflowPriority?: number; executionNameSpace?: string; isolationGroupId?: string; iteration?: number; subWorkflowId?: string; subworkflowChanged?: boolean; queueWaitTime?: number; taskDefinition?: TaskDef; loopOverTask?: boolean; }; declare type SearchResultTask = { totalHits?: number; results?: Array; }; declare type TaskSummary = { workflowId?: string; workflowType?: string; correlationId?: string; scheduledTime?: string; startTime?: string; updateTime?: string; endTime?: string; status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED'; reasonForIncompletion?: string; executionTime?: number; queueWaitTime?: number; taskDefName?: string; taskType?: string; input?: string; output?: string; taskId?: string; externalInputPayloadStoragePath?: string; externalOutputPayloadStoragePath?: string; workflowPriority?: number; }; declare type SearchResultTaskSummary = { totalHits?: number; results?: Array; }; declare type TaskExecLog = { log?: string; taskId?: string; createdTime?: number; }; declare type TaskResult = { workflowInstanceId: string; taskId: string; reasonForIncompletion?: string; callbackAfterSeconds?: number; workerId?: string; status?: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED'; outputData?: Record; logs?: Array; externalOutputPayloadStoragePath?: string; subWorkflowId?: string; }; declare class TaskResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Poll for a task of a certain type * @param tasktype * @param workerid * @param domain * @returns Task OK * @throws ApiError */ poll(tasktype: string, workerid?: string, domain?: string): CancelablePromise; /** * Get the details about each queue * @returns number OK * @throws ApiError */ allVerbose(): CancelablePromise>>>; /** * Update a task By Ref Name * @param workflowId * @param taskRefName * @param status * @param requestBody * @returns string OK * @throws ApiError */ updateTask(workflowId: string, taskRefName: string, status: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED', requestBody: Record): CancelablePromise; /** * Get task by Id * @param taskId * @returns Task OK * @throws ApiError */ getTask(taskId: string): CancelablePromise; /** * Get the details about each queue * @returns number OK * @throws ApiError */ all(): CancelablePromise>; /** * Requeue pending tasks * @param taskType * @returns string OK * @throws ApiError */ requeuePendingTask(taskType: string): CancelablePromise; /** * Search for tasks based in payload and other parameters * use sort options as sort=: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?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise; /** * Search for tasks based in payload and other parameters * use sort options as sort=: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?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise; /** * Get the last poll data for a given task type * @param taskType * @returns PollData OK * @throws ApiError */ getPollData(taskType: string): CancelablePromise>; /** * Get Task Execution Logs * @param taskId * @returns TaskExecLog OK * @throws ApiError */ getTaskLogs(taskId: string): CancelablePromise>; /** * Log Task Execution Details * @param taskId * @param requestBody * @returns any OK * @throws ApiError */ log(taskId: string, requestBody: string): CancelablePromise; /** * Get the last poll data for all task types * @returns PollData OK * @throws ApiError */ getAllPollData(): CancelablePromise>; /** * 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: string, workerid?: string, domain?: string, count?: number, timeout?: number): CancelablePromise>; /** * Update a task * @param requestBody * @returns string OK * @throws ApiError */ updateTask1(requestBody: TaskResult): CancelablePromise; /** * Get Task type queue sizes * @param taskType * @returns number OK * @throws ApiError */ size1(taskType?: Array): CancelablePromise>; /** * 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: string, operation: string, payloadType: string): CancelablePromise; } declare type GenerateTokenRequest = { keyId: string; keySecret: string; refreshTokenInterval?: number; }; declare type Response$1 = {}; declare class TokenResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Generate JWT with the given access key * @param requestBody * @returns Response OK * @throws ApiError */ generateToken(requestBody: GenerateTokenRequest): CancelablePromise; /** * Get the user info from the token * @returns any OK * @throws ApiError */ getUserInfo(): CancelablePromise; } declare type BulkResponse = { bulkErrorResults?: Record; bulkSuccessfulResults?: Array; }; declare class WorkflowBulkResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Retry the last failed task for each workflow from the list * @param requestBody * @returns BulkResponse OK * @throws ApiError */ retry(requestBody: Array): CancelablePromise; /** * Restart the list of completed workflow * @param requestBody * @param useLatestDefinitions * @returns BulkResponse OK * @throws ApiError */ restart(requestBody: Array, useLatestDefinitions?: boolean): CancelablePromise; /** * Terminate workflows execution * @param requestBody * @param reason * @returns BulkResponse OK * @throws ApiError */ terminate(requestBody: Array, reason?: string): CancelablePromise; /** * Resume the list of workflows * @param requestBody * @returns BulkResponse OK * @throws ApiError */ resumeWorkflow(requestBody: Array): CancelablePromise; /** * Pause the list of workflows * @param requestBody * @returns BulkResponse OK * @throws ApiError */ pauseWorkflow1(requestBody: Array): CancelablePromise; } declare type RerunWorkflowRequest = { reRunFromWorkflowId?: string; workflowInput?: Record; reRunFromTaskId?: string; taskInput?: Record; correlationId?: string; }; declare type WorkflowSummary = { workflowType?: string; version?: number; workflowId?: string; correlationId?: string; startTime?: string; updateTime?: string; endTime?: string; status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED'; input?: string; output?: string; reasonForIncompletion?: string; executionTime?: number; event?: string; failedReferenceTaskNames?: string; externalInputPayloadStoragePath?: string; externalOutputPayloadStoragePath?: string; priority?: number; createdBy?: string; outputSize?: number; inputSize?: number; }; declare type ScrollableSearchResultWorkflowSummary = { results?: Array; 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; input?: Record; output?: Record; correlationId?: string; reRunFromWorkflowId?: string; reasonForIncompletion?: string; event?: string; taskToDomain?: Record; failedReferenceTaskNames?: Array; workflowDefinition?: WorkflowDef$1; externalInputPayloadStoragePath?: string; externalOutputPayloadStoragePath?: string; priority?: number; variables?: Record; lastRetriedTime?: number; startTime?: number; workflowVersion?: number; workflowName?: string; }; declare type SearchResultWorkflow = { totalHits?: number; results?: Array; }; declare type SearchResultWorkflowSummary = { totalHits?: number; results?: Array; }; declare type SkipTaskRequest = { taskInput?: Record; taskOutput?: Record; }; declare type WorkflowRun = { correlationId?: string; createTime?: number; createdBy?: string; priority?: number; requestId?: string; status?: string; tasks?: Array; updateTime?: number; workflowId?: string; variables?: Record; input?: Record; output?: Record; }; declare type WorkflowStatus = { workflowId?: string; correlationId?: string; output?: Record; variables?: Record; status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED'; }; declare type TaskMock = { executionTime?: number; output: Record; queueWaitTime?: number; status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED"; }; declare type WorkflowTestRequest = { correlationId?: string; createdBy?: string; externalInputPayloadStoragePath?: string; idempotencyKey?: string; idempotencyStrategy?: "FAIL" | "RETURN_EXISTING"; input?: Record>; name: string; priority?: number; subWorkflowTestRequest?: Record; taskRefToMockOutput?: Record>; taskToDomain?: Record; version?: number; workflowDef?: WorkflowDef$1; }; declare class WorkflowResourceService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * Retrieve all the running workflows * @param name * @param version * @param startTime * @param endTime * @returns string OK * @throws ApiError */ getRunningWorkflow(name: string, version?: number, startTime?: number, endTime?: number): CancelablePromise>; /** * Execute a workflow synchronously * @param body * @param name * @param version * @param requestId * @param waitUntilTaskRef * @param callback * @returns workflowRun * @throws ApiError */ executeWorkflow(body: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string): CancelablePromise; /** * Start a new workflow with StartWorkflowRequest, which allows task to be executed in a domain * @param requestBody * @returns string OK * @throws ApiError */ startWorkflow(requestBody: StartWorkflowRequest): CancelablePromise; /** * Starts the decision task for a workflow * @param workflowId * @returns any OK * @throws ApiError */ decide(workflowId: string): CancelablePromise; /** * Reruns the workflow from a specific task * @param workflowId * @param requestBody * @returns string OK * @throws ApiError */ rerun(workflowId: string, requestBody: RerunWorkflowRequest): CancelablePromise; /** * Search for workflows based on payload and other parameters * use sort options as sort=: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?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise; /** * Pauses the workflow * @param workflowId * @returns any OK * @throws ApiError */ pauseWorkflow(workflowId: string): CancelablePromise; /** * Skips a given task from a current running workflow * @param workflowId * @param taskReferenceName * @param requestBody * @returns any OK * @throws ApiError */ skipTaskFromWorkflow(workflowId: string, taskReferenceName: string, requestBody?: SkipTaskRequest): CancelablePromise; /** * Lists workflows for the given correlation id list * @param name * @param requestBody * @param includeClosed * @param includeTasks * @returns Workflow OK * @throws ApiError */ getWorkflows(name: string, requestBody: Array, includeClosed?: boolean, includeTasks?: boolean): CancelablePromise>>; /** * Gets the workflow by workflow id * @param workflowId * @param includeOutput * @param includeVariables * @returns WorkflowStatus OK * @throws ApiError */ getWorkflowStatusSummary(workflowId: string, includeOutput?: boolean, includeVariables?: boolean): CancelablePromise; /** * Lists workflows for the given correlation id * @param name * @param correlationId * @param includeClosed * @param includeTasks * @returns Workflow OK * @throws ApiError */ getWorkflows1(name: string, correlationId: string, includeClosed?: boolean, includeTasks?: boolean): CancelablePromise>; /** * Retries the last failed task * @param workflowId * @param resumeSubworkflowTasks * @returns void * @throws ApiError */ retry1(workflowId: string, resumeSubworkflowTasks?: boolean): CancelablePromise; /** * Gets the workflow by workflow id * @param workflowId * @param includeTasks * @returns Workflow OK * @throws ApiError */ getExecutionStatus(workflowId: string, includeTasks?: boolean): CancelablePromise; /** * Terminate workflow execution * @param workflowId * @param reason * @returns any OK * @throws ApiError */ terminate1(workflowId: string, reason?: string): CancelablePromise; /** * Resumes the workflow * @param workflowId * @returns any OK * @throws ApiError */ resumeWorkflow(workflowId: string): CancelablePromise; /** * Removes the workflow from the system * @param workflowId * @param archiveWorkflow * @returns any OK * @throws ApiError */ delete(workflowId: string, archiveWorkflow?: boolean): CancelablePromise; /** * Search for workflows based on task parameters * use sort options as sort=: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?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise; /** * 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: string, operation: string, payloadType: string): CancelablePromise; /** * 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: string, requestBody: Record, version?: number, correlationId?: string, priority?: number): CancelablePromise; /** * Restarts a completed workflow * @param workflowId * @param useLatestDefinitions * @returns void * @throws ApiError */ restart1(workflowId: string, useLatestDefinitions?: boolean): CancelablePromise; /** * Search for workflows based on payload and other parameters * use sort options as sort=: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?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean): CancelablePromise; /** * Search for workflows based on task parameters * use sort options as sort=: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?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise; /** * Resets callback times of all non-terminal SIMPLE tasks to 0 * @param workflowId * @returns void * @throws ApiError */ resetWorkflow(workflowId: string): CancelablePromise; /** * Test workflow execution using mock data * @param requestBody * @returns Workflow OK * @throws ApiError */ testWorkflow(requestBody: WorkflowTestRequest): CancelablePromise; } /** * Request method * @param config The OpenAPI configuration object * @param options The request options from the service * @returns CancelablePromise * @throws ApiError */ declare const request$1: (config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise; /** * A handler to modify requests made by ConductorClient. Useful for metrics/option transformation/etc. * * @remarks * Example: Customizing the request URL * ``` * * const requestCustomizer = (request, config, options) => { * const url = options.url.replace(/^\/api/, '') * return request(config, {...options, url }); * } * const config = { BASE: "https://my-api.com"} * const client = new ConductorClient(config, requestCustomizer) * ``` * * @param request the underlying node-fetch powered function * @param config @see OpenAPIConfig * @param options {see ApiRequestOptions} */ declare type RequestType = typeof request$1; declare type ConductorHttpRequest = (request: RequestType, config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise; declare type HumanTaskUser = { user?: string; userType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP'; }; declare type HumanTaskAssignment = { assignee?: HumanTaskUser; slaMinutes?: number; }; declare type HumanTaskTrigger = { startWorkflowRequest?: StartWorkflowRequest; triggerType?: 'ASSIGNEE_CHANGED' | 'PENDING' | 'IN_PROGRESS' | 'ASSIGNED' | 'COMPLETED' | 'TIMED_OUT'; }; declare type UserFormTemplate = { name?: string; version?: number; }; declare type HumanTaskDefinition = { assignmentCompletionStrategy?: 'LEAVE_OPEN' | 'TERMINATE'; assignments?: Array; taskTriggers?: Array; userFormTemplate?: UserFormTemplate; }; declare type HumanTaskEntry = { assignee?: HumanTaskUser; claimant?: HumanTaskUser; createdBy?: string; createdOn?: number; definitionName?: string; displayName?: string; humanTaskDef?: HumanTaskDefinition; input?: Record; output?: Record; state?: 'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT' | 'DELETED'; taskId?: string; taskRefName?: string; updatedBy?: string; updatedOn?: number; workflowId?: string; workflowName?: string; }; declare type HumanTaskSearch = { assignees?: Array; claimants?: Array; definitionNames?: Array; taskOutputQuery?: string; taskInputQuery?: string; searchType?: 'ADMIN' | 'INBOX'; size?: number; start?: number; states?: Array<'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT' | 'DELETED'>; taskRefNames?: Array; workflowNames?: Array; }; declare type HumanTaskSearchResult = { results?: Array; totalHits?: number; }; declare type HumanTaskTemplate = { createdBy?: string; createdOn?: number; jsonSchema: Record; name: string; templateUI: Record; updatedBy?: string; updatedOn?: number; version: number; }; declare class HumanTaskService { readonly httpRequest: BaseHttpRequest; constructor(httpRequest: BaseHttpRequest); /** * If the workflow is disconnected from tasks, this API can be used to clean up (in bulk) * @param requestBody * @returns any OK * @throws ApiError */ deleteTaskFromHumanTaskRecords(requestBody: Array): CancelablePromise; /** * If the workflow is disconnected from tasks, this API can be used to clean up * @param taskId * @returns any OK * @throws ApiError */ deleteTaskFromHumanTaskRecords1(taskId: string): CancelablePromise; /** * Search human tasks * @param requestBody * @returns HumanTaskSearchResult OK * @throws ApiError */ search(requestBody: HumanTaskSearch): CancelablePromise; /** * Update task output, optionally complete * @param workflowId * @param taskRefName * @param requestBody * @param complete * @param iteration Populate this value if your task is in a loop and you want to update a specific iteration. If its not in a loop OR if you want to just update the latest iteration, leave this as empty * @returns any OK * @throws ApiError */ updateTaskOutputByRef(workflowId: string, taskRefName: string, requestBody: Record, complete?: boolean, iteration?: Array): CancelablePromise; /** * Get a task * @param taskId * @returns HumanTaskEntry OK * @throws ApiError */ getTask1(taskId: string): CancelablePromise; /** * Claim a task by authenticated Conductor user * @param taskId * @param overrideAssignment * @returns any OK * @throws ApiError */ claimTask(taskId: string, overrideAssignment?: boolean, withTemplate?: boolean): CancelablePromise; /** * Claim a task to an external user * @param taskId * @param userId * @param overrideAssignment * @returns any OK * @throws ApiError */ assignAndClaim(taskId: string, userId: string, overrideAssignment?: boolean, withTemplate?: boolean): CancelablePromise; /** * Release a task without completing it * @param taskId * @param requestBody * @returns any OK * @throws ApiError */ reassignTask(taskId: string, requestBody: Array): CancelablePromise; /** * Release a task without completing it * @param taskId * @returns any OK * @throws ApiError */ releaseTask(taskId: string): CancelablePromise; /** * 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; /** * Update task output, optionally complete * @param taskId * @param requestBody * @param complete * @returns any OK * @throws ApiError */ updateTaskOutput(taskId: string, requestBody: Record, complete?: boolean): CancelablePromise; /** * 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>; /** * Save user form template * @param requestBody * @param newVersion * @returns HumanTaskTemplate OK * @throws ApiError */ saveTemplate(requestBody: HumanTaskTemplate, newVersion?: boolean): CancelablePromise; /** * Save user form template * @param requestBody * @param newVersion * @returns HumanTaskTemplate OK * @throws ApiError */ saveTemplates(requestBody: Array, newVersion?: boolean): CancelablePromise>; /** * Delete all versions of user form template by name * @param name * @returns any OK * @throws ApiError */ deleteTemplateByName(name: string): CancelablePromise; /** * Delete a version of form template by name * @param name * @param version * @returns any OK * @throws ApiError */ deleteTemplatesByNameAndVersion(name: string, version: number): CancelablePromise; /** * Get user form template by name and version * @param name * @param version * @returns HumanTaskTemplate OK * @throws ApiError */ getTemplateByNameAndVersion(name: string, version: number): CancelablePromise; } 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; } interface ConductorClientAPIConfig extends Omit { serverUrl: string; useEnvVars: boolean; } declare class ConductorClient { readonly eventResource: EventResourceService; readonly healthCheckResource: HealthCheckResourceService; readonly metadataResource: MetadataResourceService; readonly schedulerResource: SchedulerResourceService; readonly taskResource: TaskResourceService; readonly tokenResource: TokenResourceService; readonly workflowBulkResource: WorkflowBulkResourceService; readonly workflowResource: WorkflowResourceService; readonly humanTask: HumanTaskService; readonly humanTaskResource: HumanTaskResourceService; readonly request: BaseHttpRequest; token?: string | Resolver; constructor(config?: Partial, requestHandler?: ConductorHttpRequest); stop(): void; } declare type ApiResult = { readonly url: string; readonly ok: boolean; readonly status: number; readonly statusText: string; readonly body: any; }; declare class ApiError extends Error { readonly url: string; readonly status: number; readonly statusText: string; readonly body: any; readonly request: ApiRequestOptions; constructor(request: ApiRequestOptions, response: ApiResult, message: string); } declare type HTScrollableSearchResultHumanTaskEntry = { queryId?: string; results?: Array; }; declare type TimeoutPolicy = { type: string; }; declare type Terminate = (TimeoutPolicy & { timeoutSeconds?: number; }); /** * Functional interface for defining a worker implementation that processes tasks from a conductor queue. * * @remarks * Optional items allow overriding properties on a per-worker basis. Items not overridden * here will be inherited from the `TaskManager` options. */ interface ConductorWorker { taskDefName: string; execute: (task: Task) => Promise>; domain?: string; concurrency?: number; pollInterval?: number; } interface ConductorLogger { info(...args: any): void; error(...args: any): void; debug(...args: any): void; } declare type ConductorLogLevel = keyof typeof LOG_LEVELS; interface DefaultLoggerConfig { level?: ConductorLogLevel; tags?: Object[]; } declare const LOG_LEVELS: { readonly DEBUG: 10; readonly INFO: 30; readonly ERROR: 60; }; declare class DefaultLogger implements ConductorLogger { private readonly tags; private readonly level; constructor(config?: DefaultLoggerConfig); private log; info: (...args: any) => void; debug: (...args: any) => void; error: (...args: any) => void; } 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; 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; forkTasks: Array>; } interface JoinTaskDef extends CommonTaskDef { type: TaskType.JOIN; inputParameters?: Record; 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; 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; 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; } interface SimpleTaskDef extends CommonTaskDef { type: TaskType.SIMPLE; inputParameters?: Record; } interface SubWorkflowTaskDef extends CommonTaskDef { type: TaskType.SUB_WORKFLOW; inputParameters?: Record; subWorkflowParam: { name: string; version?: number; taskToDomain?: Record; }; } interface SwitchTaskDef extends CommonTaskDef { inputParameters: Record; type: TaskType.SWITCH; decisionCases: Record; defaultCase: TaskDefTypes[]; evaluatorType: "value-param" | "javascript"; expression: string; } interface TerminateTaskDef extends CommonTaskDef { inputParameters: { terminationStatus: "COMPLETED" | "FAILED"; workflowOutput?: Record; 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 { inputParameters: string[]; version: number; tasks: TaskDefTypes[]; } declare type TaskErrorHandler = (error: Error, task?: Task) => void; interface TaskRunnerOptions { workerID: string; domain: string | undefined; pollInterval?: number; concurrency?: number; batchPollingTimeout?: number; } interface RunnerArgs { worker: ConductorWorker; taskResource: TaskResourceService; options: TaskRunnerOptions; logger?: ConductorLogger; onError?: TaskErrorHandler; concurrency?: number; maxRetries?: number; } declare const MAX_RETRIES = 3; declare const noopErrorHandler: TaskErrorHandler; /** * Responsible for polling and executing tasks from a queue. * * Because a `poll` in conductor "pops" a task off of a conductor queue, * each runner participates in the poll -> work -> update loop. * We could potentially split this work into a separate "poller" and "worker" pools * but that could lead to picking up more work than the pool of workers are actually able to handle. * */ declare class TaskRunner { taskResource: TaskResourceService; worker: ConductorWorker; private logger; private options; errorHandler: TaskErrorHandler; private poller; private maxRetries; constructor({ worker, taskResource, options, logger, onError: errorHandler, maxRetries, }: RunnerArgs); get isPolling(): boolean; /** * Starts polling for work */ startPolling: () => void; /** * Stops Polling for work */ stopPolling: () => Promise; updateOptions(options: Partial): void; get getOptions(): TaskRunnerOptions; private batchPoll; updateTaskWithRetry: (task: Task, taskResult: TaskResult) => Promise; private executeTask; handleUnknownError: (unknownError: unknown) => void; } declare type TaskManagerOptions = TaskRunnerOptions; interface TaskManagerConfig { logger?: ConductorLogger; options?: Partial; onError?: TaskErrorHandler; maxRetries?: number; } /** * Responsible for initializing and managing the runners that poll and work different task queues. */ declare class TaskManager { private workerRunners; private readonly client; private readonly logger; private readonly errorHandler; private workers; readonly options: Required; private polling; private maxRetries; constructor(client: ConductorClient, workers: Array, config?: TaskManagerConfig); private workerManagerWorkerOptions; get isPolling(): boolean; updatePollingOptionForWorker: (workerTaskDefName: string, options: Partial) => void; /** * new options will get merged to existing options * @param options new options to update polling options */ updatePollingOptions: (options: Partial) => void; sanityCheck: () => void; /** * Start polling for tasks */ startPolling: () => void; /** * Stops polling for tasks */ stopPolling: () => Promise; } declare class ConductorError extends Error { private _trace; private __proto__; constructor(message?: string, innerError?: Error); } declare type TaskResultStatus = NonNullable; declare type TaskFinderPredicate = (task: Task) => boolean; declare const completedTaskMatchingType: (taskType: string) => TaskFinderPredicate; declare class WorkflowExecutor { readonly _client: ConductorClient; constructor(client: ConductorClient); /** * 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: boolean, workflow: WorkflowDef): Promise; /** * Takes a StartWorkflowRequest. returns a Promise with the workflowInstanceId of the running workflow * @param workflowRequest * @returns */ startWorkflow(workflowRequest: StartWorkflowRequest): Promise; /** * Execute a workflow synchronously. returns a Promise with details of the running workflow * @param workflowRequest * @returns */ executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise; startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise[]; goBackToTask(workflowInstanceId: string, taskFinderPredicate: TaskFinderPredicate, rerunWorkflowRequestOverrides?: Partial): Promise; goBackToFirstTaskMatchingType(workflowInstanceId: string, taskType: string): Promise; /** * 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 */ getWorkflow(workflowInstanceId: string, includeTasks: boolean, retry?: number): Promise; /** * 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 */ getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): Promise; /** * 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 */ getExecution(workflowInstanceId: string, includeTasks?: boolean): Promise; /** * Pauses a running workflow * @param workflowInstanceId current workflow execution * @returns */ pause(workflowInstanceId: string): Promise; /** * Reruns workflowInstanceId workflow. with new parameters * * @param workflowInstanceId current workflow execution * @param rerunWorkflowRequest Rerun Workflow Execution Request * @returns */ reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial): Promise; /** * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion * @param workflowInstanceId * @param useLatestDefinitions * @returns */ restart(workflowInstanceId: string, useLatestDefinitions: boolean): Promise; /** * Resumes a previously paused execution * * @param workflowInstanceId Running workflow workflowInstanceId * @returns */ resume(workflowInstanceId: string): Promise; /** * Retrys workflow from last failing task * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows * * @param workflowInstanceId * @param resumeSubworkflowTasks * @returns */ retry(workflowInstanceId: string, resumeSubworkflowTasks: boolean): Promise; /** * Searches for existing workflows given the following querys * * @param start * @param size * @param query * @param freeText * @param sort * @param skipCache * @returns */ search(start: number, size: number, query: string, freeText: string, sort?: string, skipCache?: boolean): Promise; /** * 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: string, taskReferenceName: string, skipTaskRequest: Partial): Promise; /** * Takes an workflowInstanceId, and terminates a running workflow * @param workflowInstanceId * @param reason * @returns */ terminate(workflowInstanceId: string, reason: string): Promise; /** * 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: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: Record): Promise; /** * Updates a task by reference Name * @param taskReferenceName * @param workflowInstanceId * @param status * @param taskOutput * @returns */ updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: Record): Promise; /** * * @param taskId * @returns */ getTask(taskId: string): Promise; } declare type PollIntervalOptions = { pollInterval: number; maxPollTimes: number; }; declare class HumanExecutor { readonly _client: ConductorClient; constructor(client: ConductorClient); /** * @deprecated use search instead * 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, taskInputQuery?: string, taskOutputQuery?: string): Promise; /** * 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 Promise */ search(searchParams: Partial): Promise; /** * Takes a set of filter parameters. An polling interval options. will poll until the task returns a result * @param state * @param assignee * @param assigneeType * @param claimedBy * @param taskName * @param freeText * @param includeInputOutput * @returns Promise */ pollSearch(searchParams: Partial, { pollInterval, maxPollTimes, }?: PollIntervalOptions): Promise; /** * Returns task for a given task id * @param taskId * @returns */ getTaskById(taskId: string): Promise; /** * 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, options?: Record): Promise; /** * Claim task as conductor user * @param taskId * @returns */ claimTaskAsConductorUser(taskId: string, options?: Record): Promise; /** * Claim task as conductor user * @param taskId * @param assignee * @returns */ releaseTask(taskId: string): Promise; /** * Returns a HumanTaskTemplateEntry for a given name and version * @param templateId * @returns */ getTemplateByNameVersion(name: string, version: number): Promise; /** * @deprecated use getTemplate instead. name will be used as id here with version 1 * Returns a HumanTaskTemplateEntry for a given templateId * @param templateId * @returns */ getTemplateById(templateNameVersionOne: string): Promise; /** * Takes a taskId and a partial body. will update with given body * @param taskId * @param requestBody */ updateTaskOutput(taskId: string, requestBody: Record>): Promise; /** * 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>): Promise; } declare const doWhileTask: (taskRefName: string, terminationCondition: string, tasks: TaskDefTypes[]) => DoWhileTaskDef; declare const newLoopTask: (taskRefName: string, iterations: number, tasks: TaskDefTypes[]) => DoWhileTaskDef; declare const dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string) => ForkJoinDynamicDef; declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string) => EventTaskDef; declare const sqsEventTask: (taskReferenceName: string, queueName: string) => EventTaskDef; declare const conductorEventTask: (taskReferenceName: string, eventName: string) => EventTaskDef; 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 inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs") => InlineTaskDef; declare const joinTask: (taskReferenceName: string, joinOn: string[]) => JoinTaskDef; declare const jsonJqTask: (taskReferenceName: string, script: string) => JsonJQTransformTaskDef; declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters) => KafkaPublishTaskDef; declare const setVariableTask: (taskReferenceName: string, inputParameters: Record) => SetVariableTaskDef; declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record) => SimpleTaskDef; declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number | undefined) => SubWorkflowTaskDef; declare const switchTask: (taskReferenceName: string, expression: string, decisionCases?: Record, 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 waitTaskDuration: (taskReferenceName: string, duration: string) => WaitTaskDef; declare const waitTaskUntil: (taskReferenceName: string, until: string) => WaitTaskDef; declare const workflow: (name: string, tasks: TaskDefTypes[]) => WorkflowDef; /** * Takes an optional partial SimpleTaskDef * generates a task replacing default values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateSimpleTask: (overrides?: Partial) => SimpleTaskDef; /** * Takes an optional partial EventTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateEventTask: (overrides?: Partial) => EventTaskDef; declare type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef; interface WorkflowDefGen extends Omit { tasks: Partial[]; } declare type ForkJoinTaskDefGen = Omit & { forkTasks: Array>>; }; declare type SwitchTaskDefGen = Omit & { decisionCases: Record[]>; defaultCase: Partial[]; }; declare type DoWhileTaskDefGen = Omit & { loopOver: Partial[]; }; interface InlineTaskInputParametersGen extends Omit { expression: string | Function; } interface InlineTaskDefGen extends Omit { inputParameters: InlineTaskInputParametersGen; } declare type NestedTaskMapper = { (tasks: Partial[]): TaskDefTypes[]; }; declare const generateJoinTask: (overrides?: Partial) => JoinTaskDef; /** * Takes an optional partial HttpTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateHTTPTask: (overrides?: Partial) => HttpTaskDef; /** * Takes an optional partial InlineTaskDefGen * generates a task replacing default/fake values with provided overrides * * note that the inputParameters.expression can be either a string containing javascript * or a function thar returns an ES5 function * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateInlineTask: (override?: Partial) => InlineTaskDef; /** * Takes an optional partial JsonJQTransformTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateJQTransformTask: (overrides?: Partial) => JsonJQTransformTaskDef; /** * Takes an optional partial KafkaPublishTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateKafkaPublishTask: (overrides?: Partial) => KafkaPublishTaskDef; /** * Takes an optional partial SubWorkflowTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateSubWorkflowTask: (overrides?: Partial) => SubWorkflowTaskDef; /** * Takes an optional partial SetVariableTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateSetVariableTask: (overrides?: Partial) => SetVariableTaskDef; /** * Takes an optional partial TerminateTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateTerminateTask: (overrides?: Partial) => TerminateTaskDef; /** * Takes an optional partial WaitTaskDef * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generateWaitTask: (overrides?: Partial) => WaitTaskDef; declare const taskGenMapper: (tasks: Partial[]) => TaskDefTypes[]; /** * Takes an optional partial WorkflowDefGen * generates a workflow replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @returns a fully defined task */ declare const generate: (overrides: Partial) => WorkflowDef; /** * Takes an optional partial SwitchTaskDefGen and an optional nestedMapper * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @param nestedTasksMapper function to run on array of nested tasks * @returns a fully defined task */ declare const generateSwitchTask: (overrides?: Partial, nestedTasksMapper?: NestedTaskMapper) => SwitchTaskDef; /** * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @param nestedTasksMapper function to run on array of nested tasks * @returns a fully defined task */ declare const generateDoWhileTask: (overrides?: Partial, nestedTasksMapper?: NestedTaskMapper) => DoWhileTaskDef; /** * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper * generates a task replacing default/fake values with provided overrides * * @param overrides overrides for defaults * @param nestedTasksMapper function to run on array of nested tasks * @returns a fully defined task */ declare const generateForkJoinTask: (overrides?: Partial, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef; declare class SchedulerClient { readonly _client: ConductorClient; constructor(client: ConductorClient); /** * Create or update a schedule for a specified workflow with a corresponding start workflow request * @param requestBody * @returns */ saveSchedule(param: SaveScheduleRequest): Promise; /** * Searches for existing scheduler execution based on below parameters * * @param start * @param size * @param sort * @param freeText * @param query * @returns SearchResultWorkflowScheduleExecutionModel */ search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise; /** * Get an existing schedule by name * @param name * @returns SaveScheduleRequest */ getSchedule(name: string): Promise; /** * Pauses an existing schedule by name * @param name * @returns */ pauseSchedule(name: string): Promise; /** * Resume a paused schedule by name * * @param name * @returns */ resumeSchedule(name: string): Promise; /** * Deletes an existing scheduler execution by name * * @param name * @returns */ deleteSchedule(name: string): Promise; /** * Get all existing workflow schedules and optionally filter by workflow name * @param workflowName * @returns Array */ getAllSchedules(workflowName?: string): Promise>; /** * 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: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): Promise>; /** * Pause all scheduling in a single conductor server instance (for debugging only) * @returns any OK * @throws ApiError */ pauseAllSchedules(): Promise; /** * Requeue all execution records * @returns any OK * @throws ApiError */ requeueAllExecutionRecords(): Promise; /** * Resume all scheduling * @returns any OK * @throws ApiError */ resumeAllSchedules(): Promise; } declare class TaskClient { readonly _client: ConductorClient; constructor(client: ConductorClient); /** * Searches for existing scheduler execution based on below parameters * * @param start * @param size * @param sort * @param freeText * @param query * @returns SearchResultWorkflowScheduleExecutionModel */ search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise; /** * Get an existing schedule by Id * @param taskId * @returns Task */ getTask(taskId: string): Promise; /** * Update task result status * * @param workflowId * @param taskReferenceName * @param status * @param outputData * @param workerId * @returns */ updateTaskResult(workflowId: string, taskReferenceName: string, status: TaskResultStatus, outputData: Record): Promise; } declare class TemplateClient { readonly _client: ConductorClient; constructor(client: ConductorClient); /** * Register a new human task template * * @param template * @returns */ registerTemplate(template: HumanTaskTemplate, asNewVersion?: boolean): Promise; } declare class MetadataClient { readonly _client: ConductorClient; constructor(client: ConductorClient); /** * Unregisters an existing task definition by name * * @param name * @returns */ unregisterTask(name: string): Promise; /** * Registers a new task definition * * @param taskDef * @returns */ registerTask(taskDef: TaskDef): Promise; /** * Update an existing task definition * * @param taskDef * @returns */ updateTask(taskDef: TaskDef): Promise; /** * Creates or updates (overwrite: true) a workflow definition * * @param workflowDef * @param overwrite * @returns */ registerWorkflowDef(workflowDef: WorkflowDef$1, overwrite?: boolean): any; } declare type FetchFn Promise; } = Response> = (input: RequestInfo, init?: T) => Promise; declare type OrkesApiConfig = ConductorClientAPIConfig & GenerateTokenRequest; /** * Takes a config with keyId and keySecret returns a promise with an instance of ConductorClient * * @param config ConductorClientConfig with keyId and keySecret * @param requestHandler (optional) ConductorHttpRequest handler * @returns */ declare const orkesConductorClient: (config?: Partial | undefined, requestHandler?: ConductorHttpRequest) => Promise; declare class AuthConductorClient extends ConductorClient { intervalId?: NodeJS.Timeout; constructor(config?: Partial, requestHandler?: ConductorHttpRequest); /** * Stops the interval that refreshes the token */ stop(): void; } declare const baseOrkesConductorClient: Promise; } = Response>(fetchFn: FetchFn, baseRequestHandler?: ConductorHttpRequest) => (config?: Partial | undefined, requestHandler?: ConductorHttpRequest) => Promise; /** * Request method * @param config The OpenAPI configuration object * @param options The request options from the service * @returns CancelablePromise * @throws ApiError */ declare const request: (config: OpenAPIConfig, options: ApiRequestOptions, fetchFn?: FetchFn) => CancelablePromise; 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 };