@io-orkes/conductor-javascript 2.2.0 → 2.3.0

package/README.md

@@ -62,6 +62,14 @@ Show support for the Conductor OSS.  Please help spread the awareness by starrin
     - [Step 1: Create a MetadataClient](#step-1-create-a-metadataclient)
     - [Step 2: Define and Register a Task](#step-2-define-and-register-a-task)
     - [Step 3: Define and Register a Workflow](#step-3-define-and-register-a-workflow)
+- [Events](#events)
+  - [The EventClient](#the-eventclient)
+  - [Quick Start: Using Event Handlers](#quick-start-using-event-handlers)
+    - [Step 1: Create an EventClient](#step-1-create-an-eventclient)
+    - [Step 2: Register an Event Handler](#step-2-register-an-event-handler)
+    - [Step 3: Publish Events](#step-3-publish-events)
+    - [Step 4: Monitor Event Processing](#step-4-monitor-event-processing)
+    - [Step 5: Manage Event Handlers](#step-5-manage-event-handlers)
 - [Human Tasks](#human-tasks)
   - [The HumanExecutor and TemplateClient](#the-humanexecutor-and-templateclient)
   - [Quick Start: Creating and Managing a Human Task](#quick-start-creating-and-managing-a-human-task)
@@ -716,6 +724,110 @@ await metadataClient.registerWorkflowDef(wf);
 
 For a complete method reference, see the [MetadataClient API Reference](docs/api-reference/metadata-client.md).
 
+## Events
+
+Event handlers in Conductor allow you to automatically trigger actions (like starting workflows) when events are received. This enables event-driven workflows and integrations with external systems.
+
+### The EventClient
+
+The `EventClient` manages event handlers and event processing. For a complete method reference, see the [EventClient API Reference](docs/api-reference/event-client.md).
+
+### Quick Start: Using Event Handlers
+
+Here's how to set up event-driven workflows:
+
+#### Step 1: Create an EventClient
+
+First, create an instance of the `EventClient`:
+
+```typescript
+import { EventClient } from "@io-orkes/conductor-javascript";
+
+const eventClient = new EventClient(client);
+```
+
+#### Step 2: Register an Event Handler
+
+Create an event handler that defines what action to take when an event is received. In this example, we'll start a workflow when an order is created:
+
+```typescript
+await eventClient.addEventHandler({
+  name: "order_created_handler",
+  event: "order.created",
+  active: true,
+  description: "Starts fulfillment workflow when order is created",
+  actions: [
+    {
+      action: "start_workflow",
+      start_workflow: {
+        name: "fulfill_order",
+        version: 1,
+        input: {
+          orderId: "${event.orderId}",
+          customerId: "${event.customerId}",
+        },
+      },
+    },
+  ],
+});
+```
+
+#### Step 3: Publish Events
+
+When an event occurs, publish it to Conductor. All active handlers registered for that event will be triggered:
+
+```typescript
+await eventClient.handleIncomingEvent({
+  event: "order.created",
+  orderId: "ORDER-123",
+  customerId: "CUST-456",
+  amount: "99.99",
+  timestamp: Date.now().toString(),
+});
+```
+
+#### Step 4: Monitor Event Processing
+
+You can monitor event handlers and their execution history:
+
+```typescript
+// Get all handlers for a specific event
+const handlers = await eventClient.getEventHandlersForEvent("order.created");
+
+// Get execution history for a handler
+const executions = await eventClient.getEventExecutions("order_created_handler");
+
+// Get event messages
+const messages = await eventClient.getEventMessages("order.created");
+```
+
+#### Step 5: Manage Event Handlers
+
+Update, deactivate, or remove event handlers as needed:
+
+```typescript
+// Update a handler
+await eventClient.updateEventHandler({
+  name: "order_created_handler",
+  active: false, // Deactivate
+  // ... other fields
+});
+
+// Remove a handler
+await eventClient.removeEventHandler("order_created_handler");
+```
+
+**Event Handler Actions:**
+
+Event handlers support various actions:
+- `start_workflow` - Start a workflow execution
+- `complete_task` - Complete a specific task
+- `fail_task` - Fail a specific task
+- `terminate_workflow` - Terminate a workflow
+- `update_workflow_variables` - Update workflow variables
+
+For a complete method reference, see the [EventClient API Reference](docs/api-reference/event-client.md).
+
 ## Human Tasks
 
 Human tasks integrate human interaction into your automated workflows. They pause a workflow until a person provides input, such as an approval, a correction, or additional information.

package/dist/index.d.mts

@@ -48,6 +48,14 @@ type Any = {
     unknownFields?: UnknownFieldSet;
     value?: ByteString;
 };
+type BulkResponse = {
+    bulkErrorResults?: {
+        [key: string]: string;
+    };
+    bulkSuccessfulResults?: Array<{
+        [key: string]: unknown;
+    }>;
+};
 type ByteString = {
     empty?: boolean;
     validUtf8?: boolean;
@@ -66,6 +74,17 @@ type CircuitBreakerTransitionResponse = {
 type Config$2 = {
     circuitBreakerConfig?: OrkesCircuitBreakerConfig;
 };
+type ConnectivityTestInput = {
+    input?: {
+        [key: string]: unknown;
+    };
+    sink: string;
+};
+type ConnectivityTestResult = {
+    reason?: string;
+    successful?: boolean;
+    workflowId?: string;
+};
 type Declaration = {
     allFields?: {
         [key: string]: unknown;
@@ -444,6 +463,41 @@ type EventHandler = {
     orgId?: string;
     tags?: Array<Tag>;
 };
+type EventMessage = {
+    createdAt?: number;
+    eventExecutions?: Array<ExtendedEventExecution>;
+    eventTarget?: string;
+    eventType?: 'WEBHOOK' | 'MESSAGE';
+    fullPayload?: {
+        [key: string]: unknown;
+    };
+    id?: string;
+    orgId?: string;
+    payload?: string;
+    status?: 'RECEIVED' | 'HANDLED' | 'REJECTED';
+    statusDescription?: string;
+};
+type ExtendedEventExecution = {
+    action?: 'start_workflow' | 'complete_task' | 'fail_task' | 'terminate_workflow' | 'update_workflow_variables';
+    created?: number;
+    event?: string;
+    eventHandler?: EventHandler;
+    fullMessagePayload?: {
+        [key: string]: unknown;
+    };
+    id?: string;
+    messageId?: string;
+    name?: string;
+    orgId?: string;
+    output?: {
+        [key: string]: unknown;
+    };
+    payload?: {
+        [key: string]: unknown;
+    };
+    status?: 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'SKIPPED';
+    statusDescription?: string;
+};
 type ExtendedTaskDef$1 = {
     backoffScaleFactor?: number;
     baseType?: string;
@@ -945,6 +999,13 @@ type GenerateTokenRequest = {
     keyId: string;
     keySecret: string;
 };
+type HandledEventResponse = {
+    active?: boolean;
+    event?: string;
+    name?: string;
+    numberOfActions?: number;
+    numberOfMessages?: number;
+};
 type HumanTaskAssignment = {
     assignee?: HumanTaskUser;
     slaMinutes?: number;
@@ -1545,6 +1606,10 @@ type ScrollableSearchResultWorkflowSummary = {
     results?: Array<WorkflowSummary>;
     totalHits?: number;
 };
+type SearchResultHandledEventResponse = {
+    results?: Array<HandledEventResponse>;
+    totalHits?: number;
+};
 type SearchResultTaskSummary = {
     results?: Array<TaskSummary>;
     totalHits?: number;
@@ -3600,6 +3665,172 @@ declare class MetadataClient {
     unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
 }
 
+declare class EventClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Get all the event handlers
+     * @returns {Promise<EventHandler[]>}
+     * @throws {ConductorSdkError}
+     */
+    getAllEventHandlers(): Promise<EventHandler[]>;
+    /**
+     * Add event handlers
+     * @param {EventHandler[]} eventHandlers
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    addEventHandlers(eventHandlers: EventHandler[]): Promise<void>;
+    /**
+     * Add an event handler
+     * @param {EventHandler} eventHandler
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    addEventHandler(eventHandler: EventHandler): Promise<void>;
+    /**
+     * Update an event handler
+     * @param {EventHandler} eventHandler
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    updateEventHandler(eventHandler: EventHandler): Promise<void>;
+    /**
+     * Handle an incoming event
+     * @param {Record<string, string>} data
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    handleIncomingEvent(data: Record<string, string>): Promise<void>;
+    /**
+     * Get an event handler by name
+     * @param {string} eventHandlerName
+     * @returns {Promise<EventHandler>}
+     * @throws {ConductorSdkError}
+     */
+    getEventHandlerByName(eventHandlerName: string): Promise<EventHandler>;
+    /**
+     * Get all queue configs
+     * @returns {Promise<Record<string, string>>}
+     * @throws {ConductorSdkError}
+     */
+    getAllQueueConfigs(): Promise<Record<string, string>>;
+    /**
+     * Delete queue config
+     * @param {string} queueType
+     * @param {string} queueName
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    deleteQueueConfig(queueType: string, queueName: string): Promise<void>;
+    /**
+     * Get queue config
+     * @param {string} queueType
+     * @param {string} queueName
+     * @returns {Promise<Record<string, unknown>>}
+     * @throws {ConductorSdkError}
+     */
+    getQueueConfig(queueType: string, queueName: string): Promise<Record<string, unknown>>;
+    /**
+     * Get event handlers for a given event
+     * @param {string} event
+     * @param {boolean} [activeOnly=false] Only return active handlers.
+     * @returns {Promise<EventHandler[]>}
+     * @throws {ConductorSdkError}
+     */
+    getEventHandlersForEvent(event: string, activeOnly?: boolean): Promise<EventHandler[]>;
+    /**
+     * Remove an event handler by name
+     * @param {string} name
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    removeEventHandler(name: string): Promise<void>;
+    /**
+     * Get tags for an event handler
+     * @param {string} name
+     * @returns {Promise<Tag[]>}
+     * @throws {ConductorSdkError}
+     */
+    getTagsForEventHandler(name: string): Promise<Tag[]>;
+    /**
+     * Put tags for an event handler
+     * @param {string} name
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    putTagForEventHandler(name: string, tags: Tag[]): Promise<void>;
+    /**
+     * Delete tags for an event handler
+     * @param {string} name
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    deleteTagsForEventHandler(name: string, tags: Tag[]): Promise<void>;
+    /**
+     * Delete a tag for an event handler
+     * @param {string} name
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    deleteTagForEventHandler(name: string, tag: Tag): Promise<void>;
+    /**
+     * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
+     * @param {ConnectivityTestInput} input
+     * @returns {Promise<ConnectivityTestResult>}
+     * @throws {ConductorSdkError}
+     */
+    testConnectivity(input: ConnectivityTestInput): Promise<ConnectivityTestResult>;
+    /**
+     * Create or update queue config by name
+     * @deprecated Prefer server's newer endpoints if available
+     * @param {string} queueType
+     * @param {string} queueName
+     * @param {string} config
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    putQueueConfig(queueType: string, queueName: string, config: string): Promise<void>;
+    /**
+     * Test endpoint (as exposed by API)
+     * @returns {Promise<EventHandler>}
+     * @throws {ConductorSdkError}
+     */
+    test(): Promise<EventHandler>;
+    /**
+     * Get all active event handlers (execution view)
+     * @returns {Promise<SearchResultHandledEventResponse>}
+     * @throws {ConductorSdkError}
+     */
+    getAllActiveEventHandlers(): Promise<SearchResultHandledEventResponse>;
+    /**
+     * Get event executions for a specific handler
+     * @param {string} eventHandlerName
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<ExtendedEventExecution[]>}
+     * @throws {ConductorSdkError}
+     */
+    getEventExecutions(eventHandlerName: string, from?: number): Promise<ExtendedEventExecution[]>;
+    /**
+     * Get all event handlers with statistics (messages view)
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<SearchResultHandledEventResponse>}
+     * @throws {ConductorSdkError}
+     */
+    getEventHandlersWithStats(from?: number): Promise<SearchResultHandledEventResponse>;
+    /**
+     * Get event messages for a given event
+     * @param {string} event
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<EventMessage[]>}
+     * @throws {ConductorSdkError}
+     */
+    getEventMessages(event: string, from?: number): Promise<EventMessage[]>;
+}
+
 interface OrkesApiConfig {
     serverUrl?: string;
     keyId?: string;
@@ -3615,8 +3846,208 @@ interface OrkesApiConfig {
  * @param config (optional) OrkesApiConfig with keyId and keySecret
  * @param customFetch (optional) custom fetch function
  * @param requestHandler DEPRECATED! (optional) ConductorHttpRequest handler, replaced with customFetch
- * @returns
+ * @returns Client
  */
-declare const orkesConductorClient: (config?: OrkesApiConfig, customFetch?: typeof fetch) => Promise<Client>;
+declare const orkesConductorClient: (config?: OrkesApiConfig, customFetch?: typeof fetch) => Promise<{
+    eventResource: {
+        getQueueConfig: (queueType: string, queueName: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        putQueueConfig: (queueType: string, queueName: string, body: string) => Promise<void>;
+        deleteQueueConfig: (queueType: string, queueName: string) => Promise<void>;
+        getEventHandlers: () => Promise<EventHandler[]>;
+        updateEventHandler: (body: any) => Promise<void>;
+        addEventHandler: (body: any) => Promise<void>;
+        getQueueNames: () => Promise<{
+            [key: string]: string;
+        }>;
+        removeEventHandlerStatus: (name: string) => Promise<void>;
+        getEventHandlersForEvent: (event: string, activeOnly?: boolean) => Promise<EventHandler[]>;
+        deleteTagForEventHandler: (name: string, body: any[]) => Promise<void>;
+        getTagsForEventHandler: (name: string) => Promise<Tag[]>;
+        putTagForEventHandler: (name: string, body: any[]) => Promise<void>;
+    };
+    healthCheckResource: {
+        doCheck: () => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    metadataResource: {
+        getTaskDef: (tasktype: string, metadata?: boolean) => Promise<{
+            [key: string]: unknown;
+        }>;
+        unregisterTaskDef: (tasktype: string) => Promise<void>;
+        getAllWorkflows: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<WorkflowDef$1[]>;
+        update: (requestBody: any[], overwrite?: boolean) => Promise<void>;
+        create: (requestBody: any, overwrite?: boolean) => Promise<void>;
+        getTaskDefs: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<TaskDef[]>;
+        updateTaskDef: (requestBody: any) => Promise<void>;
+        registerTaskDef: (requestBody: any[]) => Promise<void>;
+        unregisterWorkflowDef: (name: string, version: number) => Promise<void>;
+        get: (name: string, version?: number, metadata?: boolean) => Promise<WorkflowDef$1>;
+    };
+    schedulerResource: {
+        getSchedule: (name: string) => Promise<WorkflowSchedule>;
+        deleteSchedule: (name: string) => Promise<void>;
+        getNextFewSchedules: (cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number) => Promise<number[]>;
+        pauseSchedule: (name: string) => Promise<void>;
+        pauseAllSchedules: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        resumeSchedule: (name: string) => Promise<void>;
+        requeueAllExecutionRecords: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        resumeAllSchedules: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        getAllSchedules: (workflowName?: string) => Promise<WorkflowScheduleModel[]>;
+        saveSchedule: (requestBody: any) => Promise<void>;
+        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultWorkflowScheduleExecutionModel>;
+        testTimeout: () => Promise<any>;
+    };
+    tokenResource: {
+        generateToken: (requestBody: any) => Promise<Response$1>;
+        getUserInfo: (claims?: boolean) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    workflowBulkResource: {
+        retry: (requestBody: any[]) => Promise<BulkResponse>;
+        restart: (requestBody: any[], useLatestDefinitions?: boolean) => Promise<BulkResponse>;
+        terminate: (requestBody: any[], reason?: string) => Promise<BulkResponse>;
+        resumeWorkflow: (requestBody: any[]) => Promise<BulkResponse>;
+        pauseWorkflow1: (requestBody: any[]) => Promise<BulkResponse>;
+    };
+    workflowResource: {
+        getRunningWorkflow: (name: string, version?: number, startTime?: number, endTime?: number) => Promise<string[]>;
+        executeWorkflow: (body: any, name: string, version: number, requestId?: string, waitUntilTaskRef?: string, waitForSeconds?: number, consistency?: any, returnStrategy?: any) => Promise<SignalResponse$1>;
+        startWorkflow: (requestBody: any) => Promise<string>;
+        decide: (workflowId: string) => Promise<void>;
+        rerun: (workflowId: string, requestBody: any) => Promise<string>;
+        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        pauseWorkflow: (workflowId: string) => Promise<void>;
+        skipTaskFromWorkflow: (workflowId: string, taskReferenceName: string, requestBody?: any) => Promise<void>;
+        getWorkflows: (name: string, requestBody: any[], includeClosed?: boolean, includeTasks?: boolean) => Promise<{
+            [key: string]: Workflow[];
+        }>;
+        getWorkflowStatusSummary: (workflowId: string, includeOutput?: boolean, includeVariables?: boolean) => Promise<WorkflowStatus>;
+        getWorkflows1: (name: string, correlationId: string, includeClosed?: boolean, includeTasks?: boolean) => Promise<Workflow[]>;
+        retry1: (workflowId: string, resumeSubworkflowTasks?: boolean) => Promise<void>;
+        getExecutionStatus: (workflowId: string, includeTasks?: boolean) => Promise<Workflow>;
+        terminate1: (workflowId: string, reason?: string) => Promise<void>;
+        resumeWorkflow: (workflowId: string) => Promise<void>;
+        delete: (workflowId: string, archiveWorkflow?: boolean) => Promise<void>;
+        searchWorkflowsByTasks: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        getExternalStorageLocation: (path: string, operation: string, payloadType: string) => Promise<any>;
+        startWorkflow1: (name: string, requestBody: any, version?: number, correlationId?: string, priority?: number) => Promise<string>;
+        restart1: (workflowId: string, useLatestDefinitions?: boolean) => Promise<void>;
+        search1: (queryId?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean) => Promise<any>;
+        searchWorkflowsByTasksV2: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        resetWorkflow: (workflowId: string) => Promise<void>;
+        testWorkflow: (requestBody: any) => Promise<Workflow>;
+    };
+    serviceRegistryResource: {
+        getRegisteredServices: () => Promise<ServiceRegistry[]>;
+        removeService: (name: string) => Promise<void>;
+        getService: (name: string) => Promise<ServiceRegistry>;
+        openCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
+        closeCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
+        getCircuitBreakerStatus: (name: string) => Promise<CircuitBreakerTransitionResponse>;
+        addOrUpdateService: (serviceRegistry: any) => Promise<void>;
+        addOrUpdateServiceMethod: (registryName: string, method: any) => Promise<void>;
+        removeMethod: (registryName: string, serviceName: string, method: string, methodType: string) => Promise<void>;
+        getProtoData: (registryName: string, filename: string) => Promise<string>;
+        setProtoData: (registryName: string, filename: string, data: any) => Promise<void>;
+        deleteProto: (registryName: string, filename: string) => Promise<void>;
+        getAllProtos: (registryName: string) => Promise<ProtoRegistryEntry[]>;
+        discover: (name: string, create?: boolean) => Promise<ServiceMethod[]>;
+    };
+    humanTaskResource: {
+        getConductorTaskById: (taskId: string) => Promise<Task>;
+    };
+    humanTask: {
+        deleteTaskFromHumanTaskRecords: (requestBody: any[]) => Promise<void>;
+        deleteTaskFromHumanTaskRecords1: (taskId: string) => Promise<void>;
+        search: (requestBody: any) => Promise<HumanTaskSearchResult>;
+        updateTaskOutputByRef: (workflowId: string, taskRefName: string, requestBody: any, complete?: boolean, iteration?: any[]) => Promise<any>;
+        getTask1: (taskId: string) => Promise<HumanTaskEntry>;
+        claimTask: (taskId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
+        assignAndClaim: (taskId: string, userId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
+        reassignTask: (taskId: string, requestBody: any[]) => Promise<void>;
+        releaseTask: (taskId: string) => Promise<void>;
+        skipTask: (taskId: string, reason?: string) => Promise<void>;
+        updateTaskOutput: (taskId: string, requestBody: any, complete?: boolean) => Promise<void>;
+        getAllTemplates: (name?: string, version?: number) => Promise<HumanTaskTemplate[]>;
+        saveTemplate: (requestBody: any, newVersion?: boolean) => Promise<HumanTaskTemplate>;
+        saveTemplates: (requestBody: any[], newVersion?: boolean) => Promise<HumanTaskTemplate[]>;
+        deleteTemplateByName: (name: string) => Promise<void>;
+        deleteTemplatesByNameAndVersion: (name: string, version: number) => Promise<void>;
+        getTemplateByNameAndVersion: (name: string, version: number) => Promise<HumanTaskTemplate>;
+    };
+    taskResource: {
+        poll: (tasktype: string, workerid?: string, domain?: string) => Promise<Task>;
+        allVerbose: () => Promise<{
+            [key: string]: {
+                [key: string]: {
+                    [key: string]: number;
+                };
+            };
+        }>;
+        updateTask: (workflowId: string, taskRefName: string, status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED", requestBody: any) => Promise<string>;
+        getTask: (taskId: string) => Promise<Task>;
+        all: () => Promise<{
+            [key: string]: number;
+        }>;
+        requeuePendingTask: (taskType: string) => Promise<string>;
+        search: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultTaskSummary>;
+        searchV22: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        getPollData: (taskType: string) => Promise<PollData[]>;
+        getTaskLogs: (taskId: string) => Promise<TaskExecLog[]>;
+        log: (taskId: string, requestBody: string) => Promise<void>;
+        getAllPollData: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        batchPoll: (tasktype: string, workerid?: string, domain?: string, count?: number, timeout?: number) => Promise<Task[]>;
+        updateTask1: (requestBody: any) => Promise<string>;
+        size1: (taskType?: string[]) => Promise<{
+            [key: string]: number;
+        }>;
+        getExternalStorageLocation1: (path: string, operation: string, payloadType: string) => Promise<any>;
+        updateTaskSync: (workflowId: string, taskRefName: string, status: any, output: any, workerId?: string) => Promise<Workflow>;
+        signal: (workflowId: string, status: any, output: any, returnStrategy?: any) => Promise<SignalResponse$1>;
+        signalAsync: (workflowId: string, status: any, output: any) => Promise<SignalResponse>;
+    };
+    buildUrl: <TData extends {
+        body?: unknown;
+        path?: Record<string, unknown>;
+        query?: Record<string, unknown>;
+        url: string;
+    }>(options: Pick<TData, "url"> & Options<TData>) => string;
+    getConfig: () => Config<ClientOptions>;
+    request: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    setConfig: (config: Config<ClientOptions>) => Config<ClientOptions>;
+    connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    sse: {
+        connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+    };
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+}>;
 
-export { type Action, ApiError, type ApiRequestOptions, type ApiResult, BaseHttpRequest, CancelError, CancelablePromise, type CircuitBreakerTransitionResponse, type Client, type CommonTaskDef, type ConductorClient, type ConductorLogLevel, type ConductorLogger, ConductorSdkError, type ConductorWorker, Consistency, DefaultLogger, type DefaultLoggerConfig, type DoWhileTaskDef, type EnhancedSignalResponse, type EventHandler, type EventTaskDef, type ExtendedTaskDef, type ExtendedWorkflowDef, type ExternalStorageLocation, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateTokenRequest, type HTScrollableSearchResultHumanTaskEntry, type HttpInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type JoinTaskDef, type JsonJQTransformTaskDef, type KafkaPublishInputParameters, type KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, type OnCancel, type OpenAPIConfig, type OrkesApiConfig, type PollData, type ProtoRegistryEntry, type RerunWorkflowRequest, type Response$1 as Response, ReturnStrategy, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, type ScrollableSearchResultWorkflowSummary, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, type ServiceMethod, type ServiceRegistry, ServiceType, type SetVariableTaskDef, type SignalResponse, type SimpleTaskDef, type SkipTaskRequest, type StartWorkflow, type StartWorkflowRequest, type SubWorkflowParams, type SubWorkflowTaskDef, type SwitchTaskDef, type Task, TaskClient, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskFinderPredicate, type TaskListSearchResultSummary, TaskManager, type TaskManagerConfig, type TaskManagerOptions, type TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerOptions, type TaskSummary, TaskType, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type UserFormTemplate, type WaitTaskDef, type Workflow, type WorkflowDef$1 as WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, 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, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };
+export { type Action, ApiError, type ApiRequestOptions, type ApiResult, type Auth, BaseHttpRequest, CancelError, CancelablePromise, type CircuitBreakerTransitionResponse, type Client, type ClientOptions, type CommonTaskDef, type ConductorClient, type ConductorLogLevel, type ConductorLogger, ConductorSdkError, type ConductorWorker, type Config, type ConnectivityTestInput, type ConnectivityTestResult, Consistency, DefaultLogger, type DefaultLoggerConfig, type DoWhileTaskDef, type EnhancedSignalResponse, EventClient, type EventHandler, type EventMessage, type EventTaskDef, type ExtendedEventExecution, type ExtendedTaskDef, type ExtendedWorkflowDef, type ExternalStorageLocation, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateTokenRequest, type HTScrollableSearchResultHumanTaskEntry, type HttpInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type JoinTaskDef, type JsonJQTransformTaskDef, type KafkaPublishInputParameters, type KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, type Middleware, type OnCancel, type OpenAPIConfig, type OrkesApiConfig, type PollData, type ProtoRegistryEntry, type QuerySerializerOptions, type RequestOptions, type RerunWorkflowRequest, type ResolvedRequestOptions, type Response$1 as Response, ReturnStrategy, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, type ScrollableSearchResultWorkflowSummary, type SearchResultHandledEventResponse, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, type ServiceMethod, type ServiceRegistry, ServiceType, type SetVariableTaskDef, type SignalResponse, type SimpleTaskDef, type SkipTaskRequest, type StartWorkflow, type StartWorkflowRequest, type StreamEvent, type SubWorkflowParams, type SubWorkflowTaskDef, type SwitchTaskDef, type Tag, type Task, TaskClient, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskFinderPredicate, type TaskListSearchResultSummary, TaskManager, type TaskManagerConfig, type TaskManagerOptions, type TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerOptions, type TaskSummary, TaskType, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type UserFormTemplate, type WaitTaskDef, type Workflow, type WorkflowDef$1 as WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, 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, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };