@io-orkes/conductor-javascript 2.4.1 → 3.0.0

package/dist/index.d.mts

@@ -322,6 +322,14 @@ type Any = {
     unknownFields?: UnknownFieldSet;
     value?: ByteString;
 };
+type AuthorizationRequest = {
+    /**
+     * The set of access which is granted or removed
+     */
+    access: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
+    subject: SubjectRef;
+    target: TargetRef;
+};
 type BulkResponse = {
     bulkErrorResults?: {
         [key: string]: string;
@@ -345,6 +353,17 @@ type CircuitBreakerTransitionResponse = {
     service?: string;
     transitionTimestamp?: number;
 };
+type ConductorUser = {
+    applicationUser?: boolean;
+    encryptedId?: boolean;
+    encryptedIdDisplayValue?: string;
+    groups?: Array<Group>;
+    id?: string;
+    name?: string;
+    orkesWorkersApp?: boolean;
+    roles?: Array<Role$1>;
+    uuid?: string;
+};
 type Config = {
     circuitBreakerConfig?: OrkesCircuitBreakerConfig;
 };
@@ -359,6 +378,10 @@ type ConnectivityTestResult = {
     successful?: boolean;
     workflowId?: string;
 };
+type CorrelationIdsSearchRequest = {
+    correlationIds: Array<string>;
+    workflowNames: Array<string>;
+};
 type Declaration = {
     allFields?: {
         [key: string]: unknown;
@@ -399,8 +422,8 @@ type Descriptor = {
     containingType?: Descriptor;
     enumTypes?: Array<EnumDescriptor>;
     extendable?: boolean;
-    extensions?: Array<FieldDescriptor>;
-    fields?: Array<FieldDescriptor>;
+    extensions?: Array<FieldDescriptor$1>;
+    fields?: Array<FieldDescriptor$1>;
     file?: FileDescriptor;
     fullName?: string;
     index?: number;
@@ -966,7 +989,7 @@ type FeatureSetOrBuilder = {
     unknownFields?: UnknownFieldSet;
     utf8Validation?: 'UTF8_VALIDATION_UNKNOWN' | 'NONE' | 'VERIFY';
 };
-type FieldDescriptor = {
+type FieldDescriptor$1 = {
     containingOneof?: OneofDescriptor;
     containingType?: Descriptor;
     defaultValue?: {
@@ -1120,7 +1143,7 @@ type FileDescriptor = {
     edition?: 'EDITION_UNKNOWN' | 'EDITION_PROTO2' | 'EDITION_PROTO3' | 'EDITION_2023' | 'EDITION_1_TEST_ONLY' | 'EDITION_2_TEST_ONLY' | 'EDITION_99997_TEST_ONLY' | 'EDITION_99998_TEST_ONLY' | 'EDITION_99999_TEST_ONLY';
     editionName?: string;
     enumTypes?: Array<EnumDescriptor>;
-    extensions?: Array<FieldDescriptor>;
+    extensions?: Array<FieldDescriptor$1>;
     file?: FileDescriptor;
     fullName?: string;
     messageTypes?: Array<Descriptor>;
@@ -1282,6 +1305,22 @@ type GenerateTokenRequest = {
     keyId: string;
     keySecret: string;
 };
+type GrantedAccess = {
+    access?: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
+    tag?: string;
+    target?: TargetRef;
+};
+type GrantedAccessResponse = {
+    grantedAccess?: Array<GrantedAccess>;
+};
+type Group = {
+    defaultAccess?: {
+        [key: string]: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
+    };
+    description?: string;
+    id?: string;
+    roles?: Array<Role$1>;
+};
 type HandledEventResponse = {
     active?: boolean;
     event?: string;
@@ -1373,6 +1412,84 @@ type HumanTaskUser = {
     user?: string;
     userType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
 };
+type Integration = {
+    apis?: Array<IntegrationApi>;
+    category?: 'API' | 'AI_MODEL' | 'VECTOR_DB' | 'RELATIONAL_DB' | 'MESSAGE_BROKER' | 'GIT' | 'EMAIL' | 'MCP';
+    configuration?: {
+        [key: string]: unknown;
+    };
+    createTime?: number;
+    createdBy?: string;
+    description?: string;
+    enabled?: boolean;
+    modelsCount?: number;
+    name?: string;
+    ownerApp?: string;
+    tags?: Array<Tag>;
+    type?: string;
+    updateTime?: number;
+    updatedBy?: string;
+};
+type IntegrationApi = {
+    api?: string;
+    configuration?: {
+        [key: string]: unknown;
+    };
+    createTime?: number;
+    createdBy?: string;
+    description?: string;
+    enabled?: boolean;
+    integrationName?: string;
+    ownerApp?: string;
+    tags?: Array<Tag>;
+    updateTime?: number;
+    updatedBy?: string;
+};
+type IntegrationApiUpdate = {
+    configuration?: {
+        [key: string]: unknown;
+    };
+    description?: string;
+    enabled?: boolean;
+};
+type IntegrationDef = {
+    apis?: Array<IntegrationDefApi>;
+    category?: 'API' | 'AI_MODEL' | 'VECTOR_DB' | 'RELATIONAL_DB' | 'MESSAGE_BROKER' | 'GIT' | 'EMAIL' | 'MCP';
+    categoryLabel?: string;
+    configuration?: Array<IntegrationDefFormField>;
+    description?: string;
+    enabled?: boolean;
+    iconName?: string;
+    name?: string;
+    tags?: Array<string>;
+    type?: string;
+};
+type IntegrationDefApi = {
+    api?: string;
+    description?: string;
+    inputSchema?: SchemaDef;
+    integrationType?: string;
+    outputSchema?: SchemaDef;
+};
+type IntegrationDefFormField = {
+    defaultValue?: string;
+    description?: string;
+    fieldName?: 'api_key' | 'user' | 'endpoint' | 'authUrl' | 'environment' | 'projectName' | 'indexName' | 'publisher' | 'password' | 'namespace' | 'batchSize' | 'batchWaitTime' | 'visibilityTimeout' | 'connectionType' | 'connectionPoolSize' | 'consumer' | 'stream' | 'batchPollConsumersCount' | 'consumer_type' | 'region' | 'awsAccountId' | 'externalId' | 'roleArn' | 'protocol' | 'mechanism' | 'port' | 'schemaRegistryUrl' | 'schemaRegistryApiKey' | 'schemaRegistryApiSecret' | 'authenticationType' | 'truststoreAuthenticationType' | 'tls' | 'cipherSuite' | 'pubSubMethod' | 'keyStorePassword' | 'keyStoreLocation' | 'schemaRegistryAuthType' | 'valueSubjectNameStrategy' | 'datasourceURL' | 'jdbcDriver' | 'subscription' | 'serviceAccountCredentials' | 'file' | 'tlsFile' | 'queueManager' | 'groupId' | 'channel' | 'dimensions' | 'distance_metric' | 'indexing_method' | 'inverted_list_count' | 'pullPeriod' | 'pullBatchWaitMillis' | 'completionsPath' | 'betaVersion' | 'version';
+    fieldType?: 'DROPDOWN' | 'TEXT' | 'PASSWORD' | 'FILE';
+    label?: string;
+    optional?: boolean;
+    value?: string;
+    valueOptions?: Array<Option>;
+};
+type IntegrationUpdate = {
+    category?: 'API' | 'AI_MODEL' | 'VECTOR_DB' | 'RELATIONAL_DB' | 'MESSAGE_BROKER' | 'GIT' | 'EMAIL' | 'MCP';
+    configuration?: {
+        [key: string]: unknown;
+    };
+    description?: string;
+    enabled?: boolean;
+    type?: string;
+};
 type Location = {
     allFields?: {
         [key: string]: unknown;
@@ -1484,6 +1601,20 @@ type MessageOptionsOrBuilder = {
     uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
     unknownFields?: UnknownFieldSet;
 };
+type MessageTemplate = {
+    createTime?: number;
+    createdBy?: string;
+    description?: string;
+    integrations?: Array<string>;
+    name?: string;
+    ownerApp?: string;
+    tags?: Array<Tag>;
+    template?: string;
+    updateTime?: number;
+    updatedBy?: string;
+    variables?: Array<string>;
+    version?: number;
+};
 type MethodDescriptor = {
     clientStreaming?: boolean;
     file?: FileDescriptor;
@@ -1685,6 +1816,10 @@ type OneofOptionsOrBuilder = {
     uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
     unknownFields?: UnknownFieldSet;
 };
+type Option = {
+    label?: string;
+    value?: string;
+};
 type OrkesCircuitBreakerConfig = {
     automaticTransitionFromOpenToHalfOpenEnabled?: boolean;
     failureRateThreshold?: number;
@@ -1789,12 +1924,26 @@ type ParserSourceCodeInfo = {
 type ParserUninterpretedOption = {
     [key: string]: unknown;
 };
+type Permission = {
+    name?: string;
+};
 type PollData = {
     domain?: string;
     lastPollTime?: number;
     queueName?: string;
     workerId?: string;
 };
+type PromptTemplateTestRequest = {
+    llmProvider?: string;
+    model?: string;
+    prompt?: string;
+    promptVariables?: {
+        [key: string]: unknown;
+    };
+    stopWords?: Array<string>;
+    temperature?: number;
+    topP?: number;
+};
 type ProtoRegistryEntry = {
     data?: string;
     filename?: string;
@@ -1850,6 +1999,10 @@ type ReservedRangeOrBuilder = {
 type Response$1 = {
     [key: string]: unknown;
 };
+type Role$1 = {
+    name?: string;
+    permissions?: Array<Permission>;
+};
 type SaveScheduleRequest = {
     createdBy?: string;
     cronExpression: string;
@@ -2092,6 +2245,16 @@ type SubWorkflowParams = {
         [key: string]: unknown;
     };
 };
+/**
+ * User, group or role which is granted/removed access
+ */
+type SubjectRef = {
+    id: string;
+    /**
+     * User, role or group
+     */
+    type?: 'USER' | 'ROLE' | 'GROUP';
+};
 type Tag = {
     key?: string;
     /**
@@ -2100,6 +2263,13 @@ type Tag = {
     type?: string;
     value?: string;
 };
+/**
+ * The object over which access is being granted or removed
+ */
+type TargetRef = {
+    id: "Identifier of the target e.g. `name` in case it's a WORKFLOW_DEF";
+    type: 'WORKFLOW' | 'WORKFLOW_DEF' | 'WORKFLOW_SCHEDULE' | 'EVENT_HANDLER' | 'TASK_DEF' | 'TASK_REF_NAME' | 'TASK_ID' | 'APPLICATION' | 'USER' | 'SECRET_NAME' | 'ENV_VARIABLE' | 'TAG' | 'DOMAIN' | 'INTEGRATION_PROVIDER' | 'INTEGRATION' | 'PROMPT' | 'USER_FORM_TEMPLATE' | 'SCHEMA' | 'CLUSTER_CONFIG' | 'WEBHOOK';
+};
 type Task = {
     callbackAfterSeconds?: number;
     callbackFromWorker?: boolean;
@@ -2203,6 +2373,14 @@ type TaskListSearchResultSummary = {
     };
     totalHits?: number;
 };
+type TaskMock = {
+    executionTime?: number;
+    output?: {
+        [key: string]: unknown;
+    };
+    queueWaitTime?: number;
+    status?: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED';
+};
 type TaskResult = {
     callbackAfterSeconds?: number;
     extendLease?: boolean;
@@ -2302,6 +2480,30 @@ type UpdateWorkflowVariables = {
     };
     workflowId?: string;
 };
+type UpsertGroupRequest = {
+    /**
+     * a default Map<TargetType, Set<Access> to share permissions, allowed target types: WORKFLOW_DEF, TASK_DEF, WORKFLOW_SCHEDULE
+     */
+    defaultAccess?: {
+        [key: string]: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
+    };
+    /**
+     * A general description of the group
+     */
+    description: string;
+    roles?: 'ADMIN' | 'USER' | 'WORKER' | 'METADATA_MANAGER' | 'WORKFLOW_MANAGER';
+};
+type UpsertUserRequest = {
+    /**
+     * Ids of the groups this user belongs to
+     */
+    groups?: Array<string>;
+    /**
+     * User's full name
+     */
+    name: string;
+    roles?: 'ADMIN' | 'USER' | 'WORKER' | 'METADATA_MANAGER' | 'WORKFLOW_MANAGER';
+};
 type UserFormTemplate = {
     name?: string;
     version?: number;
@@ -2461,6 +2663,13 @@ type WorkflowScheduleModel = {
     updatedTime?: number;
     zoneId?: string;
 };
+type WorkflowStateUpdate = {
+    taskReferenceName?: string;
+    taskResult?: TaskResult;
+    variables?: {
+        [key: string]: unknown;
+    };
+};
 type WorkflowStatus = {
     correlationId?: string;
     output?: {
@@ -2549,6 +2758,29 @@ type WorkflowTask = {
     taskReferenceName: string;
     type?: string;
 };
+type WorkflowTestRequest = {
+    correlationId?: string;
+    createdBy?: string;
+    externalInputPayloadStoragePath?: string;
+    idempotencyKey?: string;
+    idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING' | 'FAIL_ON_RUNNING';
+    input?: {
+        [key: string]: unknown;
+    };
+    name: string;
+    priority?: number;
+    subWorkflowTestRequest?: {
+        [key: string]: WorkflowTestRequest;
+    };
+    taskRefToMockOutput?: {
+        [key: string]: Array<TaskMock>;
+    };
+    taskToDomain?: {
+        [key: string]: string;
+    };
+    version?: number;
+    workflowDef?: WorkflowDef;
+};
 
 interface CommonTaskDef {
     name: string;
@@ -2582,10 +2814,14 @@ declare enum TaskType {
     JOIN = "JOIN",
     DO_WHILE = "DO_WHILE",
     SUB_WORKFLOW = "SUB_WORKFLOW",
+    START_WORKFLOW = "START_WORKFLOW",
     EVENT = "EVENT",
     WAIT = "WAIT",
+    WAIT_FOR_WEBHOOK = "WAIT_FOR_WEBHOOK",
     USER_DEFINED = "USER_DEFINED",
     HTTP = "HTTP",
+    HTTP_POLL = "HTTP_POLL",
+    HUMAN = "HUMAN",
     LAMBDA = "LAMBDA",
     INLINE = "INLINE",
     EXCLUSIVE_JOIN = "EXCLUSIVE_JOIN",
@@ -2593,7 +2829,20 @@ declare enum TaskType {
     TERMINATE = "TERMINATE",
     KAFKA_PUBLISH = "KAFKA_PUBLISH",
     JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
-    SET_VARIABLE = "SET_VARIABLE"
+    SET_VARIABLE = "SET_VARIABLE",
+    GET_DOCUMENT = "GET_DOCUMENT",
+    LLM_CHAT_COMPLETE = "LLM_CHAT_COMPLETE",
+    LLM_TEXT_COMPLETE = "LLM_TEXT_COMPLETE",
+    LLM_GENERATE_EMBEDDINGS = "LLM_GENERATE_EMBEDDINGS",
+    LLM_INDEX_TEXT = "LLM_INDEX_TEXT",
+    LLM_SEARCH_INDEX = "LLM_SEARCH_INDEX",
+    LLM_SEARCH_EMBEDDINGS = "LLM_SEARCH_EMBEDDINGS",
+    LLM_STORE_EMBEDDINGS = "LLM_STORE_EMBEDDINGS",
+    LLM_GET_EMBEDDINGS = "LLM_GET_EMBEDDINGS",
+    GENERATE_IMAGE = "GENERATE_IMAGE",
+    GENERATE_AUDIO = "GENERATE_AUDIO",
+    CALL_MCP_TOOL = "CALL_MCP_TOOL",
+    LIST_MCP_TOOLS = "LIST_MCP_TOOLS"
 }
 declare enum ServiceType {
     HTTP = "HTTP",
@@ -2756,7 +3005,9 @@ interface SignalResponse extends SignalResponse$1 {
     referenceTaskName?: string;
     retryCount?: number;
     taskDefName?: string;
+    retriedTaskId?: string;
     workflowType?: string;
+    reasonForIncompletion?: string;
 }
 interface AccessKey {
     id: string;
@@ -2771,6 +3022,33 @@ type ApplicationRole = "ADMIN" | "UNRESTRICTED_WORKER" | "METADATA_MANAGER" | "W
 interface ExtendedConductorApplication extends Required<Omit<ExtendedConductorApplication$1, "tags">> {
     tags?: Tag[];
 }
+/** Extended ConductorUser with fields present in Python SDK but missing from OpenAPI spec */
+interface ExtendedConductorUser extends ConductorUser {
+    contactInformation?: Record<string, string>;
+    namespace?: string;
+}
+/** Extended Group with fields present in Python SDK but missing from OpenAPI spec */
+interface ExtendedGroup extends Group {
+    contactInformation?: Record<string, string>;
+}
+/** Extended IntegrationApiUpdate with fields present in Python SDK but missing from OpenAPI spec */
+interface ExtendedIntegrationApiUpdate extends IntegrationApiUpdate {
+    maxTokens?: number;
+    frequency?: string;
+}
+/** Extended RateLimitConfig with fields present in Python SDK but missing from OpenAPI spec */
+interface ExtendedRateLimitConfig extends RateLimitConfig {
+    tag?: string;
+    concurrentExecutionLimit?: number;
+}
+/** Extended BulkResponse with fields present in Python SDK but missing from OpenAPI spec */
+interface ExtendedBulkResponse extends BulkResponse {
+    message?: string;
+}
+/** Extended TaskSummary with fields present in Python SDK but missing from OpenAPI spec */
+interface ExtendedTaskSummary extends TaskSummary {
+    domain?: string;
+}
 
 type TimeoutPolicy = {
     type: string;
@@ -2866,6 +3144,35 @@ declare abstract class BaseHttpRequest {
     abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
 }
 
+interface ConductorLogger {
+    info(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    warn?(...args: unknown[]): void;
+}
+type ConductorLogLevel = keyof typeof LOG_LEVELS;
+interface DefaultLoggerConfig {
+    level?: ConductorLogLevel;
+    tags?: object[];
+}
+declare const LOG_LEVELS: {
+    readonly DEBUG: 10;
+    readonly INFO: 30;
+    readonly WARN: 40;
+    readonly ERROR: 60;
+};
+declare class DefaultLogger implements ConductorLogger {
+    private readonly tags;
+    private readonly level;
+    constructor(config?: DefaultLoggerConfig);
+    private log;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+declare const noopLogger: ConductorLogger;
+
 type TaskResultStatus = NonNullable<TaskResult["status"]>;
 type TaskResultOutputData = NonNullable<TaskResult["outputData"]>;
 interface OrkesApiConfig {
@@ -2875,6 +3182,15 @@ interface OrkesApiConfig {
     refreshTokenInterval?: number;
     useEnvVars?: boolean;
     maxHttp2Connections?: number;
+    logger?: ConductorLogger;
+    requestTimeoutMs?: number;
+    connectTimeoutMs?: number;
+    tlsCertPath?: string;
+    tlsKeyPath?: string;
+    tlsCaPath?: string;
+    proxyUrl?: string;
+    tlsInsecure?: boolean;
+    disableHttp2?: boolean;
 }
 
 /**
@@ -3218,6 +3534,125 @@ declare class ApplicationClient {
     addApplicationTag(applicationId: string, tag: Tag): Promise<void>;
 }
 
+declare class AuthorizationClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Grant permissions to a subject for a target
+     * @param request - The authorization request
+     */
+    grantPermissions(request: AuthorizationRequest): Promise<void>;
+    /**
+     * Get permissions for a resource
+     * @param type - The resource type
+     * @param id - The resource ID
+     * @returns The permissions object
+     */
+    getPermissions(type: "WORKFLOW" | "WORKFLOW_DEF" | "WORKFLOW_SCHEDULE" | "EVENT_HANDLER" | "TASK_DEF" | "TASK_REF_NAME" | "TASK_ID" | "APPLICATION" | "USER" | "SECRET_NAME" | "ENV_VARIABLE" | "TAG" | "DOMAIN" | "INTEGRATION_PROVIDER" | "INTEGRATION" | "PROMPT" | "USER_FORM_TEMPLATE" | "SCHEMA" | "CLUSTER_CONFIG" | "WEBHOOK", id: string): Promise<Record<string, unknown>>;
+    /**
+     * Remove permissions from a subject for a target
+     * @param request - The authorization request
+     */
+    removePermissions(request: AuthorizationRequest): Promise<void>;
+    /**
+     * Create or update a user
+     * @param id - The user ID
+     * @param request - The upsert user request
+     * @returns The user object
+     */
+    upsertUser(id: string, request: UpsertUserRequest): Promise<ExtendedConductorUser>;
+    /**
+     * Get a user by ID
+     * @param id - The user ID
+     * @returns The user object
+     */
+    getUser(id: string): Promise<ExtendedConductorUser>;
+    /**
+     * List all users
+     * @param apps - Whether to include application users
+     * @returns Array of users
+     */
+    listUsers(apps?: boolean): Promise<ExtendedConductorUser[]>;
+    /**
+     * Delete a user
+     * @param id - The user ID
+     */
+    deleteUser(id: string): Promise<void>;
+    /**
+     * Check permissions for a user
+     * @param userId - The user ID
+     * @param type - The resource type
+     * @param id - The resource ID
+     * @returns The permissions check result
+     */
+    checkPermissions(userId: string, type: string, id: string): Promise<Record<string, unknown>>;
+    /**
+     * Get granted permissions for a user
+     * @param userId - The user ID
+     * @returns The granted permissions
+     */
+    getGrantedPermissionsForUser(userId: string): Promise<GrantedAccessResponse>;
+    /**
+     * Create or update a group
+     * @param id - The group ID
+     * @param request - The upsert group request
+     * @returns The group object
+     */
+    upsertGroup(id: string, request: UpsertGroupRequest): Promise<ExtendedGroup>;
+    /**
+     * Get a group by ID
+     * @param id - The group ID
+     * @returns The group object
+     */
+    getGroup(id: string): Promise<ExtendedGroup>;
+    /**
+     * List all groups
+     * @returns Array of groups
+     */
+    listGroups(): Promise<ExtendedGroup[]>;
+    /**
+     * Delete a group
+     * @param id - The group ID
+     */
+    deleteGroup(id: string): Promise<void>;
+    /**
+     * Add a user to a group
+     * @param groupId - The group ID
+     * @param userId - The user ID
+     */
+    addUserToGroup(groupId: string, userId: string): Promise<void>;
+    /**
+     * Add multiple users to a group
+     * @param groupId - The group ID
+     * @param userIds - Array of user IDs
+     */
+    addUsersToGroup(groupId: string, userIds: string[]): Promise<void>;
+    /**
+     * Get users in a group
+     * @param id - The group ID
+     * @returns The users in the group
+     */
+    getUsersInGroup(id: string): Promise<ExtendedConductorUser[]>;
+    /**
+     * Remove a user from a group
+     * @param groupId - The group ID
+     * @param userId - The user ID
+     */
+    removeUserFromGroup(groupId: string, userId: string): Promise<void>;
+    /**
+     * Remove multiple users from a group
+     * @param groupId - The group ID
+     * @param userIds - Array of user IDs
+     */
+    removeUsersFromGroup(groupId: string, userIds: string[]): Promise<void>;
+    /**
+     * Get granted permissions for a group
+     * @param groupId - The group ID
+     * @returns The granted access response
+     */
+    getGrantedPermissionsForGroup(groupId: string): Promise<GrantedAccessResponse>;
+}
+
 declare class EventClient {
     readonly _client: Client;
     constructor(client: Client);
@@ -3384,166 +3819,14 @@ declare class EventClient {
     getEventMessages(event: string, from?: number): Promise<EventMessage[]>;
 }
 
-interface ConductorLogger {
-    info(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-    debug(...args: unknown[]): void;
-}
-type ConductorLogLevel = keyof typeof LOG_LEVELS;
-interface DefaultLoggerConfig {
-    level?: ConductorLogLevel;
-    tags?: object[];
+type UserType = "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP";
+interface PollIntervalOptions {
+    pollInterval: number;
+    maxPollTimes: number;
 }
-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: unknown[]) => void;
-    debug: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-}
-declare const noopLogger: ConductorLogger;
-
-type TaskErrorHandler = (error: Error, task?: Task) => void;
-interface ConductorWorker {
-    taskDefName: string;
-    execute: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId">>;
-    domain?: string;
-    concurrency?: number;
-    pollInterval?: number;
-}
-interface TaskRunnerOptions {
-    workerID: string;
-    domain: string | undefined;
-    pollInterval?: number;
-    concurrency?: number;
-    batchPollingTimeout?: number;
-}
-interface RunnerArgs {
-    worker: ConductorWorker;
-    client: Client;
-    options: TaskRunnerOptions;
-    logger?: ConductorLogger;
-    onError?: TaskErrorHandler;
-    concurrency?: number;
-    maxRetries?: number;
-}
-interface PollerOptions {
-    pollInterval?: number;
-    concurrency: number;
-    warnAtO?: number;
-}
-type TaskManagerOptions = TaskRunnerOptions;
-interface TaskManagerConfig {
-    logger?: ConductorLogger;
-    options?: Partial<TaskManagerOptions>;
-    onError?: TaskErrorHandler;
-    maxRetries?: number;
-}
-
-/**
- * Responsible for initializing and managing the runners that poll and work different task queues.
- */
-declare class TaskManager {
-    private workerRunners;
-    private readonly client;
-    private readonly logger;
-    private readonly errorHandler;
-    private workers;
-    readonly options: Required<TaskManagerOptions>;
-    private polling;
-    private maxRetries;
-    constructor(client: Client, workers: ConductorWorker[], config?: TaskManagerConfig);
-    private workerManagerWorkerOptions;
-    get isPolling(): boolean;
-    updatePollingOptionForWorker: (workerTaskDefName: string, options: Partial<TaskManagerOptions>) => void;
-    /**
-     * new options will get merged to existing options
-     * @param options new options to update polling options
-     */
-    updatePollingOptions: (options: Partial<TaskManagerOptions>) => void;
-    sanityCheck: () => void;
-    /**
-     * Start polling for tasks
-     */
-    startPolling: () => void;
-    /**
-     * Stops polling for tasks
-     */
-    stopPolling: () => Promise<void>;
-}
-
-/**
- * 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 {
-    _client: Client;
-    worker: ConductorWorker;
-    private logger;
-    private options;
-    errorHandler: TaskErrorHandler;
-    private poller;
-    private maxRetries;
-    constructor({ worker, client, options, logger, onError: errorHandler, maxRetries, }: RunnerArgs);
-    get isPolling(): boolean;
-    /**
-     * Starts polling for work
-     */
-    startPolling: () => void;
-    /**
-     * Stops Polling for work
-     */
-    stopPolling: () => Promise<void>;
-    updateOptions(options: Partial<TaskRunnerOptions>): void;
-    get getOptions(): TaskRunnerOptions;
-    private batchPoll;
-    updateTaskWithRetry: (task: Task, taskResult: TaskResult) => Promise<void>;
-    private executeTask;
-    handleUnknownError: (unknownError: unknown) => void;
-}
-
-declare class Poller<T> {
-    private timeoutHandler?;
-    private pollFunction;
-    private performWorkFunction;
-    private polling;
-    private _tasksInProcess;
-    private _counterAtO;
-    private _pollerId;
-    options: PollerOptions;
-    logger: ConductorLogger;
-    constructor(pollerId: string, pollFunction: (count: number) => Promise<T[] | undefined>, performWorkFunction: (work: T) => Promise<void>, pollerOptions?: Partial<PollerOptions>, logger?: ConductorLogger);
-    get isPolling(): boolean;
-    get tasksInProcess(): number;
-    /**
-     * Starts polling for work
-     */
-    startPolling: () => void;
-    /**
-     * Stops Polling for work
-     */
-    stopPolling: () => Promise<void>;
-    private performWork;
-    updateOptions(options: Partial<PollerOptions>): void;
-    private poll;
-}
-
-type UserType = "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP";
-interface PollIntervalOptions {
-    pollInterval: number;
-    maxPollTimes: number;
+interface ClaimTaskOptions {
+    overrideAssignment?: boolean;
+    withTemplate?: boolean;
 }
 
 declare class HumanExecutor {
@@ -3598,13 +3881,13 @@ declare class HumanExecutor {
      * @param assignee
      * @returns
      */
-    claimTaskAsExternalUser(taskId: string, assignee: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    claimTaskAsExternalUser(taskId: string, assignee: string, options?: ClaimTaskOptions): Promise<HumanTaskEntry>;
     /**
      * Claim task as conductor user
      * @param taskId
      * @returns
      */
-    claimTaskAsConductorUser(taskId: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    claimTaskAsConductorUser(taskId: string, options?: ClaimTaskOptions): Promise<HumanTaskEntry>;
     /**
      * Claim task as conductor user
      * @param taskId
@@ -3639,6 +3922,137 @@ declare class HumanExecutor {
     completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
 }
 
+declare class IntegrationClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Save (create or update) an integration provider
+     * @param name - The provider name
+     * @param integration - The integration configuration
+     */
+    saveIntegrationProvider(name: string, integration: IntegrationUpdate): Promise<void>;
+    /**
+     * Get an integration provider by name
+     * @param name - The provider name
+     * @returns The integration provider
+     */
+    getIntegrationProvider(name: string): Promise<Integration>;
+    /**
+     * Get all integration providers
+     * @returns Array of integrations representing providers
+     */
+    getIntegrationProviders(): Promise<Integration[]>;
+    /**
+     * Delete an integration provider
+     * @param name - The provider name
+     */
+    deleteIntegrationProvider(name: string): Promise<void>;
+    /**
+     * Save (create or update) an integration API
+     * @param providerName - The provider name
+     * @param integrationName - The integration name
+     * @param api - The integration API configuration
+     */
+    saveIntegrationApi(providerName: string, integrationName: string, api: ExtendedIntegrationApiUpdate): Promise<void>;
+    /**
+     * Get an integration API
+     * @param providerName - The provider name
+     * @param integrationName - The integration name
+     * @returns The integration API
+     */
+    getIntegrationApi(providerName: string, integrationName: string): Promise<IntegrationApi>;
+    /**
+     * Get all integration APIs for a provider
+     * @param providerName - The provider name
+     * @returns Array of integration APIs
+     */
+    getIntegrationApis(providerName: string): Promise<IntegrationApi[]>;
+    /**
+     * Delete an integration API
+     * @param providerName - The provider name
+     * @param integrationName - The integration name
+     */
+    deleteIntegrationApi(providerName: string, integrationName: string): Promise<void>;
+    /**
+     * Get all integrations
+     * @param category - Optional category filter
+     * @param activeOnly - Whether to return only active integrations
+     * @returns Array of integrations
+     */
+    getIntegrations(category?: string, activeOnly?: boolean): Promise<Integration[]>;
+    /**
+     * Get integration provider definitions
+     * @returns Array of integration definitions
+     */
+    getIntegrationProviderDefs(): Promise<IntegrationDef[]>;
+    /**
+     * Get providers and integrations
+     * @param type - Optional type filter
+     * @param activeOnly - Whether to return only active
+     * @returns Array of provider and integration info
+     */
+    getProvidersAndIntegrations(type?: string, activeOnly?: boolean): Promise<string[]>;
+    /**
+     * Get available APIs for a provider
+     * @param providerName - The provider name
+     * @returns Array of available APIs
+     */
+    getIntegrationAvailableApis(providerName: string): Promise<string[]>;
+    /**
+     * Associate a prompt with an integration
+     * @param providerName - The integration provider name
+     * @param integrationName - The integration name
+     * @param promptName - The prompt template name
+     */
+    associatePromptWithIntegration(providerName: string, integrationName: string, promptName: string): Promise<void>;
+    /**
+     * Get prompts associated with an integration
+     * @param providerName - The integration provider name
+     * @param integrationName - The integration name
+     * @returns Array of associated prompt templates
+     */
+    getPromptsWithIntegration(providerName: string, integrationName: string): Promise<MessageTemplate[]>;
+    /**
+     * Set tags for an integration
+     * @param providerName - The provider name
+     * @param integrationName - The integration name
+     * @param tags - The tags to set
+     */
+    setIntegrationTags(providerName: string, integrationName: string, tags: Tag[]): Promise<void>;
+    /**
+     * Get tags for an integration
+     * @param providerName - The provider name
+     * @param integrationName - The integration name
+     * @returns Array of tags
+     */
+    getIntegrationTags(providerName: string, integrationName: string): Promise<Tag[]>;
+    /**
+     * Delete tags from an integration
+     * @param providerName - The provider name
+     * @param integrationName - The integration name
+     * @param tags - The tags to delete
+     */
+    deleteIntegrationTags(providerName: string, integrationName: string, tags: Tag[]): Promise<void>;
+    /**
+     * Set tags for an integration provider
+     * @param providerName - The provider name
+     * @param tags - The tags to set
+     */
+    setProviderTags(providerName: string, tags: Tag[]): Promise<void>;
+    /**
+     * Get tags for an integration provider
+     * @param providerName - The provider name
+     * @returns Array of tags
+     */
+    getProviderTags(providerName: string): Promise<Tag[]>;
+    /**
+     * Delete tags from an integration provider
+     * @param providerName - The provider name
+     * @param tags - The tags to delete
+     */
+    deleteProviderTags(providerName: string, tags: Tag[]): Promise<void>;
+}
+
 declare class MetadataClient {
     readonly _client: Client;
     constructor(client: Client);
@@ -3701,6 +4115,142 @@ declare class MetadataClient {
      * @returns
      */
     unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
+    /**
+     * Get all task definitions
+     * @returns Array of all task definitions
+     */
+    getAllTaskDefs(): Promise<TaskDef[]>;
+    /**
+     * Get all workflow definitions
+     * @returns Array of all workflow definitions
+     */
+    getAllWorkflowDefs(): Promise<WorkflowDef[]>;
+    /**
+     * Add a tag to a workflow definition
+     * @param tag - The tag to add
+     * @param name - The workflow definition name
+     */
+    addWorkflowTag(tag: Tag, name: string): Promise<void>;
+    /**
+     * Delete a tag from a workflow definition
+     * @param tag - The tag to delete
+     * @param name - The workflow definition name
+     */
+    deleteWorkflowTag(tag: Tag, name: string): Promise<void>;
+    /**
+     * Get all tags for a workflow definition
+     * @param name - The workflow definition name
+     * @returns Array of tags
+     */
+    getWorkflowTags(name: string): Promise<Tag[]>;
+    /**
+     * Set (replace all existing) tags for a workflow definition
+     * @param tags - The tags to set
+     * @param name - The workflow definition name
+     */
+    setWorkflowTags(tags: Tag[], name: string): Promise<void>;
+    /**
+     * Add a tag to a task definition
+     * @param tag - The tag to add
+     * @param taskName - The task definition name
+     */
+    addTaskTag(tag: Tag, taskName: string): Promise<void>;
+    /**
+     * Delete a tag from a task definition
+     * @param tag - The tag to delete
+     * @param taskName - The task definition name
+     */
+    deleteTaskTag(tag: Tag, taskName: string): Promise<void>;
+    /**
+     * Get all tags for a task definition
+     * @param taskName - The task definition name
+     * @returns Array of tags
+     */
+    getTaskTags(taskName: string): Promise<Tag[]>;
+    /**
+     * Set (replace all existing) tags for a task definition
+     * @param tags - The tags to set
+     * @param taskName - The task definition name
+     */
+    setTaskTags(tags: Tag[], taskName: string): Promise<void>;
+    /**
+     * Set the rate limit configuration for a workflow
+     * @param rateLimitConfig - Rate limit configuration
+     * @param name - Workflow definition name
+     */
+    setWorkflowRateLimit(rateLimitConfig: RateLimitConfig | ExtendedRateLimitConfig, name: string): Promise<void>;
+    /**
+     * Get the rate limit configuration for a workflow
+     * @param name - Workflow definition name
+     * @returns Rate limit configuration or undefined if not set
+     */
+    getWorkflowRateLimit(name: string): Promise<RateLimitConfig | ExtendedRateLimitConfig | undefined>;
+    /**
+     * Remove the rate limit configuration for a workflow
+     * @param name - Workflow definition name
+     */
+    removeWorkflowRateLimit(name: string): Promise<void>;
+}
+
+declare class PromptClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Save a prompt template
+     * @param name - The prompt name
+     * @param description - Description of the prompt
+     * @param template - The prompt template text
+     * @param models - Optional array of model names
+     */
+    savePrompt(name: string, description: string, template: string, models?: string[]): Promise<void>;
+    /**
+     * Update a prompt template
+     * @param name - The prompt name
+     * @param description - Description of the prompt
+     * @param template - The prompt template text
+     * @param models - Optional array of model names
+     */
+    updatePrompt(name: string, description: string, template: string, models?: string[]): Promise<void>;
+    /**
+     * Get a prompt template by name
+     * @param name - The prompt name
+     * @returns The message template
+     */
+    getPrompt(name: string): Promise<MessageTemplate>;
+    /**
+     * Get all prompt templates
+     * @returns Array of message templates
+     */
+    getPrompts(): Promise<MessageTemplate[]>;
+    /**
+     * Delete a prompt template
+     * @param name - The prompt name
+     */
+    deletePrompt(name: string): Promise<void>;
+    /**
+     * Test a prompt template against an LLM
+     * @param testRequest - The test request containing prompt text, variables, model info, etc.
+     * @returns The LLM response string
+     */
+    testPrompt(testRequest: PromptTemplateTestRequest): Promise<string>;
+    /**
+     * Get tags for a prompt template
+     * @param name - The prompt name
+     * @returns Array of tags
+     */
+    getPromptTags(name: string): Promise<Tag[]>;
+    /**
+     * Set tags for a prompt template
+     * @param name - The prompt name
+     * @param tags - The tags to set
+     */
+    setPromptTags(name: string, tags: Tag[]): Promise<void>;
+    /**
+     * Delete tags from a prompt template
+     * @param name - The prompt name
+     * @param tags - The tags to delete
+     */
+    deletePromptTags(name: string, tags: Tag[]): Promise<void>;
 }
 
 declare class SchedulerClient {
@@ -3783,6 +4333,120 @@ declare class SchedulerClient {
      * @throws ApiError
      */
     resumeAllSchedules(): Promise<void>;
+    /**
+     * Set tags for a schedule
+     * @param tags - The tags to set
+     * @param name - The schedule name
+     */
+    setSchedulerTags(tags: Tag[], name: string): Promise<void>;
+    /**
+     * Get tags for a schedule
+     * @param name - The schedule name
+     * @returns Array of tags
+     */
+    getSchedulerTags(name: string): Promise<Tag[]>;
+    /**
+     * Delete tags from a schedule
+     * @param tags - The tags to delete
+     * @param name - The schedule name
+     */
+    deleteSchedulerTags(tags: Tag[], name: string): Promise<void>;
+}
+
+declare class SchemaClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Register (create or update) schemas
+     * @param schemas - Array of schema definitions to register
+     * @param newVersion - Whether to create a new version
+     */
+    registerSchema(schemas: SchemaDef[], newVersion?: boolean): Promise<void>;
+    /**
+     * Get a schema by name and version
+     * @param name - The schema name
+     * @param version - The schema version
+     * @returns The schema definition
+     */
+    getSchema(name: string, version: number): Promise<SchemaDef>;
+    /**
+     * Get the latest version of a schema by name
+     * @param name - The schema name
+     * @returns The schema definition
+     */
+    getSchemaByName(name: string): Promise<SchemaDef>;
+    /**
+     * Get all schemas
+     * @returns Array of all schema definitions
+     */
+    getAllSchemas(): Promise<SchemaDef[]>;
+    /**
+     * Delete a specific version of a schema
+     * @param name - The schema name
+     * @param version - The schema version
+     */
+    deleteSchema(name: string, version: number): Promise<void>;
+    /**
+     * Delete all versions of a schema by name
+     * @param name - The schema name
+     */
+    deleteSchemaByName(name: string): Promise<void>;
+}
+
+declare class SecretClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Store a secret value
+     * @param key - The secret key
+     * @param value - The secret value
+     */
+    putSecret(key: string, value: string): Promise<void>;
+    /**
+     * Get a secret value
+     * @param key - The secret key
+     * @returns The secret value
+     */
+    getSecret(key: string): Promise<string>;
+    /**
+     * Delete a secret
+     * @param key - The secret key
+     */
+    deleteSecret(key: string): Promise<void>;
+    /**
+     * List all secret names
+     * @returns Array of secret names
+     */
+    listAllSecretNames(): Promise<string[]>;
+    /**
+     * List secrets that the user can grant access to
+     * @returns Array of secret names
+     */
+    listSecretsThatUserCanGrantAccessTo(): Promise<string[]>;
+    /**
+     * Check if a secret exists
+     * @param key - The secret key
+     * @returns Whether the secret exists
+     */
+    secretExists(key: string): Promise<boolean>;
+    /**
+     * Set tags for a secret
+     * @param tags - The tags to set
+     * @param key - The secret key
+     */
+    setSecretTags(tags: Tag[], key: string): Promise<void>;
+    /**
+     * Get tags for a secret
+     * @param key - The secret key
+     * @returns Array of tags
+     */
+    getSecretTags(key: string): Promise<Tag[]>;
+    /**
+     * Delete tags from a secret
+     * @param tags - The tags to delete
+     * @param key - The secret key
+     */
+    deleteSecretTags(tags: Tag[], key: string): Promise<void>;
 }
 
 /**
@@ -3916,6 +4580,40 @@ declare class TaskClient {
      * @returns
      */
     updateTaskResult(workflowId: string, taskRefName: string, status: TaskResultStatus, outputData: Record<string, unknown>): Promise<string>;
+    /**
+     * Add a log entry to a task
+     * @param taskId - The task ID
+     * @param message - The log message
+     */
+    addTaskLog(taskId: string, message: string): Promise<void>;
+    /**
+     * Get logs for a task
+     * @param taskId - The task ID
+     * @returns Array of task execution logs
+     */
+    getTaskLogs(taskId: string): Promise<TaskExecLog[]>;
+    /**
+     * Get queue sizes for task types
+     * @param taskType - Optional array of task types to filter by
+     * @returns Map of task type to queue size
+     */
+    getQueueSizeForTask(taskType?: string[]): Promise<Record<string, number>>;
+    /**
+     * Get poll data for a task type
+     * @param taskType - The task type
+     * @returns Array of poll data
+     */
+    getTaskPollData(taskType: string): Promise<PollData[]>;
+    /**
+     * Updates a task by reference name synchronously and returns the complete workflow
+     * @param workflowId - The workflow instance ID
+     * @param taskRefName - The task reference name
+     * @param status - The task status
+     * @param output - The task output data
+     * @param workerId - Optional worker ID
+     * @returns The updated workflow
+     */
+    updateTaskSync(workflowId: string, taskRefName: string, status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED", output: Record<string, unknown>, workerId?: string): Promise<Workflow>;
 }
 
 declare class TemplateClient {
@@ -4124,11 +4822,587 @@ declare class WorkflowExecutor {
      * @returns Promise<void>
      */
     signalAsync(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData): Promise<void>;
+    /**
+     * Deletes a workflow execution
+     * @param workflowId - The workflow instance ID to delete
+     * @param archiveWorkflow - Whether to archive the workflow before deletion
+     */
+    deleteWorkflow(workflowId: string, archiveWorkflow?: boolean): Promise<void>;
+    /**
+     * Gets workflows by correlation IDs
+     * @param request - Correlation IDs search request containing workflow names and correlation IDs
+     * @param includeClosed - Whether to include closed workflows
+     * @param includeTasks - Whether to include task details
+     * @returns Map of correlation ID to array of matching workflows
+     */
+    getByCorrelationIds(request: CorrelationIdsSearchRequest, includeClosed?: boolean, includeTasks?: boolean): Promise<Record<string, Workflow[]>>;
+    /**
+     * Tests a workflow execution with mock data
+     * @param testRequest - The workflow test request containing workflow definition and mock task outputs
+     * @returns The simulated workflow execution result
+     */
+    testWorkflow(testRequest: WorkflowTestRequest): Promise<Workflow>;
+    /**
+     * Updates workflow variables
+     * @param workflowId - The workflow instance ID
+     * @param variables - The variables to update
+     * @returns The updated workflow
+     */
+    updateVariables(workflowId: string, variables: Record<string, unknown>): Promise<Workflow>;
+    /**
+     * Updates the workflow state (task result + variables) and optionally waits for further execution
+     * @param workflowId - The workflow instance ID
+     * @param updateRequest - The state update request containing task result and/or variables
+     * @param requestId - A unique request ID for idempotency
+     * @param waitUntilTaskRef - Optional task reference name to wait until
+     * @param waitForSeconds - Optional number of seconds to wait
+     * @returns The workflow run status after the update
+     */
+    updateState(workflowId: string, updateRequest: WorkflowStateUpdate, requestId: string, waitUntilTaskRef?: string, waitForSeconds?: number): Promise<WorkflowRun>;
+    /**
+     * Starts a workflow by name with input directly (without a StartWorkflowRequest object)
+     * @param name - The workflow name
+     * @param input - The workflow input data
+     * @param version - Optional workflow version
+     * @param correlationId - Optional correlation ID
+     * @param priority - Optional priority
+     * @returns The workflow instance ID
+     */
+    startWorkflowByName(name: string, input: Record<string, unknown>, version?: number, correlationId?: string, priority?: number): Promise<string>;
+}
+
+/**
+ * Factory class that provides access to all Conductor client instances.
+ * Equivalent to Python SDK's `OrkesClients`.
+ *
+ * Usage:
+ * ```typescript
+ * const clients = await OrkesClients.from({ serverUrl, keyId, keySecret });
+ * const workflowClient = clients.getWorkflowClient();
+ * const metadataClient = clients.getMetadataClient();
+ * ```
+ */
+declare class OrkesClients {
+    private readonly _client;
+    constructor(client: Client);
+    /**
+     * Creates an OrkesClients instance from configuration.
+     * Handles authentication and connection setup.
+     */
+    static from(config?: OrkesApiConfig): Promise<OrkesClients>;
+    /** Returns the underlying HTTP client */
+    getClient(): Client;
+    getWorkflowClient(): WorkflowExecutor;
+    getMetadataClient(): MetadataClient;
+    getTaskClient(): TaskClient;
+    getSchedulerClient(): SchedulerClient;
+    getSecretClient(): SecretClient;
+    getSchemaClient(): SchemaClient;
+    getAuthorizationClient(): AuthorizationClient;
+    getIntegrationClient(): IntegrationClient;
+    getPromptClient(): PromptClient;
+    getApplicationClient(): ApplicationClient;
+    getEventClient(): EventClient;
+    getHumanClient(): HumanExecutor;
+    getTemplateClient(): TemplateClient;
+    getServiceRegistryClient(): ServiceRegistryClient;
+}
+
+/**
+ * Event types for task runner lifecycle events.
+ *
+ * These events provide observability into the worker polling and execution lifecycle,
+ * matching the Python SDK's event system architecture.
+ */
+/**
+ * Base interface for all task runner events.
+ */
+interface TaskRunnerEvent {
+    /** The task definition name */
+    taskType: string;
+    /** UTC timestamp when the event was created */
+    timestamp: Date;
+}
+/**
+ * Event published when task polling begins.
+ */
+interface PollStarted extends TaskRunnerEvent {
+    /** Identifier of the worker polling for tasks */
+    workerId: string;
+    /** Number of tasks requested in this poll */
+    pollCount: number;
+}
+/**
+ * Event published when task polling completes successfully.
+ */
+interface PollCompleted extends TaskRunnerEvent {
+    /** Time taken for the poll operation in milliseconds */
+    durationMs: number;
+    /** Number of tasks received from the poll */
+    tasksReceived: number;
+}
+/**
+ * Event published when task polling fails.
+ */
+interface PollFailure extends TaskRunnerEvent {
+    /** Time taken before the poll failed in milliseconds */
+    durationMs: number;
+    /** The error that caused the failure */
+    cause: Error;
+}
+/**
+ * Event published when task execution begins.
+ */
+interface TaskExecutionStarted extends TaskRunnerEvent {
+    /** Unique identifier of the task instance */
+    taskId: string;
+    /** Identifier of the worker executing the task */
+    workerId: string;
+    /** ID of the workflow instance this task belongs to */
+    workflowInstanceId?: string;
+}
+/**
+ * Event published when task execution completes successfully.
+ */
+interface TaskExecutionCompleted extends TaskRunnerEvent {
+    /** Unique identifier of the task instance */
+    taskId: string;
+    /** Identifier of the worker that executed the task */
+    workerId: string;
+    /** ID of the workflow instance this task belongs to */
+    workflowInstanceId?: string;
+    /** Time taken for task execution in milliseconds */
+    durationMs: number;
+    /** Size of the task output in bytes (if available) */
+    outputSizeBytes?: number;
+}
+/**
+ * Event published when task execution fails.
+ */
+interface TaskExecutionFailure extends TaskRunnerEvent {
+    /** Unique identifier of the task instance */
+    taskId: string;
+    /** Identifier of the worker that attempted execution */
+    workerId: string;
+    /** ID of the workflow instance this task belongs to */
+    workflowInstanceId?: string;
+    /** The error that caused the failure */
+    cause: Error;
+    /** Time taken before failure in milliseconds */
+    durationMs: number;
+}
+/**
+ * Event published when task update fails after all retry attempts.
+ *
+ * This is a CRITICAL event indicating that the worker successfully executed a task
+ * but failed to communicate the result back to Conductor after multiple retries.
+ *
+ * The task result is lost from Conductor's perspective, and external intervention
+ * may be required to reconcile the state.
+ *
+ * Use Cases:
+ * - Alert operations team of critical update failures
+ * - Log failed task results to external storage for recovery
+ * - Implement custom retry logic with different backoff strategies
+ * - Track update reliability metrics
+ * - Trigger incident response workflows
+ */
+interface TaskUpdateFailure extends TaskRunnerEvent {
+    /** Unique identifier of the task instance */
+    taskId: string;
+    /** Identifier of the worker that executed the task */
+    workerId: string;
+    /** ID of the workflow instance this task belongs to */
+    workflowInstanceId?: string;
+    /** The error that caused the final update failure */
+    cause: Error;
+    /** Number of retry attempts made */
+    retryCount: number;
+    /** The TaskResult object that failed to update (for recovery/logging) */
+    taskResult: unknown;
+}
+/**
+ * Event published when task update completes successfully.
+ */
+interface TaskUpdateCompleted extends TaskRunnerEvent {
+    /** Unique identifier of the task instance */
+    taskId: string;
+    /** Identifier of the worker that executed the task */
+    workerId: string;
+    /** ID of the workflow instance this task belongs to */
+    workflowInstanceId?: string;
+    /** Time taken for the update API call in milliseconds */
+    durationMs: number;
+}
+/**
+ * Union type of all task runner events.
+ */
+type TaskRunnerEventType = PollStarted | PollCompleted | PollFailure | TaskExecutionStarted | TaskExecutionCompleted | TaskExecutionFailure | TaskUpdateCompleted | TaskUpdateFailure;
+
+/**
+ * Interface for task runner event listeners.
+ *
+ * All methods are optional - implement only the events you need to handle.
+ * Listener failures are isolated and will not affect task execution.
+ */
+interface TaskRunnerEventsListener {
+    /**
+     * Called when task polling begins.
+     */
+    onPollStarted?(event: PollStarted): void | Promise<void>;
+    /**
+     * Called when task polling completes successfully.
+     */
+    onPollCompleted?(event: PollCompleted): void | Promise<void>;
+    /**
+     * Called when task polling fails.
+     */
+    onPollFailure?(event: PollFailure): void | Promise<void>;
+    /**
+     * Called when task execution begins.
+     */
+    onTaskExecutionStarted?(event: TaskExecutionStarted): void | Promise<void>;
+    /**
+     * Called when task execution completes successfully.
+     */
+    onTaskExecutionCompleted?(event: TaskExecutionCompleted): void | Promise<void>;
+    /**
+     * Called when task execution fails.
+     */
+    onTaskExecutionFailure?(event: TaskExecutionFailure): void | Promise<void>;
+    /**
+     * Called when task update completes successfully.
+     */
+    onTaskUpdateCompleted?(event: TaskUpdateCompleted): void | Promise<void>;
+    /**
+     * Called when task update fails after all retry attempts.
+     * This is a CRITICAL event that may require operational intervention.
+     */
+    onTaskUpdateFailure?(event: TaskUpdateFailure): void | Promise<void>;
+}
+/**
+ * Event dispatcher for task runner events.
+ *
+ * Provides a decoupled event system for observability and metrics collection.
+ * Events are published asynchronously and listener failures are isolated.
+ */
+declare class EventDispatcher {
+    private listeners;
+    private logger?;
+    constructor(logger?: ConductorLogger);
+    /**
+     * Register an event listener.
+     *
+     * @param listener - The listener to register
+     */
+    register(listener: TaskRunnerEventsListener): void;
+    /**
+     * Unregister an event listener.
+     *
+     * @param listener - The listener to unregister
+     */
+    unregister(listener: TaskRunnerEventsListener): void;
+    /**
+     * Publish a PollStarted event.
+     */
+    publishPollStarted(event: PollStarted): Promise<void>;
+    /**
+     * Publish a PollCompleted event.
+     */
+    publishPollCompleted(event: PollCompleted): Promise<void>;
+    /**
+     * Publish a PollFailure event.
+     */
+    publishPollFailure(event: PollFailure): Promise<void>;
+    /**
+     * Publish a TaskExecutionStarted event.
+     */
+    publishTaskExecutionStarted(event: TaskExecutionStarted): Promise<void>;
+    /**
+     * Publish a TaskExecutionCompleted event.
+     */
+    publishTaskExecutionCompleted(event: TaskExecutionCompleted): Promise<void>;
+    /**
+     * Publish a TaskExecutionFailure event.
+     */
+    publishTaskExecutionFailure(event: TaskExecutionFailure): Promise<void>;
+    /**
+     * Publish a TaskUpdateCompleted event.
+     */
+    publishTaskUpdateCompleted(event: TaskUpdateCompleted): Promise<void>;
+    /**
+     * Publish a TaskUpdateFailure event.
+     */
+    publishTaskUpdateFailure(event: TaskUpdateFailure): Promise<void>;
+    /**
+     * Internal method to publish events to all registered listeners.
+     * Listener failures are caught and logged to prevent affecting task execution.
+     */
+    private publishEvent;
+}
+
+type TaskErrorHandler = (error: Error, task?: Task) => void;
+/**
+ * Return type for long-running tasks.
+ *
+ * When a worker returns this, the task is sent to Conductor with IN_PROGRESS status
+ * and Conductor will re-queue the task after `callbackAfterSeconds`.
+ *
+ * @example
+ * ```typescript
+ * @worker({ taskDefName: "long_running_task" })
+ * async function longTask(task: Task): Promise<TaskInProgressResult | TaskResult> {
+ *   if (!isReady()) {
+ *     return { status: "IN_PROGRESS", callbackAfterSeconds: 30, outputData: { progress: 50 } };
+ *   }
+ *   return { status: "COMPLETED", outputData: { result: "done" } };
+ * }
+ * ```
+ */
+interface TaskInProgressResult {
+    status: "IN_PROGRESS";
+    callbackAfterSeconds: number;
+    outputData?: Record<string, unknown>;
+}
+/**
+ * Type guard for TaskInProgressResult.
+ */
+declare function isTaskInProgress(result: unknown): result is TaskInProgressResult;
+interface ConductorWorker {
+    taskDefName: string;
+    execute: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId"> | TaskInProgressResult>;
+    domain?: string;
+    /** Number of polling instances to run concurrently */
+    concurrency?: number;
+    pollInterval?: number;
+}
+interface TaskRunnerOptions {
+    workerID: string;
+    domain: string | undefined;
+    pollInterval?: number;
+    concurrency?: number;
+    batchPollingTimeout?: number;
+}
+interface RunnerArgs {
+    worker: ConductorWorker;
+    client: Client;
+    options: TaskRunnerOptions;
+    logger?: ConductorLogger;
+    onError?: TaskErrorHandler;
+    concurrency?: number;
+    maxRetries?: number;
+    eventListeners?: TaskRunnerEventsListener[];
+}
+interface PollerOptions {
+    pollInterval?: number;
+    concurrency: number;
+    warnAtO?: number;
+    /** Enable adaptive backoff for empty polls (default: true) */
+    adaptiveBackoff?: boolean;
+    /** Whether this poller is paused (default: false) */
+    paused?: boolean;
+}
+/**
+ * Configuration for health monitoring of worker processes.
+ */
+interface HealthMonitorConfig {
+    /** Interval between health checks in ms (default: 5000) */
+    healthCheckIntervalMs?: number;
+    /** Maximum restart attempts, 0 = unlimited (default: 0) */
+    maxRestartAttempts?: number;
+    /** Whether health monitoring is enabled (default: true) */
+    enabled?: boolean;
+}
+type TaskManagerOptions = TaskRunnerOptions;
+interface TaskManagerConfig {
+    logger?: ConductorLogger;
+    options?: Partial<TaskManagerOptions>;
+    onError?: TaskErrorHandler;
+    maxRetries?: number;
+    eventListeners?: TaskRunnerEventsListener[];
+}
+
+/**
+ * Responsible for initializing and managing the runners that poll and work different task queues.
+ */
+declare class TaskManager {
+    private workerRunners;
+    private readonly client;
+    private readonly logger;
+    private readonly errorHandler;
+    private workers;
+    readonly options: Required<TaskManagerOptions>;
+    private polling;
+    private maxRetries;
+    private eventListeners;
+    constructor(client: Client, workers: ConductorWorker[], config?: TaskManagerConfig);
+    private workerManagerWorkerOptions;
+    get isPolling(): boolean;
+    updatePollingOptionForWorker: (workerTaskDefName: string, options: Partial<TaskManagerOptions>) => void;
+    /**
+     * new options will get merged to existing options
+     * @param options new options to update polling options
+     */
+    updatePollingOptions: (options: Partial<TaskManagerOptions>) => void;
+    sanityCheck: () => void;
+    /**
+     * Start polling for tasks
+     */
+    startPolling: () => void;
+    /**
+     * Stops polling for tasks
+     */
+    stopPolling: () => Promise<void>;
+}
+
+/**
+ * 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 {
+    _client: Client;
+    worker: ConductorWorker;
+    private logger;
+    private options;
+    errorHandler: TaskErrorHandler;
+    private poller;
+    private maxRetries;
+    private eventDispatcher;
+    constructor({ worker, client, options, logger, onError: errorHandler, maxRetries, eventListeners, }: RunnerArgs);
+    get isPolling(): boolean;
+    /**
+     * Starts polling for work
+     */
+    startPolling: () => void;
+    /**
+     * Stops Polling for work
+     */
+    stopPolling: () => Promise<void>;
+    updateOptions(options: Partial<TaskRunnerOptions>): void;
+    /** Pause or unpause the worker's polling */
+    setPaused(paused: boolean): void;
+    get isPaused(): boolean;
+    get getOptions(): TaskRunnerOptions;
+    private batchPoll;
+    updateTaskWithRetry: (task: Task, taskResult: TaskResult) => Promise<Task | undefined>;
+    private isValidTask;
+    /**
+     * Entry point for task execution with V2 chaining.
+     *
+     * When updateTaskV2 returns a next task in its response, we immediately
+     * execute it without going back through the poll cycle. This eliminates
+     * one HTTP round-trip + sleep per task when there is a backlog.
+     */
+    private executeTask;
+    /**
+     * Execute a single task and return the next task from V2 response (if any).
+     */
+    private executeOneTask;
+    handleUnknownError: (unknownError: unknown) => void;
+}
+
+declare class Poller<T> {
+    private timeoutHandler?;
+    private pollFunction;
+    private performWorkFunction;
+    private polling;
+    private _tasksInProcess;
+    private _counterAtO;
+    private _pollerId;
+    private _consecutiveEmptyPolls;
+    private _lastPollTime;
+    private _authFailures;
+    private _lastAuthFailureAt;
+    options: PollerOptions;
+    logger: ConductorLogger;
+    constructor(pollerId: string, pollFunction: (count: number) => Promise<T[] | undefined>, performWorkFunction: (work: T) => Promise<void>, pollerOptions?: Partial<PollerOptions>, logger?: ConductorLogger);
+    get isPolling(): boolean;
+    get tasksInProcess(): number;
+    get consecutiveEmptyPolls(): number;
+    get authFailures(): number;
+    /**
+     * Starts polling for work
+     */
+    startPolling: () => void;
+    /**
+     * Stops Polling for work
+     */
+    stopPolling: () => Promise<void>;
+    private performWork;
+    updateOptions(options: Partial<PollerOptions>): void;
+    /**
+     * Detect if an error is an authentication/authorization failure.
+     */
+    private isAuthError;
+    /**
+     * Calculate adaptive backoff delay for empty polls.
+     *
+     * Matches Python SDK: min(BASE_MS * 2^min(count, MAX_EXPONENT), pollInterval)
+     * Sequence: 1ms, 2ms, 4ms, 8ms, 16ms, ... 1024ms, then capped at pollInterval
+     */
+    private calculateAdaptiveDelay;
+    /**
+     * Calculate auth failure backoff delay in milliseconds.
+     *
+     * Matches Python SDK: min(2^failures, 60) seconds
+     */
+    private calculateAuthBackoffMs;
+    /** Promise-based sleep that resolves immediately if polling has stopped */
+    private sleep;
+    private poll;
+}
+
+/**
+ * Custom exception types for worker error handling.
+ */
+/**
+ * Exception indicating a non-retryable task failure.
+ *
+ * When thrown from a worker's execute function, the task will be marked as
+ * FAILED_WITH_TERMINAL_ERROR and will NOT be retried, regardless of the
+ * task definition's retry_count setting.
+ *
+ * Use this for permanent failures where retry would produce the same result:
+ * - Business validation failures (invalid data format)
+ * - Authorization failures (user lacks permission)
+ * - Resource not found (entity doesn't exist)
+ * - Configuration errors (missing required config)
+ * - Data integrity violations (constraint violations)
+ * - Unsupported operations (feature not available)
+ *
+ * @example
+ * ```typescript
+ * async function validateOrder(task: Task) {
+ *   const order = await getOrder(task.inputData.orderId);
+ *
+ *   if (!order) {
+ *     // Order doesn't exist - retry won't help
+ *     throw new NonRetryableException(`Order ${task.inputData.orderId} not found`);
+ *   }
+ *
+ *   if (order.status === 'CANCELLED') {
+ *     // Business rule - retry won't help
+ *     throw new NonRetryableException('Cannot process cancelled order');
+ *   }
+ *
+ *   return { status: 'COMPLETED', outputData: { validated: true } };
+ * }
+ * ```
+ */
+declare class NonRetryableException extends Error {
+    constructor(message: string);
 }
 
 declare const doWhileTask: (taskRefName: string, terminationCondition: string, tasks: TaskDefTypes[], optional?: boolean) => DoWhileTaskDef;
 declare const newLoopTask: (taskRefName: string, iterations: number, tasks: TaskDefTypes[], optional?: boolean) => DoWhileTaskDef;
 
+declare const dynamicTask: (taskReferenceName: string, dynamicTaskName: string, dynamicTaskParam?: string, optional?: boolean) => WorkflowTask;
+
 declare const dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string, optional?: boolean) => ForkJoinDynamicDef;
 
 declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string, optional?: boolean) => EventTaskDef;
@@ -4138,8 +5412,40 @@ declare const conductorEventTask: (taskReferenceName: string, eventName: string,
 declare const forkTask: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => ForkJoinTaskDef;
 declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[], optional?: boolean) => [ForkJoinTaskDef, JoinTaskDef];
 
+interface GetDocumentOptions {
+    /** Media type of the document (e.g. "application/pdf") */
+    mediaType?: string;
+    optional?: boolean;
+}
+declare const getDocumentTask: (taskReferenceName: string, url: string, options?: GetDocumentOptions) => WorkflowTask;
+
 declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters, asyncComplete?: boolean, optional?: boolean) => HttpTaskDef;
 
+interface HttpPollInputParameters {
+    http_request: HttpInputParameters;
+    /** Polling interval in seconds */
+    pollingInterval?: number;
+    /** Polling strategy: FIXED or LINEAR_BACKOFF */
+    pollingStrategy?: "FIXED" | "LINEAR_BACKOFF";
+    /** Condition expression to terminate polling (e.g. "$.status === 'COMPLETED'") */
+    terminationCondition?: string;
+}
+declare const httpPollTask: (taskReferenceName: string, inputParameters: HttpPollInputParameters, optional?: boolean) => WorkflowTask;
+
+type AssignmentCompletionStrategy = "LEAVE_OPEN" | "TERMINATE";
+interface HumanTaskOptions {
+    displayName?: string;
+    formTemplate?: string;
+    formVersion?: number;
+    assignmentCompletionStrategy?: AssignmentCompletionStrategy;
+    assignee?: {
+        userType: "EXTERNAL_USER" | "EXTERNAL_GROUP";
+        user: string;
+    };
+    optional?: boolean;
+}
+declare const humanTask: (taskReferenceName: string, options?: HumanTaskOptions) => WorkflowTask;
+
 declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs", optional?: boolean) => InlineTaskDef;
 
 declare const joinTask: (taskReferenceName: string, joinOn: string[], optional?: boolean) => JoinTaskDef;
@@ -4152,6 +5458,8 @@ declare const setVariableTask: (taskReferenceName: string, inputParameters: Reco
 
 declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>, optional?: boolean) => SimpleTaskDef;
 
+declare const startWorkflowTask: (taskReferenceName: string, workflowName: string, input?: Record<string, unknown>, version?: number, correlationId?: string, optional?: boolean) => WorkflowTask;
+
 declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number, optional?: boolean) => SubWorkflowTaskDef;
 
 declare const switchTask: (taskReferenceName: string, expression: string, decisionCases?: Record<string, TaskDefTypes[]>, defaultCase?: TaskDefTypes[], optional?: boolean) => SwitchTaskDef;
@@ -4161,10 +5469,338 @@ declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "
 declare const waitTaskDuration: (taskReferenceName: string, duration: string, optional?: boolean) => WaitTaskDef;
 declare const waitTaskUntil: (taskReferenceName: string, until: string, optional?: boolean) => WaitTaskDef;
 
+interface WaitForWebhookOptions {
+    /** Match conditions for incoming webhook (key-value pairs) */
+    matches?: Record<string, unknown>;
+    optional?: boolean;
+}
+declare const waitForWebhookTask: (taskReferenceName: string, options?: WaitForWebhookOptions) => WorkflowTask;
+
+declare enum Role {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system",
+    TOOL_CALL = "tool_call",
+    TOOL = "tool"
+}
+/** LLM provider identifiers matching the Python SDK's LLMProvider enum. */
+declare enum LLMProvider {
+    OPEN_AI = "openai",
+    AZURE_OPEN_AI = "azure_openai",
+    VERTEX_AI = "vertex_ai",
+    HUGGING_FACE = "huggingface",
+    ANTHROPIC = "anthropic",
+    BEDROCK = "bedrock",
+    COHERE = "cohere",
+    GROK = "Grok",
+    MISTRAL = "mistral",
+    OLLAMA = "ollama",
+    PERPLEXITY = "perplexity"
+}
+/** Vector database identifiers matching the Python SDK's VectorDB enum. */
+declare enum VectorDB {
+    PINECONE_DB = "pineconedb",
+    WEAVIATE_DB = "weaviatedb",
+    POSTGRES_VECTOR_DB = "pgvectordb",
+    MONGO_VECTOR_DB = "mongovectordb"
+}
+interface ToolCall {
+    name: string;
+    taskReferenceName?: string;
+    type?: string;
+    inputParameters?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+}
+interface ChatMessage {
+    role: Role;
+    message: string;
+    media?: string[];
+    mimeType?: string;
+    toolCalls?: ToolCall[];
+}
+interface ToolSpec {
+    name: string;
+    type?: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+}
+interface EmbeddingModel {
+    provider: string;
+    model: string;
+}
+interface LlmCompletionParams {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxTokens?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    stopWords?: string[];
+    maxResults?: number;
+}
+/** Base configuration for AI integrations. */
+interface IntegrationConfig {
+    provider: string;
+    description?: string;
+    [key: string]: unknown;
+}
+/** OpenAI integration configuration. */
+interface OpenAIConfig extends IntegrationConfig {
+    provider: "openai";
+    apiKey: string;
+    organizationId?: string;
+}
+/** Azure OpenAI integration configuration. */
+interface AzureOpenAIConfig extends IntegrationConfig {
+    provider: "azure_openai";
+    apiKey: string;
+    endpoint: string;
+    deploymentName?: string;
+}
+/** Weaviate vector database configuration. */
+interface WeaviateConfig extends IntegrationConfig {
+    provider: "weaviatedb";
+    apiKey: string;
+    endpoint: string;
+}
+/** Pinecone vector database configuration. */
+interface PineconeConfig extends IntegrationConfig {
+    provider: "pineconedb";
+    apiKey: string;
+    environment?: string;
+    projectName?: string;
+}
+
+interface LlmChatCompleteOptions extends LlmCompletionParams {
+    messages?: ChatMessage[];
+    instructionsTemplate?: string;
+    promptVariables?: Record<string, unknown>;
+    promptVersion?: number;
+    userInput?: string;
+    tools?: ToolSpec[];
+    jsonOutput?: boolean;
+    outputSchema?: Record<string, unknown>;
+    outputMimeType?: string;
+    outputLocation?: string;
+    googleSearchRetrieval?: boolean;
+    inputSchema?: Record<string, unknown>;
+    thinkingTokenLimit?: number;
+    reasoningEffort?: string;
+    voice?: string;
+    participants?: string[];
+}
+declare const llmChatCompleteTask: (taskReferenceName: string, provider: string, model: string, options?: LlmChatCompleteOptions) => WorkflowTask;
+
+interface LlmTextCompleteOptions extends LlmCompletionParams {
+    promptVariables?: Record<string, unknown>;
+    promptVersion?: number;
+    jsonOutput?: boolean;
+}
+declare const llmTextCompleteTask: (taskReferenceName: string, provider: string, model: string, promptName: string, options?: LlmTextCompleteOptions) => WorkflowTask;
+
+interface LlmGenerateEmbeddingsOptions {
+    instructions?: string;
+    dimensions?: number;
+}
+declare const llmGenerateEmbeddingsTask: (taskReferenceName: string, provider: string, model: string, text: string, options?: LlmGenerateEmbeddingsOptions) => WorkflowTask;
+
+interface LlmIndexTextOptions {
+    namespace?: string;
+    metadata?: Record<string, unknown>;
+    url?: string;
+    chunkSize?: number;
+    chunkOverlap?: number;
+    dimensions?: number;
+}
+declare const llmIndexTextTask: (taskReferenceName: string, vectorDb: string, index: string, embeddingModel: EmbeddingModel, text: string, docId: string, options?: LlmIndexTextOptions) => WorkflowTask;
+
+interface LlmIndexDocumentOptions {
+    namespace?: string;
+    chunkSize?: number;
+    chunkOverlap?: number;
+    docId?: string;
+    metadata?: Record<string, unknown>;
+    dimensions?: number;
+}
+declare const llmIndexDocumentTask: (taskReferenceName: string, vectorDb: string, index: string, embeddingModel: EmbeddingModel, url: string, mediaType: string, options?: LlmIndexDocumentOptions) => WorkflowTask;
+
+interface LlmSearchIndexOptions {
+    namespace?: string;
+    maxResults?: number;
+    dimensions?: number;
+}
+declare const llmSearchIndexTask: (taskReferenceName: string, vectorDb: string, index: string, embeddingModel: EmbeddingModel, query: string, options?: LlmSearchIndexOptions) => WorkflowTask;
+
+interface LlmSearchEmbeddingsOptions {
+    namespace?: string;
+    maxResults?: number;
+}
+declare const llmSearchEmbeddingsTask: (taskReferenceName: string, vectorDb: string, index: string, embeddings: number[], options?: LlmSearchEmbeddingsOptions) => WorkflowTask;
+
+interface LlmStoreEmbeddingsOptions {
+    namespace?: string;
+    docId?: string;
+    metadata?: Record<string, unknown>;
+}
+declare const llmStoreEmbeddingsTask: (taskReferenceName: string, vectorDb: string, index: string, embeddings: number[], options?: LlmStoreEmbeddingsOptions) => WorkflowTask;
+
+interface LlmQueryEmbeddingsOptions {
+    namespace?: string;
+}
+declare const llmQueryEmbeddingsTask: (taskReferenceName: string, vectorDb: string, index: string, embeddings: number[], options?: LlmQueryEmbeddingsOptions) => WorkflowTask;
+
+interface GenerateImageOptions {
+    imageCount?: number;
+    width?: number;
+    height?: number;
+}
+declare const generateImageTask: (taskReferenceName: string, provider: string, model: string, prompt: string, options?: GenerateImageOptions) => WorkflowTask;
+
+interface GenerateAudioOptions {
+    text?: string;
+    voice?: string;
+    speed?: number;
+}
+declare const generateAudioTask: (taskReferenceName: string, provider: string, model: string, options?: GenerateAudioOptions) => WorkflowTask;
+
+interface CallMcpToolOptions {
+    inputParameters?: Record<string, unknown>;
+}
+declare const callMcpToolTask: (taskReferenceName: string, mcpServer: string, method: string, options?: CallMcpToolOptions) => WorkflowTask;
+
+interface ListMcpToolsOptions {
+    filter?: string;
+}
+declare const listMcpToolsTask: (taskReferenceName: string, mcpServer: string, options?: ListMcpToolsOptions) => WorkflowTask;
+
+/**
+ * Set a single prompt variable on an LLM task.
+ * Returns a new task with the variable applied to inputParameters.promptVariables.
+ *
+ * @example
+ * ```typescript
+ * const task = withPromptVariable(
+ *   llmChatCompleteTask("ref", "openai", "gpt-4"),
+ *   "context",
+ *   "${workflow.input.context}"
+ * );
+ * ```
+ */
+declare const withPromptVariable: (task: WorkflowTask, variable: string, value: unknown) => WorkflowTask;
+/**
+ * Set multiple prompt variables on an LLM task at once.
+ * Returns a new task with all variables merged into inputParameters.promptVariables.
+ *
+ * @example
+ * ```typescript
+ * const task = withPromptVariables(
+ *   llmTextCompleteTask("ref", "openai", "gpt-4", "my_prompt"),
+ *   {
+ *     context: "${workflow.input.context}",
+ *     query: "${workflow.input.query}",
+ *   }
+ * );
+ * ```
+ */
+declare const withPromptVariables: (task: WorkflowTask, variables: Record<string, unknown>) => WorkflowTask;
+
 declare const workflow: (name: string, tasks: TaskDefTypes[]) => WorkflowDef;
 
 declare const taskDefinition: ({ name, ownerApp, description, retryCount, timeoutSeconds, inputKeys, outputKeys, timeoutPolicy, retryLogic, retryDelaySeconds, responseTimeoutSeconds, concurrentExecLimit, inputTemplate, rateLimitPerFrequency, rateLimitFrequencyInSeconds, ownerEmail, pollTimeoutSeconds, backoffScaleFactor, }: ExtendedTaskDef) => TaskDef;
 
+/**
+ * Fluent workflow builder matching the Python SDK's ConductorWorkflow pattern.
+ *
+ * Provides method chaining for building, configuring, registering, and
+ * executing workflows.
+ *
+ * @example
+ * ```typescript
+ * const wf = new ConductorWorkflow(executor, "order_flow")
+ *   .add(simpleTask("validate_ref", "validate_order", {}))
+ *   .add(simpleTask("charge_ref", "charge_payment", {}))
+ *   .add(simpleTask("confirm_ref", "send_confirmation", {}))
+ *   .timeoutSeconds(3600)
+ *   .outputParameters({ orderId: "${workflow.input.orderId}" });
+ *
+ * await wf.register(true);
+ * const run = await wf.execute({ orderId: "123" });
+ * ```
+ */
+declare class ConductorWorkflow {
+    private readonly _executor;
+    private readonly _name;
+    private _version;
+    private _description?;
+    private _tasks;
+    private _timeoutPolicy?;
+    private _timeoutSeconds;
+    private _ownerEmail?;
+    private _failureWorkflow;
+    private _restartable;
+    private _inputParameters;
+    private _inputTemplate;
+    private _outputParameters;
+    private _variables;
+    private _workflowStatusListenerEnabled;
+    private _workflowStatusListenerSink?;
+    private _forkCounter;
+    constructor(executor: WorkflowExecutor, name: string, version?: number, description?: string);
+    /** Get the workflow name */
+    getName(): string;
+    /** Get the workflow version */
+    getVersion(): number;
+    /** Append one or more tasks sequentially */
+    add(task: WorkflowTask | WorkflowTask[]): this;
+    /** Add parallel fork branches with an auto-generated join */
+    fork(branches: WorkflowTask[][]): this;
+    /**
+     * Convert this workflow into a SUB_WORKFLOW task with the full definition
+     * embedded inline, matching Python SDK's `InlineSubWorkflowTask`.
+     *
+     * This allows composing workflows without pre-registering the child workflow.
+     *
+     * @param taskReferenceName - Reference name for the sub-workflow task
+     */
+    toSubWorkflowTask(taskReferenceName: string): WorkflowTask;
+    description(desc: string): this;
+    version(v: number): this;
+    timeoutPolicy(policy: "TIME_OUT_WF" | "ALERT_ONLY"): this;
+    timeoutSeconds(n: number): this;
+    ownerEmail(email: string): this;
+    failureWorkflow(name: string): this;
+    restartable(val: boolean): this;
+    /** Set the list of input parameter names */
+    inputParameters(params: string[]): this;
+    /** Set the input template (default values/expressions for inputs) */
+    inputTemplate(template: Record<string, unknown>): this;
+    /** Alias for inputTemplate — set workflow input defaults */
+    workflowInput(input: Record<string, unknown>): this;
+    /** Set all output parameters at once */
+    outputParameters(params: Record<string, unknown>): this;
+    /** Set a single output parameter */
+    outputParameter(key: string, value: unknown): this;
+    /** Set workflow variables */
+    variables(vars: Record<string, unknown>): this;
+    /** Enable workflow status listener with a sink name */
+    enableStatusListener(sinkName: string): this;
+    /** Disable workflow status listener */
+    disableStatusListener(): this;
+    /** Returns a workflow input reference expression */
+    input(jsonPath: string): string;
+    /** Returns a workflow output reference expression */
+    output(jsonPath?: string): string;
+    /** Convert to a WorkflowDef object */
+    toWorkflowDef(): WorkflowDef;
+    /** Register this workflow with the Conductor server */
+    register(overwrite?: boolean): Promise<void>;
+    /** Execute the workflow synchronously and wait for result */
+    execute(input?: Record<string, unknown>, waitUntilTaskRef?: string, requestId?: string, idempotencyKey?: string, idempotencyStrategy?: "FAIL" | "RETURN_EXISTING" | "FAIL_ON_RUNNING", taskToDomain?: Record<string, string>): Promise<WorkflowRun>;
+    /** Start the workflow asynchronously (returns workflow ID) */
+    startWorkflow(input?: Record<string, unknown>, correlationId?: string, priority?: number, idempotencyKey?: string, idempotencyStrategy?: "FAIL" | "RETURN_EXISTING" | "FAIL_ON_RUNNING", taskToDomain?: Record<string, string>): Promise<string>;
+}
+
 /**
  * Takes an optional partial SimpleTaskDef
  * generates a task replacing default values with provided overrides
@@ -4320,10 +5956,817 @@ declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nest
  */
 declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
 
+/**
+ * Configuration for TaskHandler.
+ */
+interface TaskHandlerConfig {
+    /**
+     * Conductor client instance.
+     * Required for communicating with Conductor server.
+     */
+    client: Client;
+    /**
+     * Additional workers to register manually.
+     * These will be added alongside auto-discovered decorated workers.
+     * Default: []
+     */
+    workers?: ConductorWorker[];
+    /**
+     * Whether to scan for @worker decorated functions.
+     * When true, automatically discovers all workers registered via @worker decorator.
+     * Default: true
+     */
+    scanForDecorated?: boolean;
+    /**
+     * Modules to import for side-effect registration.
+     * Importing these modules will trigger @worker decorator execution.
+     * Useful when workers are defined in separate files.
+     *
+     * Example: ['./workers/orderWorkers', './workers/paymentWorkers']
+     * Default: []
+     */
+    importModules?: string[];
+    /**
+     * Event listeners for worker lifecycle events.
+     * Default: []
+     */
+    eventListeners?: TaskRunnerEventsListener[];
+    /**
+     * Logger instance for TaskHandler.
+     * Default: DefaultLogger
+     */
+    logger?: ConductorLogger;
+    /**
+     * Health monitoring configuration.
+     * Monitors worker polling loops and auto-restarts on failure.
+     * Default: { enabled: true }
+     */
+    healthMonitor?: HealthMonitorConfig;
+}
+/**
+ * TaskHandler orchestrates worker lifecycle and auto-discovery.
+ *
+ * This is the main entry point for the SDK-style worker framework,
+ * matching the Python SDK's TaskHandler architecture.
+ *
+ * Features:
+ * - Auto-discovers workers decorated with @worker
+ * - Manages worker lifecycle (start/stop)
+ * - Supports both decorated and manual worker registration
+ * - Module import for side-effect registration
+ * - Event listener support
+ * - Health monitoring with auto-restart
+ * - Automatic task definition registration
+ * - Environment variable configuration override
+ *
+ * @example
+ * Basic usage with auto-discovery:
+ * ```typescript
+ * const handler = new TaskHandler({
+ *   client: conductorClient,
+ *   scanForDecorated: true,
+ * });
+ *
+ * await handler.startWorkers();
+ *
+ * // Later...
+ * await handler.stopWorkers();
+ * ```
+ *
+ * @example
+ * With event listeners and health monitoring:
+ * ```typescript
+ * const handler = new TaskHandler({
+ *   client: conductorClient,
+ *   eventListeners: [metricsCollector],
+ *   healthMonitor: {
+ *     enabled: true,
+ *     healthCheckIntervalMs: 5000,
+ *     maxRestartAttempts: 10,
+ *   },
+ * });
+ *
+ * await handler.startWorkers();
+ * handler.printSummary();
+ * ```
+ */
+declare class TaskHandler {
+    private client;
+    private resolvedWorkers;
+    private taskRunners;
+    private config;
+    private logger;
+    private isRunning;
+    private healthCheckTimer?;
+    private restartAttempts;
+    private healthMonitorConfig;
+    /**
+     * Create a TaskHandler instance with async module imports.
+     * Use this instead of `new TaskHandler()` when using `importModules`.
+     */
+    static create(config: TaskHandlerConfig): Promise<TaskHandler>;
+    constructor(config: TaskHandlerConfig);
+    /**
+     * Start all registered workers.
+     *
+     * Registers task definitions (if configured), creates a TaskRunner for each
+     * worker, and begins polling for tasks.
+     * This method is idempotent - calling it multiple times has no effect.
+     */
+    startWorkers(): Promise<void>;
+    /**
+     * Stop all running workers gracefully.
+     *
+     * Stops polling and waits for in-flight tasks to complete.
+     * This method is idempotent - calling it multiple times has no effect.
+     */
+    stopWorkers(): Promise<void>;
+    /**
+     * Register task definitions for workers that have registerTaskDef=true.
+     * Called automatically by startWorkers() before polling begins.
+     *
+     * Matches Python SDK behavior:
+     * - If overwriteTaskDef=true: PUT /api/metadata/taskdefs (create or update)
+     * - If overwriteTaskDef=false: GET first, then POST only if not found
+     * - Uses taskDef template if provided, otherwise creates minimal definition
+     */
+    private registerTaskDefinitions;
+    private startHealthMonitor;
+    private stopHealthMonitor;
+    private checkWorkerHealth;
+    /**
+     * Print a summary of all registered workers and their configurations.
+     * Matches Python SDK's print_summary() function.
+     */
+    printSummary(): void;
+    /**
+     * Check if all workers are healthy (all polling).
+     * Returns false if any worker has stopped unexpectedly.
+     */
+    isHealthy(): boolean;
+    /**
+     * Get detailed status of each worker.
+     * Matches Python SDK's get_worker_process_status().
+     */
+    getWorkerStatus(): {
+        taskDefName: string;
+        domain?: string;
+        polling: boolean;
+        paused: boolean;
+        workerId: string;
+        restartCount: number;
+    }[];
+    /** Get the number of registered workers. */
+    get workerCount(): number;
+    /** Get the number of running workers. */
+    get runningWorkerCount(): number;
+    /** Check if workers are currently running. */
+    get running(): boolean;
+    /**
+     * Context manager support (for TypeScript 5.2+ using keyword).
+     * Automatically stops workers when disposed.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+/**
+ * Options for the @worker decorator.
+ */
+interface WorkerOptions {
+    /**
+     * Task definition name (must match workflow task name).
+     * This is the only required parameter.
+     */
+    taskDefName: string;
+    /**
+     * Maximum concurrent tasks this worker can execute.
+     * - Default: 1
+     * - Controls concurrency level for task execution
+     * - Choose based on workload:
+     *   * CPU-bound: 1-4
+     *   * I/O-bound: 10-50
+     *   * Mixed: 5-20
+     */
+    concurrency?: number;
+    /**
+     * Polling interval in milliseconds.
+     * - Default: 100ms
+     * - Lower values = more responsive but higher server load
+     * - Higher values = less server load but slower task pickup
+     * - Recommended: 100-500ms for most use cases
+     */
+    pollInterval?: number;
+    /**
+     * Task domain for multi-tenancy.
+     * - Default: undefined (no domain isolation)
+     * - Use when you need to partition tasks across different environments/tenants
+     */
+    domain?: string;
+    /**
+     * Unique worker identifier.
+     * - Default: undefined (auto-generated)
+     * - Useful for debugging and tracking which worker executed which task
+     */
+    workerId?: string;
+    /**
+     * Auto-register task definition on startup.
+     * - Default: false
+     * - When true: Task definition is created/updated on worker startup
+     * - When false: Task definition must exist in Conductor already
+     * - Recommended: false for production (manage task definitions separately)
+     */
+    registerTaskDef?: boolean;
+    /**
+     * Server-side long poll timeout in milliseconds.
+     * - Default: 100ms
+     * - How long the server will wait for a task before returning empty response
+     * - Higher values reduce polling frequency when no tasks available
+     * - Recommended: 100-500ms
+     */
+    pollTimeout?: number;
+    /**
+     * Task definition template for registration.
+     * - Default: undefined
+     * - Only used when registerTaskDef=true
+     * - Allows specifying retry policies, timeouts, rate limits, etc.
+     * - The taskDefName parameter takes precedence for the name field
+     */
+    taskDef?: TaskDef;
+    /**
+     * Overwrite existing task definitions on server.
+     * - Default: true
+     * - When true: Always updates task definition
+     * - When false: Only creates if doesn't exist
+     * - Can be overridden via env: CONDUCTOR_WORKER_<NAME>_OVERWRITE_TASK_DEF=false
+     */
+    overwriteTaskDef?: boolean;
+    /**
+     * Enforce strict JSON schema validation.
+     * - Default: false
+     * - When false: additionalProperties=true (allows extra fields)
+     * - When true: additionalProperties=false (strict validation)
+     * - Can be overridden via env: CONDUCTOR_WORKER_<NAME>_STRICT_SCHEMA=true
+     */
+    strictSchema?: boolean;
+    /**
+     * JSON Schema for task input validation.
+     * - Registered alongside the task definition when registerTaskDef=true
+     * - Use the `jsonSchema()` helper to generate from field descriptors
+     */
+    inputSchema?: Record<string, unknown>;
+    /**
+     * JSON Schema for task output validation.
+     * - Registered alongside the task definition when registerTaskDef=true
+     * - Use the `jsonSchema()` helper to generate from field descriptors
+     */
+    outputSchema?: Record<string, unknown>;
+    /**
+     * Class decorated with `@schemaField()` for auto-generating input schema.
+     * - Alternative to `inputSchema` — schema is generated from class metadata
+     * - Takes precedence over `inputSchema` if both are set
+     */
+    inputType?: new (...args: any[]) => unknown;
+    /**
+     * Class decorated with `@schemaField()` for auto-generating output schema.
+     * - Alternative to `outputSchema` — schema is generated from class metadata
+     * - Takes precedence over `outputSchema` if both are set
+     */
+    outputType?: new (...args: any[]) => unknown;
+}
+/**
+ * Decorator to register a function as a Conductor worker.
+ *
+ * This decorator enables SDK-style worker registration with auto-discovery,
+ * matching the Python SDK's @worker_task pattern.
+ *
+ * @param options - Worker configuration options
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * @worker({ taskDefName: "process_order" })
+ * async function processOrder(task: Task): Promise<TaskResult> {
+ *   const orderId = task.inputData.orderId;
+ *   // Process order logic
+ *   return {
+ *     status: "COMPLETED",
+ *     outputData: { orderId, processed: true },
+ *   };
+ * }
+ * ```
+ *
+ * @example
+ * With concurrency:
+ * ```typescript
+ * @worker({ taskDefName: "send_email", concurrency: 10 })
+ * async function sendEmail(task: Task): Promise<TaskResult> {
+ *   const { to, subject, body } = task.inputData;
+ *   await emailService.send(to, subject, body);
+ *   return { status: "COMPLETED", outputData: { sent: true } };
+ * }
+ * ```
+ *
+ * @example
+ * With domain and custom polling:
+ * ```typescript
+ * @worker({
+ *   taskDefName: "validate_payment",
+ *   domain: "payments",
+ *   concurrency: 5,
+ *   pollInterval: 200,
+ * })
+ * async function validatePayment(task: Task): Promise<TaskResult> {
+ *   // Validation logic
+ *   return { status: "COMPLETED", outputData: { valid: true } };
+ * }
+ * ```
+ *
+ * @example
+ * With task definition registration:
+ * ```typescript
+ * @worker({
+ *   taskDefName: "complex_task",
+ *   registerTaskDef: true,
+ *   taskDef: {
+ *     retryCount: 3,
+ *     retryLogic: "EXPONENTIAL_BACKOFF",
+ *     timeoutSeconds: 300,
+ *   },
+ * })
+ * async function complexTask(task: Task): Promise<TaskResult> {
+ *   // Complex logic
+ *   return { status: "COMPLETED", outputData: { result: "..." } };
+ * }
+ * ```
+ *
+ * @example
+ * Non-retryable errors:
+ * ```typescript
+ * import { worker, NonRetryableException } from "@io-orkes/conductor-javascript/worker";
+ *
+ * @worker({ taskDefName: "validate_order" })
+ * async function validateOrder(task: Task): Promise<TaskResult> {
+ *   const order = await getOrder(task.inputData.orderId);
+ *
+ *   if (!order) {
+ *     // Order doesn't exist - retry won't help
+ *     throw new NonRetryableException(`Order ${task.inputData.orderId} not found`);
+ *   }
+ *
+ *   return { status: "COMPLETED", outputData: { validated: true } };
+ * }
+ * ```
+ */
+declare function worker(options: WorkerOptions): (target: unknown, propertyKey?: string, descriptor?: PropertyDescriptor) => PropertyDescriptor | ((this: unknown, ...args: unknown[]) => unknown);
+
+/**
+ * Registered worker metadata stored in the global registry.
+ */
+interface RegisteredWorker {
+    /** Task definition name (must match workflow task name) */
+    taskDefName: string;
+    /** Worker execution function */
+    executeFunction: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId">>;
+    /** Maximum concurrent tasks (default: 1) */
+    concurrency?: number;
+    /** Polling interval in milliseconds (default: 100) */
+    pollInterval?: number;
+    /** Task domain for multi-tenancy (default: undefined) */
+    domain?: string;
+    /** Unique worker identifier (default: auto-generated) */
+    workerId?: string;
+    /** Auto-register task definition on startup (default: false) */
+    registerTaskDef?: boolean;
+    /** Server-side long poll timeout in milliseconds (default: 100) */
+    pollTimeout?: number;
+    /** Task definition template for registration (optional) */
+    taskDef?: TaskDef;
+    /** Overwrite existing task definitions (default: true) */
+    overwriteTaskDef?: boolean;
+    /** Enforce strict JSON schema validation (default: false) */
+    strictSchema?: boolean;
+    /** JSON Schema for task input validation (registered alongside task def) */
+    inputSchema?: Record<string, unknown>;
+    /** JSON Schema for task output validation (registered alongside task def) */
+    outputSchema?: Record<string, unknown>;
+    /** Whether this worker should start in paused state (default: false) */
+    paused?: boolean;
+}
+/**
+ * Get all registered workers from the global registry.
+ * Used by TaskHandler for auto-discovery.
+ *
+ * @returns Array of all registered workers
+ */
+declare function getRegisteredWorkers(): RegisteredWorker[];
+/**
+ * Get a specific registered worker.
+ *
+ * @param taskDefName - Task definition name
+ * @param domain - Optional domain
+ * @returns Registered worker or undefined
+ */
+declare function getRegisteredWorker(taskDefName: string, domain?: string): RegisteredWorker | undefined;
+/**
+ * Clear all registered workers.
+ * Primarily for testing purposes.
+ */
+declare function clearWorkerRegistry(): void;
+/**
+ * Get the number of registered workers.
+ */
+declare function getWorkerCount(): number;
+
+/**
+ * TaskContext provides async-local context during task execution.
+ *
+ * This is the JavaScript equivalent of Python's contextvars-based
+ * `get_task_context()`. Each task execution runs in its own async context,
+ * so `getTaskContext()` returns the context for the currently executing task.
+ *
+ * @example
+ * ```typescript
+ * @worker({ taskDefName: "my_task" })
+ * async function myTask(task: Task) {
+ *   const ctx = getTaskContext();
+ *   ctx?.addLog("Starting processing");
+ *
+ *   if (needsMoreTime) {
+ *     ctx?.setCallbackAfter(30);
+ *     return { status: "IN_PROGRESS", callbackAfterSeconds: 30 };
+ *   }
+ *
+ *   return { status: "COMPLETED", outputData: { result: "done" } };
+ * }
+ * ```
+ */
+declare class TaskContext {
+    private _task;
+    private _logs;
+    private _callbackAfterSeconds?;
+    private _output?;
+    constructor(task: Task);
+    /** Get the task ID */
+    getTaskId(): string | undefined;
+    /** Get the workflow instance ID */
+    getWorkflowInstanceId(): string | undefined;
+    /** Get the retry count for this task (0 for first attempt) */
+    getRetryCount(): number;
+    /** Get the poll count for this task */
+    getPollCount(): number;
+    /** Get the full task input data */
+    getInput(): Record<string, unknown>;
+    /** Get the task definition name */
+    getTaskDefName(): string | undefined;
+    /** Get the workflow task type (e.g., SIMPLE, HTTP, SUB_WORKFLOW) */
+    getWorkflowTaskType(): string | undefined;
+    /** Get the full task object */
+    getTask(): Task;
+    /**
+     * Add an execution log entry.
+     * Logs are merged into the task result when execution completes.
+     */
+    addLog(message: string): void;
+    /** Get all accumulated logs */
+    getLogs(): TaskExecLog[];
+    /**
+     * Set callback-after seconds.
+     * Tells Conductor to re-queue the task after the specified number of seconds.
+     */
+    setCallbackAfter(seconds: number): void;
+    /** Get the callback-after value (if set) */
+    getCallbackAfterSeconds(): number | undefined;
+    /**
+     * Set intermediate output data.
+     * Merged into the final task result.
+     */
+    setOutput(data: Record<string, unknown>): void;
+    /** Get intermediate output data (if set) */
+    getOutput(): Record<string, unknown> | undefined;
+}
+/**
+ * Get the current task context.
+ *
+ * Must be called from within a task execution callback.
+ * Returns `undefined` if called outside of a task execution.
+ */
+declare function getTaskContext(): TaskContext | undefined;
+
+/**
+ * Configuration for MetricsCollector.
+ */
+interface MetricsCollectorConfig {
+    /** Prometheus metric name prefix (default: "conductor_worker") */
+    prefix?: string;
+    /** If set, auto-starts MetricsServer on this port */
+    httpPort?: number;
+    /** If set, periodically writes Prometheus metrics to this file path */
+    filePath?: string;
+    /** File write interval in milliseconds (default: 5000) */
+    fileWriteIntervalMs?: number;
+    /** Sliding window size for quantile calculations (default: 1000) */
+    slidingWindowSize?: number;
+    /**
+     * Use prom-client for native Prometheus integration.
+     * Requires `prom-client` to be installed (`npm install prom-client`).
+     * When enabled, metrics are registered in prom-client's default registry
+     * and `toPrometheusText()` delegates to `prom-client.register.metrics()`.
+     * Falls back to custom text format if prom-client is not installed.
+     */
+    usePromClient?: boolean;
+}
+/**
+ * Collected worker metrics.
+ */
+interface WorkerMetrics {
+    /** Total polls by taskType */
+    pollTotal: Map<string, number>;
+    /** Poll errors by taskType */
+    pollErrorTotal: Map<string, number>;
+    /** Task executions completed by taskType */
+    taskExecutionTotal: Map<string, number>;
+    /** Task execution errors by "taskType:exceptionName" */
+    taskExecutionErrorTotal: Map<string, number>;
+    /** Task update failures by taskType */
+    taskUpdateFailureTotal: Map<string, number>;
+    /** Task ack errors by taskType */
+    taskAckErrorTotal: Map<string, number>;
+    /** Task execution queue full by taskType */
+    taskExecutionQueueFullTotal: Map<string, number>;
+    /** Thread/process uncaught exceptions (global counter) */
+    uncaughtExceptionTotal: number;
+    /** Worker restart count (global counter) */
+    workerRestartTotal: number;
+    /** Task paused count by taskType */
+    taskPausedTotal: Map<string, number>;
+    /** Workflow start errors */
+    workflowStartErrorTotal: number;
+    /** External payload used count by type (workflow_input/task_output) */
+    externalPayloadUsedTotal: Map<string, number>;
+    /** Poll duration observations in ms by taskType */
+    pollDurationMs: Map<string, number[]>;
+    /** Execution duration observations in ms by taskType */
+    executionDurationMs: Map<string, number[]>;
+    /** Update duration observations in ms by taskType */
+    updateDurationMs: Map<string, number[]>;
+    /** Output size observations in bytes by taskType */
+    outputSizeBytes: Map<string, number[]>;
+    /** Workflow input size observations in bytes */
+    workflowInputSizeBytes: Map<string, number[]>;
+    /** API request duration observations in ms by "method:uri:status" */
+    apiRequestDurationMs: Map<string, number[]>;
+}
+/**
+ * Built-in metrics collector implementing TaskRunnerEventsListener.
+ *
+ * Collects 19 metric types matching the Python SDK's MetricsCollector,
+ * with sliding-window quantile support (p50, p75, p90, p95, p99).
+ *
+ * @example
+ * ```typescript
+ * const metrics = new MetricsCollector({ httpPort: 9090 });
+ *
+ * const handler = new TaskHandler({
+ *   client,
+ *   eventListeners: [metrics],
+ * });
+ *
+ * await handler.startWorkers();
+ * // GET http://localhost:9090/metrics  — Prometheus format
+ * // GET http://localhost:9090/health   — {"status":"UP"}
+ * ```
+ */
+declare class MetricsCollector implements TaskRunnerEventsListener {
+    private metrics;
+    private readonly _prefix;
+    private readonly _slidingWindowSize;
+    private _server?;
+    private _fileTimer?;
+    private _promRegistry?;
+    constructor(config?: MetricsCollectorConfig);
+    private initPromClient;
+    private startServer;
+    private startFileWriter;
+    private createEmptyMetrics;
+    private increment;
+    private observe;
+    private incrementCounter;
+    private observeSummary;
+    onPollStarted(event: PollStarted): void;
+    onPollCompleted(event: PollCompleted): void;
+    onPollFailure(event: PollFailure): void;
+    onTaskExecutionStarted(_event: TaskExecutionStarted): void;
+    onTaskExecutionCompleted(event: TaskExecutionCompleted): void;
+    onTaskExecutionFailure(event: TaskExecutionFailure): void;
+    onTaskUpdateCompleted(event: TaskUpdateCompleted): void;
+    onTaskUpdateFailure(event: TaskUpdateFailure): void;
+    /** Record a task execution queue full event */
+    recordTaskExecutionQueueFull(taskType: string): void;
+    /** Record an uncaught exception */
+    recordUncaughtException(): void;
+    /** Record a worker restart */
+    recordWorkerRestart(): void;
+    /** Record a task paused event */
+    recordTaskPaused(taskType: string): void;
+    /** Record a task ack error */
+    recordTaskAckError(taskType: string): void;
+    /** Record a workflow start error */
+    recordWorkflowStartError(): void;
+    /** Record external payload usage */
+    recordExternalPayloadUsed(payloadType: string): void;
+    /** Record workflow input size */
+    recordWorkflowInputSize(workflowType: string, sizeBytes: number): void;
+    /** Record API request duration */
+    recordApiRequestTime(method: string, uri: string, status: number, durationMs: number): void;
+    /** Get a snapshot of all collected metrics */
+    getMetrics(): Readonly<WorkerMetrics>;
+    /** Reset all collected metrics */
+    reset(): void;
+    /** Stop the auto-started metrics HTTP server and file writer (if any) */
+    stop(): Promise<void>;
+    /**
+     * Get the content type for the Prometheus metrics endpoint.
+     * Returns prom-client's content type when available, otherwise standard Prometheus text format.
+     */
+    getContentType(): string;
+    /**
+     * Render all collected metrics in Prometheus exposition format.
+     * If prom-client is available and `usePromClient: true`, delegates to prom-client's registry.
+     * Otherwise uses built-in rendering with p50/p75/p90/p95/p99 quantiles.
+     *
+     * @param prefix - Metric name prefix (defaults to constructor config or "conductor_worker")
+     * @returns Prometheus text format string
+     */
+    /**
+     * Async version of toPrometheusText.
+     * When prom-client is available, returns its native registry output.
+     * Otherwise falls back to the built-in text format.
+     */
+    toPrometheusTextAsync(): Promise<string>;
+    toPrometheusText(prefix?: string): string;
+}
+
+/**
+ * Lightweight HTTP server exposing Prometheus metrics and a health check endpoint.
+ *
+ * Uses Node.js built-in `http` module — no external dependencies.
+ *
+ * Endpoints:
+ * - `GET /metrics` — Prometheus text exposition format (`text/plain; version=0.0.4`)
+ * - `GET /health` — JSON health check (`{"status":"UP"}`)
+ *
+ * @example
+ * ```typescript
+ * const collector = new MetricsCollector();
+ * const server = new MetricsServer(collector, 9090);
+ * await server.start();
+ * // GET http://localhost:9090/metrics
+ * // GET http://localhost:9090/health
+ * await server.stop();
+ * ```
+ */
+declare class MetricsServer {
+    private readonly _collector;
+    private readonly _port;
+    private _server?;
+    constructor(collector: MetricsCollector, port: number);
+    /** Start listening on the configured port */
+    start(): Promise<void>;
+    /** Stop the HTTP server */
+    stop(): Promise<void>;
+}
+
+/**
+ * Lightweight JSON Schema (draft-07) generator from declarative field descriptions.
+ *
+ * TypeScript has no runtime type reflection, so this provides a practical
+ * alternative: describe your fields declaratively and get a valid JSON Schema object.
+ *
+ * @example
+ * ```typescript
+ * const schema = jsonSchema({
+ *   orderId: { type: "string", required: true },
+ *   amount: { type: "number" },
+ *   items: { type: "array", items: { type: "string" } },
+ *   address: {
+ *     type: "object",
+ *     properties: {
+ *       street: { type: "string", required: true },
+ *       city: { type: "string" },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+interface FieldDescriptor {
+    type: JsonSchemaType;
+    required?: boolean;
+    description?: string;
+    /** For arrays: schema of array items */
+    items?: FieldDescriptor;
+    /** For objects: nested property descriptors */
+    properties?: Record<string, FieldDescriptor>;
+    /** Default value */
+    default?: unknown;
+    /** Enum values */
+    enum?: unknown[];
+}
+interface JsonSchemaOutput {
+    $schema: string;
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+}
+/**
+ * Generate a JSON Schema (draft-07) from declarative field descriptions.
+ */
+declare function jsonSchema(fields: Record<string, FieldDescriptor>): JsonSchemaOutput;
+
+declare global {
+    namespace Reflect {
+        function getMetadata(key: unknown, target: object, propertyKey?: string): unknown;
+        function getOwnMetadata(key: unknown, target: object): unknown;
+        function defineMetadata(key: unknown, value: unknown, target: object): void;
+    }
+}
+/**
+ * Options for the @schemaField property decorator.
+ */
+interface SchemaFieldOptions {
+    /** JSON Schema type. If omitted, inferred from TypeScript type metadata. */
+    type?: JsonSchemaType;
+    /** Whether this field is required (default: false) */
+    required?: boolean;
+    /** Field description */
+    description?: string;
+    /** For arrays: element type or schema */
+    items?: {
+        type: JsonSchemaType;
+    } | SchemaFieldOptions;
+    /** For objects: nested property definitions */
+    properties?: Record<string, SchemaFieldOptions>;
+    /** Default value */
+    default?: unknown;
+    /** Enum values */
+    enum?: unknown[];
+}
+/**
+ * Property decorator to define JSON Schema metadata on a class.
+ *
+ * When used with `generateSchemaFromClass()`, produces a JSON Schema draft-07
+ * object from the decorated properties.
+ *
+ * If `emitDecoratorMetadata` is enabled in tsconfig.json, the TypeScript type
+ * is automatically inferred for `string`, `number`, `boolean` — no need to
+ * specify `type` explicitly for those.
+ *
+ * @example
+ * ```typescript
+ * class OrderInput {
+ *   @schemaField({ required: true })
+ *   orderId!: string;
+ *
+ *   @schemaField()
+ *   amount!: number;
+ *
+ *   @schemaField({ type: "array", items: { type: "string" } })
+ *   items!: string[];
+ * }
+ *
+ * const schema = generateSchemaFromClass(OrderInput);
+ * ```
+ */
+declare function schemaField(options?: SchemaFieldOptions): (target: object, propertyKey: string) => void;
+/**
+ * Generate a JSON Schema (draft-07) from a class decorated with `@schemaField()`.
+ *
+ * Uses `reflect-metadata` to read TypeScript type information when available,
+ * falling back to explicit `type` in `@schemaField()` options.
+ *
+ * @param cls - A class constructor with `@schemaField()` decorated properties
+ * @returns JSON Schema draft-07 object
+ *
+ * @example
+ * ```typescript
+ * class OrderInput {
+ *   @schemaField({ required: true })
+ *   orderId!: string;
+ *
+ *   @schemaField()
+ *   amount!: number;
+ * }
+ *
+ * const schema = generateSchemaFromClass(OrderInput);
+ * // → { "$schema": "...", type: "object", properties: { orderId: { type: "string" }, ... }, required: ["orderId"] }
+ * ```
+ */
+declare function generateSchemaFromClass(cls: new (...args: any[]) => unknown): JsonSchemaOutput;
+
 declare class ConductorSdkError extends Error {
     private _trace;
     private __proto__;
     constructor(message?: string, innerError?: Error);
 }
 
-export { type AccessKey, type AccessKeyInfo, type Action, ApiError, type ApiRequestOptions, type ApiResult, ApplicationClient, type ApplicationRole, type Auth, BaseHttpRequest, CancelError, CancelablePromise, type CircuitBreakerTransitionResponse, type Client, type ClientOptions, type CommonTaskDef, type ConductorClient, type ConductorLogger, ConductorSdkError, type ConductorWorker, type Config$1 as Config, type ConnectivityTestInput, type ConnectivityTestResult, Consistency, DefaultLogger, type DoWhileTaskDef, type EnhancedSignalResponse, EventClient, type EventHandler, type EventMessage, type EventTaskDef, type ExtendedConductorApplication, 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, MetadataClient, type Middleware, type OnCancel, type OpenAPIConfig, type OrkesApiConfig, type PollData, type PollIntervalOptions, Poller, 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, ServiceRegistryClient, 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 TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerOptions, type TaskSummary, TaskType, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type UserFormTemplate, type UserType, type WaitTaskDef, type Workflow, type WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, conductorEventTask, createConductorClient, 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, noopLogger, createConductorClient as orkesConductorClient, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };
+export { type AccessKey, type AccessKeyInfo, type Action, ApiError, type ApiRequestOptions, type ApiResult, ApplicationClient, type ApplicationRole, type AssignmentCompletionStrategy, type Auth, AuthorizationClient, type AuthorizationRequest, type AzureOpenAIConfig, BaseHttpRequest, type BulkResponse, type CallMcpToolOptions, CancelError, CancelablePromise, type ChatMessage, type CircuitBreakerTransitionResponse, type ClaimTaskOptions, type Client, type ClientOptions, type CommonTaskDef, type ConductorClient, type ConductorLogger, ConductorSdkError, type ConductorUser, type ConductorWorker, ConductorWorkflow, type Config$1 as Config, type ConnectivityTestInput, type ConnectivityTestResult, Consistency, type CorrelationIdsSearchRequest, DefaultLogger, type DoWhileTaskDef, type EmbeddingModel, type EnhancedSignalResponse, EventClient, EventDispatcher, type EventHandler, type EventMessage, type EventTaskDef, type ExtendedBulkResponse, type ExtendedConductorApplication, type ExtendedConductorUser, type ExtendedEventExecution, type ExtendedGroup, type ExtendedIntegrationApiUpdate, type ExtendedRateLimitConfig, type ExtendedTaskDef, type ExtendedTaskSummary, type ExtendedWorkflowDef, type ExternalStorageLocation, type FieldDescriptor, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateAudioOptions, type GenerateImageOptions, type GenerateTokenRequest, type GetDocumentOptions, type GrantedAccessResponse, type Group, type HTScrollableSearchResultHumanTaskEntry, type HealthMonitorConfig, type HttpInputParameters, type HttpPollInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskOptions, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type Integration, type IntegrationApi, type IntegrationApiUpdate, IntegrationClient, type IntegrationConfig, type IntegrationDef, type IntegrationUpdate, type JoinTaskDef, type JsonJQTransformTaskDef, type JsonSchemaOutput, type JsonSchemaType, type KafkaPublishInputParameters, type KafkaPublishTaskDef, LLMProvider, type ListMcpToolsOptions, type LlmChatCompleteOptions, type LlmCompletionParams, type LlmGenerateEmbeddingsOptions, type LlmIndexDocumentOptions, type LlmIndexTextOptions, type LlmQueryEmbeddingsOptions, type LlmSearchEmbeddingsOptions, type LlmSearchIndexOptions, type LlmStoreEmbeddingsOptions, type LlmTextCompleteOptions, type MessageTemplate, MetadataClient, MetricsCollector, type MetricsCollectorConfig, MetricsServer, type Middleware, NonRetryableException, type OnCancel, type OpenAIConfig, type OpenAPIConfig, type OrkesApiConfig, OrkesClients, type PineconeConfig, type PollCompleted, type PollData, type PollFailure, type PollIntervalOptions, type PollStarted, Poller, PromptClient, type PromptTemplateTestRequest, type ProtoRegistryEntry, type QuerySerializerOptions, type RateLimitConfig, type RegisteredWorker, type RequestOptions, type RerunWorkflowRequest, type ResolvedRequestOptions, type Response$1 as Response, ReturnStrategy, Role, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, SchemaClient, type SchemaDef, type SchemaFieldOptions, type ScrollableSearchResultWorkflowSummary, type SearchResultHandledEventResponse, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, SecretClient, type ServiceMethod, type ServiceRegistry, ServiceRegistryClient, 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, TaskContext, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskExecutionCompleted, type TaskExecutionFailure, type TaskExecutionStarted, type TaskFinderPredicate, TaskHandler, type TaskHandlerConfig, type TaskInProgressResult, type TaskListSearchResultSummary, TaskManager, type TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerEvent, type TaskRunnerEventType, type TaskRunnerEventsListener, type TaskRunnerOptions, type TaskSummary, TaskType, type TaskUpdateCompleted, type TaskUpdateFailure, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type ToolCall, type ToolSpec, type UpsertGroupRequest, type UpsertUserRequest, type UserFormTemplate, type UserType, VectorDB, type WaitForWebhookOptions, type WaitTaskDef, type WeaviateConfig, type WorkerMetrics, type WorkerOptions, type Workflow, type WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStateUpdate, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, type WorkflowTestRequest, callMcpToolTask, clearWorkerRegistry, conductorEventTask, createConductorClient, doWhileTask, dynamicForkTask, dynamicTask, eventTask, forkTask, forkTaskJoin, generate, generateAudioTask, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateImageTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSchemaFromClass, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, getDocumentTask, getRegisteredWorker, getRegisteredWorkers, getTaskContext, getWorkerCount, httpPollTask, httpTask, humanTask, inlineTask, isTaskInProgress, joinTask, jsonJqTask, jsonSchema, kafkaPublishTask, listMcpToolsTask, llmChatCompleteTask, llmGenerateEmbeddingsTask, llmIndexDocumentTask, llmIndexTextTask, llmQueryEmbeddingsTask, llmSearchEmbeddingsTask, llmSearchIndexTask, llmStoreEmbeddingsTask, llmTextCompleteTask, newLoopTask, noopLogger, createConductorClient as orkesConductorClient, schemaField, setVariableTask, simpleTask, sqsEventTask, startWorkflowTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitForWebhookTask, waitTaskDuration, waitTaskUntil, withPromptVariable, withPromptVariables, worker, workflow };