@io-orkes/conductor-javascript 0.0.7

package/dist/index.d.ts

@@ -0,0 +1,2328 @@
+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 type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+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<T> implements Promise<T> {
+    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<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+declare type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+declare type Headers = Record<string, string>;
+declare type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string>;
+    USERNAME?: string | Resolver<string>;
+    PASSWORD?: string | Resolver<string>;
+    HEADERS?: Headers | Resolver<Headers>;
+    ENCODE_PATH?: (path: string) => string;
+};
+
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+
+/**
+ * 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;
+declare type ConductorHttpRequest = <T>(request: RequestType, config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+declare type TaskDef = {
+    ownerApp?: string;
+    createTime?: number;
+    updateTime?: number;
+    createdBy?: string;
+    updatedBy?: string;
+    name: string;
+    description?: string;
+    retryCount?: number;
+    timeoutSeconds: number;
+    inputKeys?: Array<string>;
+    outputKeys?: Array<string>;
+    timeoutPolicy?: 'RETRY' | 'TIME_OUT_WF' | 'ALERT_ONLY';
+    retryLogic?: 'FIXED' | 'EXPONENTIAL_BACKOFF' | 'LINEAR_BACKOFF';
+    retryDelaySeconds?: number;
+    responseTimeoutSeconds?: number;
+    concurrentExecLimit?: number;
+    inputTemplate?: Record<string, any>;
+    rateLimitPerFrequency?: number;
+    rateLimitFrequencyInSeconds?: number;
+    isolationGroupId?: string;
+    executionNameSpace?: string;
+    ownerEmail?: string;
+    pollTimeoutSeconds?: number;
+    backoffScaleFactor?: number;
+};
+
+declare type WorkflowDef$1 = {
+    ownerApp?: string;
+    createTime?: number;
+    updateTime?: number;
+    createdBy?: string;
+    updatedBy?: string;
+    name: string;
+    description?: string;
+    version?: number;
+    tasks: Array<WorkflowTask>;
+    inputParameters?: Array<string>;
+    outputParameters?: Record<string, any>;
+    failureWorkflow?: string;
+    schemaVersion?: number;
+    restartable?: boolean;
+    workflowStatusListenerEnabled?: boolean;
+    ownerEmail?: string;
+    timeoutPolicy?: 'TIME_OUT_WF' | 'ALERT_ONLY';
+    timeoutSeconds: number;
+    variables?: Record<string, any>;
+    inputTemplate?: Record<string, any>;
+};
+
+declare type SubWorkflowParams = {
+    name: string;
+    version?: number;
+    taskToDomain?: Record<string, string>;
+    workflowDefinition?: WorkflowDef$1;
+};
+
+declare type WorkflowTask = {
+    name: string;
+    taskReferenceName: string;
+    description?: string;
+    inputParameters?: Record<string, any>;
+    type?: string;
+    dynamicTaskNameParam?: string;
+    /**
+     * @deprecated
+     */
+    caseValueParam?: string;
+    /**
+     * @deprecated
+     */
+    caseExpression?: string;
+    scriptExpression?: string;
+    decisionCases?: Record<string, Array<WorkflowTask>>;
+    /**
+     * @deprecated
+     */
+    dynamicForkJoinTasksParam?: string;
+    dynamicForkTasksParam?: string;
+    dynamicForkTasksInputParamName?: string;
+    defaultCase?: Array<WorkflowTask>;
+    forkTasks?: Array<Array<WorkflowTask>>;
+    startDelay?: number;
+    subWorkflowParam?: SubWorkflowParams;
+    joinOn?: Array<string>;
+    sink?: string;
+    optional?: boolean;
+    taskDefinition?: TaskDef;
+    rateLimited?: boolean;
+    defaultExclusiveJoinTask?: Array<string>;
+    asyncComplete?: boolean;
+    loopCondition?: string;
+    loopOver?: Array<WorkflowTask>;
+    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 Task = {
+    taskType?: string;
+    status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
+    inputData?: Record<string, any>;
+    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<string, any>;
+    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 class AdminResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Verify and repair workflow consistency
+     * @param workflowId
+     * @returns string OK
+     * @throws ApiError
+     */
+    verifyAndRepairWorkflowConsistency(workflowId: string): CancelablePromise<string>;
+    /**
+     * Get details of redis usage
+     * @returns any OK
+     * @throws ApiError
+     */
+    getRedisUsage(): CancelablePromise<Record<string, any>>;
+    /**
+     * Get the list of pending tasks for a given task type
+     * @param tasktype
+     * @param start
+     * @param count
+     * @returns Task OK
+     * @throws ApiError
+     */
+    view(tasktype: string, start?: number, count?: number): CancelablePromise<Array<Task>>;
+    /**
+     * Queue up all the running workflows for sweep
+     * @param workflowId
+     * @returns string OK
+     * @throws ApiError
+     */
+    requeueSweep(workflowId: string): CancelablePromise<string>;
+    /**
+     * Get registered queues
+     * @param verbose
+     * @returns any OK
+     * @throws ApiError
+     */
+    getEventQueues(verbose?: boolean): CancelablePromise<Record<string, any>>;
+}
+
+declare type ConductorApplication = {
+    id?: string;
+    name?: string;
+    createdBy?: string;
+};
+
+declare type CreateOrUpdateApplicationRequest = {
+    /**
+     * Application's name e.g.: Payment Processors
+     */
+    name: string;
+};
+
+declare class ApplicationResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get an application by id
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    getApplication(id: string): CancelablePromise<any>;
+    /**
+     * Update an application
+     * @param id
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateApplication(id: string, requestBody: CreateOrUpdateApplicationRequest): CancelablePromise<any>;
+    /**
+     * Delete an application
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteApplication(id: string): CancelablePromise<any>;
+    /**
+     * Get application's access keys
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    getAccessKeys(id: string): CancelablePromise<any>;
+    /**
+     * Create an access key for an application
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    createAccessKey(id: string): CancelablePromise<any>;
+    /**
+     * @param applicationId
+     * @param role
+     * @returns any OK
+     * @throws ApiError
+     */
+    addRoleToApplicationUser(applicationId: string, role: string): CancelablePromise<any>;
+    /**
+     * @param applicationId
+     * @param role
+     * @returns any OK
+     * @throws ApiError
+     */
+    removeRoleFromApplicationUser(applicationId: string, role: string): CancelablePromise<any>;
+    /**
+     * Toggle the status of an access key
+     * @param applicationId
+     * @param keyId
+     * @returns any OK
+     * @throws ApiError
+     */
+    toggleAccessKeyStatus(applicationId: string, keyId: string): CancelablePromise<any>;
+    /**
+     * Get all applications
+     * @returns ConductorApplication OK
+     * @throws ApiError
+     */
+    listApplications(): CancelablePromise<Array<ConductorApplication>>;
+    /**
+     * Create an application
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    createApplication(requestBody: CreateOrUpdateApplicationRequest): CancelablePromise<any>;
+    /**
+     * Delete an access key
+     * @param applicationId
+     * @param keyId
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteAccessKey(applicationId: string, keyId: string): CancelablePromise<any>;
+}
+
+/**
+ * User, group or role which is granted/removed access
+ */
+declare type SubjectRef = {
+    /**
+     * User, role or group
+     */
+    type?: 'USER' | 'ROLE' | 'GROUP';
+    id: string;
+};
+
+/**
+ * The object over which access is being granted or removed
+ */
+declare type TargetRef = {
+    type: 'WORKFLOW_DEF' | 'TASK_DEF' | 'APPLICATION' | 'USER';
+    id: 'Identifier of the target e.g. `name` in case it\'s a WORKFLOW_DEF';
+};
+
+declare type AuthorizationRequest = {
+    subject: SubjectRef;
+    target: TargetRef;
+    /**
+     * The set of access which is granted or removed
+     */
+    access: Array<'CREATE' | 'READ' | 'UPDATE' | 'DELETE' | 'EXECUTE'>;
+};
+
+declare type Response = {};
+
+declare class AuthorizationResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Grant access to a user over the target
+     * @param requestBody
+     * @returns Response OK
+     * @throws ApiError
+     */
+    grantPermissions(requestBody: AuthorizationRequest): CancelablePromise<Response>;
+    /**
+     * Remove user's access over the target
+     * @param requestBody
+     * @returns Response OK
+     * @throws ApiError
+     */
+    removePermissions(requestBody: AuthorizationRequest): CancelablePromise<Response>;
+    /**
+     * Get the access that have been granted over the given object
+     * @param type
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    getPermissions(type: string, id: string): CancelablePromise<any>;
+}
+
+declare type StartWorkflow = {
+    name?: string;
+    version?: number;
+    correlationId?: string;
+    input?: Record<string, any>;
+    taskToDomain?: Record<string, string>;
+};
+
+declare type TaskDetails = {
+    workflowId?: string;
+    taskRefName?: string;
+    output?: Record<string, any>;
+    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<Action>;
+    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<any>;
+    /**
+     * 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<any>;
+    /**
+     * Delete queue config by name
+     * @param queueType
+     * @param queueName
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteQueueConfig(queueType: string, queueName: string): CancelablePromise<any>;
+    /**
+     * Get all the event handlers
+     * @returns EventHandler OK
+     * @throws ApiError
+     */
+    getEventHandlers(): CancelablePromise<Array<EventHandler>>;
+    /**
+     * Update an existing event handler.
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateEventHandler(requestBody: EventHandler): CancelablePromise<any>;
+    /**
+     * Add a new event handler.
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    addEventHandler(requestBody: EventHandler): CancelablePromise<any>;
+    /**
+     * Get all queue configs
+     * @returns any OK
+     * @throws ApiError
+     */
+    getQueueNames(): CancelablePromise<any>;
+    /**
+     * Remove an event handler
+     * @param name
+     * @returns any OK
+     * @throws ApiError
+     */
+    removeEventHandlerStatus(name: string): CancelablePromise<any>;
+    /**
+     * Get event handlers for a given event
+     * @param event
+     * @param activeOnly
+     * @returns EventHandler OK
+     * @throws ApiError
+     */
+    getEventHandlersForEvent(event: string, activeOnly?: boolean): CancelablePromise<Array<EventHandler>>;
+}
+
+declare type Permission = {
+    name?: string;
+};
+
+declare type Role = {
+    name?: string;
+    permissions?: Array<Permission>;
+};
+
+declare type Group = {
+    id?: string;
+    description?: string;
+    roles?: Array<Role>;
+};
+
+declare type UpsertGroupRequest = {
+    /**
+     * A general description of the group
+     */
+    description: string;
+    roles?: 'ADMIN' | 'USER' | 'WORKER' | 'METADATA_MANAGER' | 'WORKFLOW_MANAGER';
+};
+
+declare class GroupResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Add user to group
+     * @param groupId
+     * @param userId
+     * @returns any OK
+     * @throws ApiError
+     */
+    addUserToGroup(groupId: string, userId: string): CancelablePromise<any>;
+    /**
+     * Remove user from group
+     * @param groupId
+     * @param userId
+     * @returns any OK
+     * @throws ApiError
+     */
+    removeUserFromGroup(groupId: string, userId: string): CancelablePromise<any>;
+    /**
+     * Get a group by id
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    getGroup(id: string): CancelablePromise<any>;
+    /**
+     * Create or update a group
+     * @param id
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    upsertGroup(id: string, requestBody: UpsertGroupRequest): CancelablePromise<any>;
+    /**
+     * Delete a group
+     * @param id
+     * @returns Response OK
+     * @throws ApiError
+     */
+    deleteGroup(id: string): CancelablePromise<Response>;
+    /**
+     * Get the permissions this group has over workflows and tasks
+     * @param groupId
+     * @returns any OK
+     * @throws ApiError
+     */
+    getGrantedPermissions(groupId: string): CancelablePromise<any>;
+    /**
+     * Get all users in group
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    getUsersInGroup(id: string): CancelablePromise<any>;
+    /**
+     * Get all groups
+     * @returns Group OK
+     * @throws ApiError
+     */
+    listGroups(): CancelablePromise<Array<Group>>;
+}
+
+declare class HealthCheckResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * @returns any OK
+     * @throws ApiError
+     */
+    doCheck(): CancelablePromise<Record<string, any>>;
+}
+
+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<TaskDef>;
+    /**
+     * Remove a task definition
+     * @param tasktype
+     * @returns any OK
+     * @throws ApiError
+     */
+    unregisterTaskDef(tasktype: string): CancelablePromise<any>;
+    /**
+     * 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<Array<WorkflowDef$1>>;
+    /**
+     * Create or update workflow definition(s)
+     * @param requestBody
+     * @param overwrite
+     * @returns any OK
+     * @throws ApiError
+     */
+    update(requestBody: Array<WorkflowDef$1>, overwrite?: boolean): CancelablePromise<any>;
+    /**
+     * Create a new workflow definition
+     * @param requestBody
+     * @param overwrite
+     * @returns any OK
+     * @throws ApiError
+     */
+    create(requestBody: WorkflowDef$1, overwrite?: boolean): CancelablePromise<any>;
+    /**
+     * 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<Array<TaskDef>>;
+    /**
+     * Update an existing task
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateTaskDef(requestBody: TaskDef): CancelablePromise<any>;
+    /**
+     * Create or update task definition(s)
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    registerTaskDef(requestBody: Array<TaskDef>): CancelablePromise<any>;
+    /**
+     * 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<any>;
+    /**
+     * 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<WorkflowDef$1>;
+}
+
+declare class MigrationResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Migrate workflows from Redis to Postgres
+     * @param batchSize
+     * @param startFromTimestamp
+     * @returns any OK
+     * @throws ApiError
+     */
+    migrateWorkflows(batchSize: number, startFromTimestamp: number): CancelablePromise<Record<string, any>>;
+    /**
+     * Migrate Workflow Index t o the sharded table
+     * @returns number OK
+     * @throws ApiError
+     */
+    migrateIndex(): CancelablePromise<number>;
+    /**
+     * Migrate Workflow and Task Definitions to Postgres
+     * @returns any OK
+     * @throws ApiError
+     */
+    migrateMetadata(): CancelablePromise<any>;
+}
+
+declare class PublisherConfigResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get all publisher configurations
+     * @returns any OK
+     * @throws ApiError
+     */
+    listAllConfigs(): CancelablePromise<any>;
+    /**
+     * Get a publisher config value by id
+     * @param id
+     * @returns string OK
+     * @throws ApiError
+     */
+    downloadConfig(id: string): CancelablePromise<string>;
+    /**
+     * Put a publisher config value by id
+     * @param id
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    uploadConfig(id: string, requestBody: string): CancelablePromise<any>;
+    /**
+     * Delete a publisher config value by id
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteConfig(id: string): CancelablePromise<any>;
+}
+
+declare class QueueAdminResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Queue Names
+     * @returns string OK
+     * @throws ApiError
+     */
+    names(): CancelablePromise<Record<string, string>>;
+    /**
+     * Get the queue length
+     * @returns number OK
+     * @throws ApiError
+     */
+    size(): CancelablePromise<Record<string, number>>;
+    /**
+     * Publish a message in queue to mark a wait task (by taskId) as completed.
+     * @param workflowId
+     * @param taskId
+     * @param status
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    updateByTaskId(workflowId: string, taskId: string, status: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED', requestBody: Record<string, any>): CancelablePromise<any>;
+    /**
+     * Publish a message in queue to mark a wait task as completed.
+     * @param workflowId
+     * @param taskRefName
+     * @param status
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    update1(workflowId: string, taskRefName: string, status: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED', requestBody: Record<string, any>): CancelablePromise<any>;
+}
+
+declare type StartWorkflowRequest$1 = {
+    name: string;
+    version?: number;
+    correlationId?: string;
+    input?: Record<string, any>;
+    taskToDomain?: Record<string, string>;
+    workflowDef?: WorkflowDef$1;
+    externalInputPayloadStoragePath?: string;
+    priority?: number;
+    createdBy?: string;
+};
+
+declare type SaveScheduleRequest = {
+    name: string;
+    cronExpression: string;
+    runCatchupScheduleInstances?: boolean;
+    paused?: boolean;
+    startWorkflowRequest?: StartWorkflowRequest$1;
+    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$1;
+    state?: 'POLLED' | 'FAILED' | 'EXECUTED';
+};
+
+declare type SearchResultWorkflowScheduleExecutionModel = {
+    totalHits?: number;
+    results?: Array<WorkflowScheduleExecutionModel>;
+};
+
+declare type WorkflowSchedule = {
+    name?: string;
+    cronExpression?: string;
+    runCatchupScheduleInstances?: boolean;
+    paused?: boolean;
+    startWorkflowRequest?: StartWorkflowRequest$1;
+    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<any>;
+    /**
+     * Deletes an existing workflow schedule by name
+     * @param name
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteSchedule(name: string): CancelablePromise<any>;
+    /**
+     * 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<Array<number>>;
+    /**
+     * Pauses an existing schedule by name
+     * @param name
+     * @returns any OK
+     * @throws ApiError
+     */
+    pauseSchedule(name: string): CancelablePromise<any>;
+    /**
+     * Pause all scheduling in a single conductor server instance (for debugging only)
+     * @returns any OK
+     * @throws ApiError
+     */
+    pauseAllSchedules(): CancelablePromise<Record<string, any>>;
+    /**
+     * Resume a paused schedule by name
+     * @param name
+     * @returns any OK
+     * @throws ApiError
+     */
+    resumeSchedule(name: string): CancelablePromise<any>;
+    /**
+     * Requeue all execution records
+     * @returns any OK
+     * @throws ApiError
+     */
+    requeueAllExecutionRecords(): CancelablePromise<Record<string, any>>;
+    /**
+     * Resume all scheduling
+     * @returns any OK
+     * @throws ApiError
+     */
+    resumeAllSchedules(): CancelablePromise<Record<string, any>>;
+    /**
+     * Get all existing workflow schedules and optionally filter by workflow name
+     * @param workflowName
+     * @returns WorkflowSchedule OK
+     * @throws ApiError
+     */
+    getAllSchedules(workflowName?: string): CancelablePromise<Array<WorkflowSchedule>>;
+    /**
+     * 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<any>;
+    /**
+     * Test timeout - do not use in production
+     * @returns any OK
+     * @throws ApiError
+     */
+    testTimeout(): CancelablePromise<any>;
+    /**
+     * Search for workflows based on payload and other parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultWorkflowScheduleExecutionModel OK
+     * @throws ApiError
+     */
+    searchV21(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflowScheduleExecutionModel>;
+}
+
+declare class SecretResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get secret value by key
+     * @param key
+     * @returns any OK
+     * @throws ApiError
+     */
+    getSecret(key: string): CancelablePromise<any>;
+    /**
+     * Put a secret value by key
+     * @param key
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    putSecret(key: string, requestBody: string): CancelablePromise<any>;
+    /**
+     * Delete a secret value by key
+     * @param key
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteSecret(key: string): CancelablePromise<any>;
+    /**
+     * List all secret names user can grant access to
+     * @returns string OK
+     * @throws ApiError
+     */
+    listSecretsThatUserCanGrantAccessTo(): CancelablePromise<Array<string>>;
+    /**
+     * List all secret names
+     * @returns any OK
+     * @throws ApiError
+     */
+    listAllSecretNames(): CancelablePromise<any>;
+    /**
+     * Check if secret exists
+     * @param key
+     * @returns any OK
+     * @throws ApiError
+     */
+    secretExists(key: string): CancelablePromise<any>;
+}
+
+declare type TagObject = {
+    type?: 'METADATA' | 'RATE_LIMIT';
+    key?: string;
+    value?: any;
+};
+
+declare type TagString = {
+    type?: 'METADATA' | 'RATE_LIMIT';
+    key?: string;
+    value?: string;
+};
+
+declare class TagsExperimentalService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Returns all the tags of the workflow
+     * @param name
+     * @returns TagObject OK
+     * @throws ApiError
+     */
+    getWorkflowTags(name: string): CancelablePromise<Array<TagObject>>;
+    /**
+     * Set the tags of the workflow
+     * @param name
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    setWorkflowTags(name: string, requestBody: Array<TagObject>): CancelablePromise<any>;
+    /**
+     * Adds the tag to the workflow
+     * @param name
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    addWorkflowTag(name: string, requestBody: TagObject): CancelablePromise<any>;
+    /**
+     * Removes the tag of the workflow
+     * @param name
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteWorkflowTag(name: string, requestBody: TagObject): CancelablePromise<any>;
+    /**
+     * Returns all the tags of the task
+     * @param taskName
+     * @returns TagObject OK
+     * @throws ApiError
+     */
+    getTaskTags(taskName: string): CancelablePromise<Array<TagObject>>;
+    /**
+     * Adds the tag to the task
+     * @param taskName
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    setTaskTags(taskName: string, requestBody: Array<TagObject>): CancelablePromise<any>;
+    /**
+     * Adds the tag to the task
+     * @param taskName
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    addTaskTag(taskName: string, requestBody: TagObject): CancelablePromise<any>;
+    /**
+     * Removes the tag of the task
+     * @param taskName
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    deleteTaskTag(taskName: string, requestBody: TagString): CancelablePromise<any>;
+}
+
+declare type ExternalStorageLocation = {
+    uri?: string;
+    path?: string;
+};
+
+declare type PollData = {
+    queueName?: string;
+    domain?: string;
+    workerId?: string;
+    lastPollTime?: number;
+};
+
+declare type SearchResultTask = {
+    totalHits?: number;
+    results?: Array<Task>;
+};
+
+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<TaskSummary>;
+};
+
+declare type TaskExecLog = {
+    log?: string;
+    taskId?: string;
+    createdTime?: number;
+};
+
+declare type TaskResult$1 = {
+    workflowInstanceId: string;
+    taskId: string;
+    reasonForIncompletion?: string;
+    callbackAfterSeconds?: number;
+    workerId?: string;
+    status?: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED';
+    outputData?: Record<string, any>;
+    logs?: Array<TaskExecLog>;
+    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<Task>;
+    /**
+     * Get the details about each queue
+     * @returns number OK
+     * @throws ApiError
+     */
+    allVerbose(): CancelablePromise<Record<string, Record<string, Record<string, number>>>>;
+    /**
+     * 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<string, any>): CancelablePromise<string>;
+    /**
+     * Get task by Id
+     * @param taskId
+     * @returns Task OK
+     * @throws ApiError
+     */
+    getTask(taskId: string): CancelablePromise<Task>;
+    /**
+     * Get the details about each queue
+     * @returns number OK
+     * @throws ApiError
+     */
+    all(): CancelablePromise<Record<string, number>>;
+    /**
+     * Requeue pending tasks
+     * @param taskType
+     * @returns string OK
+     * @throws ApiError
+     */
+    requeuePendingTask(taskType: string): CancelablePromise<string>;
+    /**
+     * Search for tasks based in payload and other parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultTaskSummary OK
+     * @throws ApiError
+     */
+    search(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultTaskSummary>;
+    /**
+     * Search for tasks based in payload and other parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultTask OK
+     * @throws ApiError
+     */
+    searchV22(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultTask>;
+    /**
+     * Get the last poll data for a given task type
+     * @param taskType
+     * @returns PollData OK
+     * @throws ApiError
+     */
+    getPollData(taskType: string): CancelablePromise<Array<PollData>>;
+    /**
+     * Get Task Execution Logs
+     * @param taskId
+     * @returns TaskExecLog OK
+     * @throws ApiError
+     */
+    getTaskLogs(taskId: string): CancelablePromise<Array<TaskExecLog>>;
+    /**
+     * Log Task Execution Details
+     * @param taskId
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    log(taskId: string, requestBody: string): CancelablePromise<any>;
+    /**
+     * Get the last poll data for all task types
+     * @returns PollData OK
+     * @throws ApiError
+     */
+    getAllPollData(): CancelablePromise<Array<PollData>>;
+    /**
+     * 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<Array<Task>>;
+    /**
+     * Update a task
+     * @param requestBody
+     * @returns string OK
+     * @throws ApiError
+     */
+    updateTask1(requestBody: TaskResult$1): CancelablePromise<string>;
+    /**
+     * Get Task type queue sizes
+     * @param taskType
+     * @returns number OK
+     * @throws ApiError
+     */
+    size1(taskType?: Array<string>): CancelablePromise<Record<string, number>>;
+    /**
+     * 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<ExternalStorageLocation>;
+}
+
+declare type GenerateTokenRequest = {
+    keyId: string;
+    keySecret: string;
+};
+
+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<Response>;
+    /**
+     * Get the user info from the token
+     * @returns any OK
+     * @throws ApiError
+     */
+    getUserInfo(): CancelablePromise<any>;
+}
+
+declare type ConductorUser = {
+    id?: string;
+    name?: string;
+    roles?: Array<Role>;
+    groups?: Array<Group>;
+    uuid?: string;
+    applicationUser?: boolean;
+};
+
+declare type UpsertUserRequest = {
+    /**
+     * User's full name
+     */
+    name: string;
+    roles?: 'ADMIN' | 'USER' | 'WORKER' | 'METADATA_MANAGER' | 'WORKFLOW_MANAGER';
+    /**
+     * Ids of the groups this user belongs to
+     */
+    groups?: Array<string>;
+};
+
+declare class UserResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get a user by id
+     * @param id
+     * @returns any OK
+     * @throws ApiError
+     */
+    getUser(id: string): CancelablePromise<any>;
+    /**
+     * Create or update a user
+     * @param id
+     * @param requestBody
+     * @returns any OK
+     * @throws ApiError
+     */
+    upsertUser(id: string, requestBody: UpsertUserRequest): CancelablePromise<any>;
+    /**
+     * Delete a user
+     * @param id
+     * @returns Response OK
+     * @throws ApiError
+     */
+    deleteUser(id: string): CancelablePromise<Response>;
+    /**
+     * Get all users
+     * @param apps
+     * @returns ConductorUser OK
+     * @throws ApiError
+     */
+    listUsers(apps?: boolean): CancelablePromise<Array<ConductorUser>>;
+    /**
+     * Get the permissions this user has over workflows and tasks
+     * @param userId
+     * @returns any OK
+     * @throws ApiError
+     */
+    getGrantedPermissions1(userId: string): CancelablePromise<any>;
+}
+
+declare class VersionResourceService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get the server's version
+     * @returns string OK
+     * @throws ApiError
+     */
+    getVersion(): CancelablePromise<string>;
+}
+
+declare type BulkResponse = {
+    bulkErrorResults?: Record<string, string>;
+    bulkSuccessfulResults?: Array<string>;
+};
+
+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<string>): CancelablePromise<BulkResponse>;
+    /**
+     * Restart the list of completed workflow
+     * @param requestBody
+     * @param useLatestDefinitions
+     * @returns BulkResponse OK
+     * @throws ApiError
+     */
+    restart(requestBody: Array<string>, useLatestDefinitions?: boolean): CancelablePromise<BulkResponse>;
+    /**
+     * Terminate workflows execution
+     * @param requestBody
+     * @param reason
+     * @returns BulkResponse OK
+     * @throws ApiError
+     */
+    terminate(requestBody: Array<string>, reason?: string): CancelablePromise<BulkResponse>;
+    /**
+     * Resume the list of workflows
+     * @param requestBody
+     * @returns BulkResponse OK
+     * @throws ApiError
+     */
+    resumeWorkflow(requestBody: Array<string>): CancelablePromise<BulkResponse>;
+    /**
+     * Pause the list of workflows
+     * @param requestBody
+     * @returns BulkResponse OK
+     * @throws ApiError
+     */
+    pauseWorkflow1(requestBody: Array<string>): CancelablePromise<BulkResponse>;
+}
+
+declare type RerunWorkflowRequest$1 = {
+    reRunFromWorkflowId?: string;
+    workflowInput?: Record<string, any>;
+    reRunFromTaskId?: string;
+    taskInput?: Record<string, any>;
+    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<WorkflowSummary>;
+    queryId?: string;
+};
+
+declare type Workflow = {
+    ownerApp?: string;
+    createTime?: number;
+    updateTime?: number;
+    createdBy?: string;
+    updatedBy?: string;
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    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 = {
+    totalHits?: number;
+    results?: Array<Workflow>;
+};
+
+declare type SearchResultWorkflowSummary = {
+    totalHits?: number;
+    results?: Array<WorkflowSummary>;
+};
+
+declare type SkipTaskRequest$1 = {
+    taskInput?: Record<string, any>;
+    taskOutput?: Record<string, any>;
+};
+
+declare type WorkflowStatus = {
+    workflowId?: string;
+    correlationId?: string;
+    output?: Record<string, any>;
+    variables?: Record<string, any>;
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+};
+
+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<Array<string>>;
+    /**
+     * 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$1): CancelablePromise<string>;
+    /**
+     * Starts the decision task for a workflow
+     * @param workflowId
+     * @returns any OK
+     * @throws ApiError
+     */
+    decide(workflowId: string): CancelablePromise<any>;
+    /**
+     * Reruns the workflow from a specific task
+     * @param workflowId
+     * @param requestBody
+     * @returns string OK
+     * @throws ApiError
+     */
+    rerun(workflowId: string, requestBody: RerunWorkflowRequest$1): CancelablePromise<string>;
+    /**
+     * Search for workflows based on payload and other parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultWorkflow OK
+     * @throws ApiError
+     */
+    searchV21(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflow>;
+    /**
+     * Pauses the workflow
+     * @param workflowId
+     * @returns any OK
+     * @throws ApiError
+     */
+    pauseWorkflow(workflowId: string): CancelablePromise<any>;
+    /**
+     * 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$1): CancelablePromise<any>;
+    /**
+     * 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<string>, includeClosed?: boolean, includeTasks?: boolean): CancelablePromise<Record<string, Array<Workflow>>>;
+    /**
+     * 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<WorkflowStatus>;
+    /**
+     * 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<Array<Workflow>>;
+    /**
+     * Retries the last failed task
+     * @param workflowId
+     * @param resumeSubworkflowTasks
+     * @returns void
+     * @throws ApiError
+     */
+    retry1(workflowId: string, resumeSubworkflowTasks?: boolean): CancelablePromise<void>;
+    /**
+     * Gets the workflow by workflow id
+     * @param workflowId
+     * @param includeTasks
+     * @returns Workflow OK
+     * @throws ApiError
+     */
+    getExecutionStatus(workflowId: string, includeTasks?: boolean): CancelablePromise<Workflow>;
+    /**
+     * Terminate workflow execution
+     * @param workflowId
+     * @param reason
+     * @returns any OK
+     * @throws ApiError
+     */
+    terminate1(workflowId: string, reason?: string): CancelablePromise<any>;
+    /**
+     * Resumes the workflow
+     * @param workflowId
+     * @returns any OK
+     * @throws ApiError
+     */
+    resumeWorkflow(workflowId: string): CancelablePromise<any>;
+    /**
+     * Removes the workflow from the system
+     * @param workflowId
+     * @param archiveWorkflow
+     * @returns any OK
+     * @throws ApiError
+     */
+    delete(workflowId: string, archiveWorkflow?: boolean): CancelablePromise<any>;
+    /**
+     * Search for workflows based on task parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultWorkflowSummary OK
+     * @throws ApiError
+     */
+    searchWorkflowsByTasks(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflowSummary>;
+    /**
+     * 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<ExternalStorageLocation>;
+    /**
+     * 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<string, any>, version?: number, correlationId?: string, priority?: number): CancelablePromise<string>;
+    /**
+     * Restarts a completed workflow
+     * @param workflowId
+     * @param useLatestDefinitions
+     * @returns void
+     * @throws ApiError
+     */
+    restart1(workflowId: string, useLatestDefinitions?: boolean): CancelablePromise<void>;
+    /**
+     * Search for workflows based on payload and other parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
+     * @param queryId
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @param skipCache
+     * @returns ScrollableSearchResultWorkflowSummary OK
+     * @throws ApiError
+     */
+    search1(queryId?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean): CancelablePromise<ScrollableSearchResultWorkflowSummary>;
+    /**
+     * Search for workflows based on task parameters
+     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultWorkflow OK
+     * @throws ApiError
+     */
+    searchWorkflowsByTasksV2(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflow>;
+    /**
+     * Resets callback times of all non-terminal SIMPLE tasks to 0
+     * @param workflowId
+     * @returns void
+     * @throws ApiError
+     */
+    resetWorkflow(workflowId: string): CancelablePromise<void>;
+}
+
+interface ConductorClientAPIConfig extends Omit<OpenAPIConfig, "BASE"> {
+    serverUrl: string;
+}
+declare class ConductorClient {
+    readonly adminResource: AdminResourceService;
+    readonly applicationResource: ApplicationResourceService;
+    readonly authorizationResource: AuthorizationResourceService;
+    readonly eventResource: EventResourceService;
+    readonly groupResource: GroupResourceService;
+    readonly healthCheckResource: HealthCheckResourceService;
+    readonly metadataResource: MetadataResourceService;
+    readonly migrationResource: MigrationResourceService;
+    readonly publisherConfigResource: PublisherConfigResourceService;
+    readonly queueAdminResource: QueueAdminResourceService;
+    readonly schedulerResource: SchedulerResourceService;
+    readonly secretResource: SecretResourceService;
+    readonly tagsExperimental: TagsExperimentalService;
+    readonly taskResource: TaskResourceService;
+    readonly tokenResource: TokenResourceService;
+    readonly userResource: UserResourceService;
+    readonly versionResource: VersionResourceService;
+    readonly workflowBulkResource: WorkflowBulkResourceService;
+    readonly workflowResource: WorkflowResourceService;
+    readonly request: BaseHttpRequest;
+    constructor(config?: Partial<ConductorClientAPIConfig>, requestHandler?: ConductorHttpRequest);
+}
+
+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<OrkesApiConfig> | undefined, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
+
+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, string>;
+    type: TaskType.DO_WHILE;
+    decisionCases: Record<string, TaskDefTypes[]>;
+    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: string;
+        dynamicTasksInput: string;
+    };
+    type: TaskType.FORK_JOIN_DYNAMIC;
+    dynamicForkTasksParam: string;
+    dynamicForkTasksInputParamName: string;
+    startDelay: number;
+    optional: boolean;
+    asyncComplete: boolean;
+}
+interface HttpTaskDef extends CommonTaskDef {
+    inputParameters: {
+        [x: string]: unknown;
+        http_request: {
+            uri: string;
+            method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
+            accept?: string;
+            contentType?: string;
+            headers?: Record<string, string>;
+            body?: unknown;
+            connectionTimeOut?: number;
+            readTimeOut?: string;
+        };
+    };
+    type: TaskType.HTTP;
+}
+interface InlineTaskInputParameters {
+    evaluatorType: "javascript";
+    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 KafkaPublishTaskDef extends CommonTaskDef {
+    inputParameters: {
+        kafka_request: {
+            topic: string;
+            value: string;
+            bootStrapServers: string;
+            headers: Record<string, string>;
+            key: string;
+            keySerializer: string;
+        };
+    };
+    type: TaskType.KAFKA_PUBLISH;
+}
+interface SetVariableTaskDef extends CommonTaskDef {
+    type: TaskType.SET_VARIABLE;
+    inputParameters: Record<string, string>;
+}
+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>;
+    };
+    type: TaskType.TERMINATE;
+    startDelay: number;
+    optional: boolean;
+}
+interface WaitTaskDef extends CommonTaskDef {
+    type: TaskType.WAIT;
+}
+declare type U2O<U extends string> = {
+    [key in U]: U2O<Exclude<U, key>>;
+};
+declare type O2T<O extends {}> = {} extends O ? [] : {
+    [key in keyof O]: [key, ...O2T<O[key]>];
+}[keyof O];
+declare type WorkflowInputParameters<T extends string> = O2T<U2O<T>>;
+interface WorkflowDef extends Omit<WorkflowDef$1, "tasks" | "version" | "inputParameters"> {
+    inputParameters: string[];
+    version: number;
+    tasks: TaskDefTypes[];
+}
+
+/**
+ * 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>) => 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>) => EventTaskDef;
+
+declare 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"> & {
+    forkTasks: Array<Array<Partial<TaskDefTypesGen>>>;
+};
+declare type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
+    decisionCases: Record<string, Partial<TaskDefTypesGen>[]>;
+    defaultCase: Partial<TaskDefTypesGen>[];
+};
+declare type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
+    loopOver: Partial<TaskDefTypesGen>[];
+};
+interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "expression"> {
+    expression: string | Function;
+}
+interface InlineTaskDefGen extends Omit<InlineTaskDef, "inputParameters"> {
+    inputParameters: InlineTaskInputParametersGen;
+}
+declare type NestedTaskMapper = {
+    (tasks: Partial<TaskDefTypesGen>[]): TaskDefTypes[];
+};
+
+declare const generateJoinTask: (overrides?: Partial<JoinTaskDef>) => 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>) => HttpTaskDef;
+
+/**
+ * Takes an optional partial InlineTaskDefGen
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * <b>note</b> 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<InlineTaskDefGen>) => 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>) => 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>) => 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>) => 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>) => 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>) => 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>) => WaitTaskDef;
+
+declare const taskGenMapper: (tasks: Partial<TaskDefTypesGen>[]) => 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<WorkflowDefGen>) => 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<SwitchTaskDefGen>, 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<DoWhileTaskDefGen>, 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<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
+
+/**
+ * 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<Omit<TaskResult$1, "workflowInstanceId" | "taskId">>;
+    domain?: string;
+    concurrency?: number;
+}
+
+interface TaskManagerOptions {
+    workerID: string;
+    domain: string | undefined;
+    pollInterval?: number;
+    concurrency?: number;
+}
+interface TaskManagerConfig {
+    logger?: ConductorLogger;
+    options?: Partial<TaskManagerOptions>;
+}
+/**
+ * Responsible for initializing and managing the runners that poll and work different task queues.
+ */
+declare class TaskManager {
+    private tasks;
+    private readonly client;
+    private readonly logger;
+    private workers;
+    private readonly taskManageOptions;
+    constructor(client: ConductorClient, workers: Array<ConductorWorker>, config?: TaskManagerConfig);
+    startPolling: () => void;
+    stopPolling: () => void;
+}
+
+interface RunnerArgs {
+    worker: ConductorWorker;
+    taskResource: TaskResourceService;
+    options: Required<TaskManagerOptions>;
+    logger?: ConductorLogger;
+}
+/**
+ * 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 {
+    isPolling: boolean;
+    taskResource: TaskResourceService;
+    worker: ConductorWorker;
+    logger: ConductorLogger;
+    options: Required<TaskManagerOptions>;
+    constructor({ worker, taskResource, options, logger, }: RunnerArgs);
+    startPolling: () => Promise<void>;
+    stopPolling: () => void;
+    poll: () => Promise<void>;
+    executeTask: (task: Task) => Promise<void>;
+    handleUnknownError: (unknownError: unknown) => void;
+}
+
+interface StartWorkflowRequest<I = Record<string, any>> {
+    name: string;
+    version: number;
+    correlationId?: string;
+    input?: I;
+    taskToDomain?: Record<string, string>;
+    workflowDef?: WorkflowDef;
+    externalInputPayloadStoragePath?: string;
+    priority?: number;
+}
+interface RerunWorkflowRequest<I = Record<string, any>> {
+    workflowInput: I;
+    rerunFromTaskId?: string;
+    taskInput: Record<string, any>;
+    correlationId: string;
+}
+interface SkipTaskRequest {
+    taskInput: Record<string, any>;
+    taskOutput: Record<string, any>;
+}
+declare class ConductorError extends Error {
+    private _trace;
+    private __proto__;
+    constructor(message?: string, innerError?: Error);
+}
+declare enum TaskResult {
+    IN_PROGRESS = "IN_PROGRESS",
+    FAILED = "FAILED",
+    FAILED_WITH_TERMINAL_ERROR = "FAILED_WITH_TERMINAL_ERROR",
+    COMPLETED = "COMPLETED"
+}
+
+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): any;
+    /**
+     * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
+     * @param workflowRequest
+     * @returns
+     */
+    startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
+    startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise<string>[];
+    /**
+     * 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<Workflow>;
+    /**
+     *  Returns a summary of the current workflow status.
+     *
+     * @param workflowInstanceId current running workflow
+     * @param includeOutput flag to include output
+     * @param includeVariables flag to include variable
+     * @returns Promise<WorkflowStatus>
+     */
+    getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): any;
+    /**
+     * Pauses a running workflow
+     * @param workflowInstanceId current workflow execution
+     * @returns
+     */
+    pause(workflowInstanceId: string): any;
+    /**
+     * Reruns workflowInstanceId workflow. with new parameters
+     *
+     * @param workflowInstanceId current workflow execution
+     * @param rerunWorkflowRequest Rerun Workflow Execution Request
+     * @returns
+     */
+    reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial<RerunWorkflowRequest>): any;
+    /**
+     * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
+     * @param workflowInstanceId
+     * @param useLatestDefinitions
+     * @returns
+     */
+    restart(workflowInstanceId: string, useLatestDefinitions: boolean): any;
+    /**
+     * Resumes a previously paused execution
+     *
+     * @param workflowInstanceId Running workflow workflowInstanceId
+     * @returns
+     */
+    resume(workflowInstanceId: string): any;
+    /**
+     * 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): any;
+    /**
+     * 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): any;
+    /**
+     * 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<SkipTaskRequest>): any;
+    /**
+     * Takes an workflowInstanceId, and terminates a running workflow
+     * @param workflowInstanceId
+     * @param reason
+     * @returns
+     */
+    terminate(workflowInstanceId: string, reason: string): any;
+    /**
+     * 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: TaskResult, taskOutput: Record<string, any>): any;
+    /**
+     * Updates a task by reference Name
+     * @param taskReferenceName
+     * @param workflowInstanceId
+     * @param status
+     * @param taskOutput
+     * @returns
+     */
+    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResult, taskOutput: Record<string, any>): any;
+}
+
+export { CancelError, CancelablePromise, CommonTaskDef, ConductorClient, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, EventTaskDef, ForkJoinDynamicDef, ForkJoinTaskDef, HttpTaskDef, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishTaskDef, OnCancel, OpenAPIConfig, OrkesApiConfig, RequestType, RerunWorkflowRequest, RunnerArgs, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflowRequest, SubWorkflowTaskDef, SwitchTaskDef, TaskDefTypes, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResult, TaskRunner, TaskType, TerminateTaskDef, WaitTaskDef, WorkflowDef, WorkflowExecutor, WorkflowInputParameters, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, orkesConductorClient, taskGenMapper };