@io-orkes/conductor-javascript 2.3.0 → 2.4.1-beta

package/dist/index.d.ts

@@ -1,99 +1,373 @@
-interface ConductorLogger {
-    info(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-    debug(...args: unknown[]): void;
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
 }
-type ConductorLogLevel = keyof typeof LOG_LEVELS;
-interface DefaultLoggerConfig {
-    level?: ConductorLogLevel;
-    tags?: object[];
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
 }
-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;
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: any) => any;
+interface QuerySerializerOptions {
+    allowReserved?: boolean;
+    array?: SerializerOptions<ArrayStyle>;
+    object?: SerializerOptions<ObjectStyle>;
 }
-declare const noopLogger: ConductorLogger;
 
-type Action = {
-    action?: 'start_workflow' | 'complete_task' | 'fail_task' | 'terminate_workflow' | 'update_workflow_variables';
-    complete_task?: TaskDetails;
-    expandInlineJSON?: boolean;
-    fail_task?: TaskDetails;
-    start_workflow?: StartWorkflowRequest;
-    terminate_workflow?: TerminateWorkflow;
-    update_workflow_variables?: UpdateWorkflowVariables;
-};
-type Any = {
-    allFields?: {
-        [key: string]: unknown;
-    };
-    defaultInstanceForType?: Any;
-    descriptorForType?: Descriptor;
-    initializationErrorString?: string;
-    initialized?: boolean;
-    parserForType?: ParserAny;
-    serializedSize?: number;
-    typeUrl?: string;
-    typeUrlBytes?: ByteString;
-    unknownFields?: UnknownFieldSet;
-    value?: ByteString;
-};
-type BulkResponse = {
-    bulkErrorResults?: {
-        [key: string]: string;
-    };
-    bulkSuccessfulResults?: Array<{
-        [key: string]: unknown;
-    }>;
-};
-type ByteString = {
-    empty?: boolean;
-    validUtf8?: boolean;
-};
-type CacheConfig = {
-    key?: string;
-    ttlInSecond?: number;
-};
-type CircuitBreakerTransitionResponse = {
-    currentState?: string;
-    message?: string;
-    previousState?: string;
-    service?: string;
-    transitionTimestamp?: number;
-};
-type Config$2 = {
-    circuitBreakerConfig?: OrkesCircuitBreakerConfig;
-};
-type ConnectivityTestInput = {
-    input?: {
-        [key: string]: unknown;
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
     };
-    sink: string;
+});
+interface Config$2 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g. converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$2, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
 };
-type ConnectivityTestResult = {
-    reason?: string;
-    successful?: boolean;
-    workflowId?: string;
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-type Declaration = {
-    allFields?: {
-        [key: string]: unknown;
-    };
-    defaultInstanceForType?: Declaration;
-    descriptorForType?: Descriptor;
-    fullName?: string;
-    fullNameBytes?: ByteString;
-    initializationErrorString?: string;
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config$1<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$2 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$1<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: Pick<TData, 'url'> & Options<TData>) => string;
+type Client = Client$1<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+
+type Action = {
+    action?: 'start_workflow' | 'complete_task' | 'fail_task' | 'terminate_workflow' | 'update_workflow_variables';
+    complete_task?: TaskDetails;
+    expandInlineJSON?: boolean;
+    fail_task?: TaskDetails;
+    start_workflow?: StartWorkflowRequest;
+    terminate_workflow?: TerminateWorkflow;
+    update_workflow_variables?: UpdateWorkflowVariables;
+};
+type Any = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Any;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserAny;
+    serializedSize?: number;
+    typeUrl?: string;
+    typeUrlBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+    value?: ByteString;
+};
+type BulkResponse = {
+    bulkErrorResults?: {
+        [key: string]: string;
+    };
+    bulkSuccessfulResults?: Array<{
+        [key: string]: unknown;
+    }>;
+};
+type ByteString = {
+    empty?: boolean;
+    validUtf8?: boolean;
+};
+type CacheConfig = {
+    key?: string;
+    ttlInSecond?: number;
+};
+type CircuitBreakerTransitionResponse = {
+    currentState?: string;
+    message?: string;
+    previousState?: string;
+    service?: string;
+    transitionTimestamp?: number;
+};
+type Config = {
+    circuitBreakerConfig?: OrkesCircuitBreakerConfig;
+};
+type ConnectivityTestInput = {
+    input?: {
+        [key: string]: unknown;
+    };
+    sink: string;
+};
+type ConnectivityTestResult = {
+    reason?: string;
+    successful?: boolean;
+    workflowId?: string;
+};
+type Declaration = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Declaration;
+    descriptorForType?: Descriptor;
+    fullName?: string;
+    fullNameBytes?: ByteString;
+    initializationErrorString?: string;
     initialized?: boolean;
     number?: number;
     parserForType?: ParserDeclaration;
@@ -477,6 +751,15 @@ type EventMessage = {
     status?: 'RECEIVED' | 'HANDLED' | 'REJECTED';
     statusDescription?: string;
 };
+type ExtendedConductorApplication$1 = {
+    createTime?: number;
+    createdBy?: string;
+    id?: string;
+    name?: string;
+    tags?: Array<Tag>;
+    updateTime?: number;
+    updatedBy?: string;
+};
 type ExtendedEventExecution = {
     action?: 'start_workflow' | 'complete_task' | 'fail_task' | 'terminate_workflow' | 'update_workflow_variables';
     created?: number;
@@ -1714,7 +1997,7 @@ type ServiceOptionsOrBuilder = {
 };
 type ServiceRegistry = {
     circuitBreakerEnabled?: boolean;
-    config?: Config$2;
+    config?: Config;
     methods?: Array<ServiceMethod>;
     name?: string;
     requestParams?: Array<RequestParam>;
@@ -1786,7 +2069,7 @@ type StartWorkflowRequest = {
         [key: string]: string;
     };
     version?: number;
-    workflowDef?: WorkflowDef$1;
+    workflowDef?: WorkflowDef;
 };
 type StateChangeEvent = {
     payload?: {
@@ -2061,12 +2344,12 @@ type Workflow = {
     variables?: {
         [key: string]: unknown;
     };
-    workflowDefinition?: WorkflowDef$1;
+    workflowDefinition?: WorkflowDef;
     workflowId?: string;
     workflowName?: string;
     workflowVersion?: number;
 };
-type WorkflowDef$1 = {
+type WorkflowDef = {
     cacheConfig?: CacheConfig;
     createTime?: number;
     createdBy?: string;
@@ -2267,383 +2550,83 @@ type WorkflowTask = {
     type?: string;
 };
 
-type AuthToken = string | undefined;
-interface Auth {
-    /**
-     * Which part of the request do we use to send the auth?
-     *
-     * @default 'header'
-     */
-    in?: 'header' | 'query' | 'cookie';
-    /**
-     * Header or query parameter name.
-     *
-     * @default 'Authorization'
-     */
-    name?: string;
-    scheme?: 'basic' | 'bearer';
-    type: 'apiKey' | 'http';
+interface CommonTaskDef {
+    name: string;
+    taskReferenceName: string;
 }
-
-interface SerializerOptions<T> {
-    /**
-     * @default true
-     */
-    explode: boolean;
-    style: T;
+declare enum Consistency {
+    SYNCHRONOUS = "SYNCHRONOUS",
+    DURABLE = "DURABLE",
+    REGION_DURABLE = "REGION_DURABLE"
 }
-type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
-type ObjectStyle = 'form' | 'deepObject';
-
-type QuerySerializer = (query: Record<string, unknown>) => string;
-type BodySerializer = (body: any) => any;
-interface QuerySerializerOptions {
-    allowReserved?: boolean;
-    array?: SerializerOptions<ArrayStyle>;
-    object?: SerializerOptions<ObjectStyle>;
+declare enum ReturnStrategy {
+    TARGET_WORKFLOW = "TARGET_WORKFLOW",
+    BLOCKING_WORKFLOW = "BLOCKING_WORKFLOW",
+    BLOCKING_TASK = "BLOCKING_TASK",
+    BLOCKING_TASK_INPUT = "BLOCKING_TASK_INPUT"
 }
-
-type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
-    /**
-     * Returns the final request URL.
-     */
-    buildUrl: BuildUrlFn;
-    getConfig: () => Config;
-    request: RequestFn;
-    setConfig: (config: Config) => Config;
-} & {
-    [K in HttpMethod]: MethodFn;
-} & ([SseFn] extends [never] ? {
-    sse?: never;
-} : {
-    sse: {
-        [K in HttpMethod]: SseFn;
-    };
-});
-interface Config$1 {
-    /**
-     * Auth token or a function returning auth token. The resolved value will be
-     * added to the request payload as defined by its `security` array.
-     */
-    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
-    /**
-     * A function for serializing request body parameter. By default,
-     * {@link JSON.stringify()} will be used.
-     */
-    bodySerializer?: BodySerializer | null;
-    /**
-     * An object containing any HTTP headers that you want to pre-populate your
-     * `Headers` object with.
-     *
-     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
-     */
-    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
-    /**
-     * The request method.
-     *
-     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
-     */
-    method?: Uppercase<HttpMethod>;
-    /**
-     * A function for serializing request query parameters. By default, arrays
-     * will be exploded in form style, objects will be exploded in deepObject
-     * style, and reserved characters are percent-encoded.
-     *
-     * This method will have no effect if the native `paramsSerializer()` Axios
-     * API function is used.
-     *
-     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
-     */
-    querySerializer?: QuerySerializer | QuerySerializerOptions;
-    /**
-     * A function validating request data. This is useful if you want to ensure
-     * the request conforms to the desired shape, so it can be safely sent to
-     * the server.
-     */
-    requestValidator?: (data: unknown) => Promise<unknown>;
-    /**
-     * A function transforming response data before it's returned. This is useful
-     * for post-processing data, e.g. converting ISO strings into Date objects.
-     */
-    responseTransformer?: (data: unknown) => Promise<unknown>;
-    /**
-     * A function validating response data. This is useful if you want to ensure
-     * the response conforms to the desired shape, so it can be safely passed to
-     * the transformers and returned to the user.
-     */
-    responseValidator?: (data: unknown) => Promise<unknown>;
+declare enum TaskResultStatusEnum {
+    IN_PROGRESS = "IN_PROGRESS",
+    FAILED = "FAILED",
+    FAILED_WITH_TERMINAL_ERROR = "FAILED_WITH_TERMINAL_ERROR",
+    COMPLETED = "COMPLETED"
 }
-
-type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
-    /**
-     * Fetch API implementation. You can use this option to provide a custom
-     * fetch instance.
-     *
-     * @default globalThis.fetch
-     */
-    fetch?: typeof fetch;
-    /**
-     * Implementing clients can call request interceptors inside this hook.
-     */
-    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
-    /**
-     * Callback invoked when a network or parsing error occurs during streaming.
-     *
-     * This option applies only if the endpoint returns a stream of events.
-     *
-     * @param error The error that occurred.
-     */
-    onSseError?: (error: unknown) => void;
-    /**
-     * Callback invoked when an event is streamed from the server.
-     *
-     * This option applies only if the endpoint returns a stream of events.
-     *
-     * @param event Event streamed from the server.
-     * @returns Nothing (void).
-     */
-    onSseEvent?: (event: StreamEvent<TData>) => void;
-    serializedBody?: RequestInit['body'];
-    /**
-     * Default retry delay in milliseconds.
-     *
-     * This option applies only if the endpoint returns a stream of events.
-     *
-     * @default 3000
-     */
-    sseDefaultRetryDelay?: number;
-    /**
-     * Maximum number of retry attempts before giving up.
-     */
-    sseMaxRetryAttempts?: number;
-    /**
-     * Maximum retry delay in milliseconds.
-     *
-     * Applies only when exponential backoff is used.
-     *
-     * This option applies only if the endpoint returns a stream of events.
-     *
-     * @default 30000
-     */
-    sseMaxRetryDelay?: number;
-    /**
-     * Optional sleep function for retry backoff.
-     *
-     * Defaults to using `setTimeout`.
-     */
-    sseSleepFn?: (ms: number) => Promise<void>;
-    url: string;
-};
-interface StreamEvent<TData = unknown> {
-    data: TData;
-    event?: string;
-    id?: string;
-    retry?: number;
+declare enum TaskType {
+    START = "START",
+    SIMPLE = "SIMPLE",
+    DYNAMIC = "DYNAMIC",
+    FORK_JOIN = "FORK_JOIN",
+    FORK_JOIN_DYNAMIC = "FORK_JOIN_DYNAMIC",
+    DECISION = "DECISION",
+    SWITCH = "SWITCH",
+    JOIN = "JOIN",
+    DO_WHILE = "DO_WHILE",
+    SUB_WORKFLOW = "SUB_WORKFLOW",
+    EVENT = "EVENT",
+    WAIT = "WAIT",
+    USER_DEFINED = "USER_DEFINED",
+    HTTP = "HTTP",
+    LAMBDA = "LAMBDA",
+    INLINE = "INLINE",
+    EXCLUSIVE_JOIN = "EXCLUSIVE_JOIN",
+    TERMINAL = "TERMINAL",
+    TERMINATE = "TERMINATE",
+    KAFKA_PUBLISH = "KAFKA_PUBLISH",
+    JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
+    SET_VARIABLE = "SET_VARIABLE"
 }
-type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
-    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
-};
-
-type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
-type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
-type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
-declare class Interceptors<Interceptor> {
-    fns: Array<Interceptor | null>;
-    clear(): void;
-    eject(id: number | Interceptor): void;
-    exists(id: number | Interceptor): boolean;
-    getInterceptorIndex(id: number | Interceptor): number;
-    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
-    use(fn: Interceptor): number;
+declare enum ServiceType {
+    HTTP = "HTTP",
+    MCP_REMOTE = "MCP_REMOTE",
+    gRPC = "gRPC"
 }
-interface Middleware<Req, Res, Err, Options> {
-    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
-    request: Interceptors<ReqInterceptor<Req, Options>>;
-    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
+interface DoWhileTaskDef extends CommonTaskDef {
+    inputParameters: Record<string, unknown>;
+    type: TaskType.DO_WHILE;
+    startDelay?: number;
+    optional?: boolean;
+    asyncComplete?: boolean;
+    loopCondition: string;
+    loopOver: TaskDefTypes[];
 }
-
-type ResponseStyle = 'data' | 'fields';
-interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
-    /**
-     * Base URL for all requests made by this client.
-     */
-    baseUrl?: T['baseUrl'];
-    /**
-     * Fetch API implementation. You can use this option to provide a custom
-     * fetch instance.
-     *
-     * @default globalThis.fetch
-     */
-    fetch?: typeof fetch;
-    /**
-     * Please don't use the Fetch client for Next.js applications. The `next`
-     * options won't have any effect.
-     *
-     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
-     */
-    next?: never;
-    /**
-     * Return the response data parsed in a specified format. By default, `auto`
-     * will infer the appropriate method from the `Content-Type` response header.
-     * You can override this behavior with any of the {@link Body} methods.
-     * Select `stream` if you don't want to parse response data at all.
-     *
-     * @default 'auto'
-     */
-    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
-    /**
-     * Should we return only data or multiple fields (data, error, response, etc.)?
-     *
-     * @default 'fields'
-     */
-    responseStyle?: ResponseStyle;
-    /**
-     * Throw an error instead of returning it in the response?
-     *
-     * @default false
-     */
-    throwOnError?: T['throwOnError'];
+interface EventTaskDef extends CommonTaskDef {
+    type: TaskType.EVENT;
+    sink: string;
+    asyncComplete?: boolean;
+    optional?: boolean;
 }
-interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
-    responseStyle: TResponseStyle;
-    throwOnError: ThrowOnError;
-}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
-    /**
-     * Any body that you want to add to your request.
-     *
-     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
-     */
-    body?: unknown;
-    path?: Record<string, unknown>;
-    query?: Record<string, unknown>;
-    /**
-     * Security mechanism(s) to use for the request.
-     */
-    security?: ReadonlyArray<Auth>;
-    url: Url;
+interface ForkJoinTaskDef extends CommonTaskDef {
+    type: TaskType.FORK_JOIN;
+    inputParameters?: Record<string, string>;
+    forkTasks: TaskDefTypes[][];
 }
-interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
-    serializedBody?: string;
-}
-type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
-    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
-    request: Request;
-    response: Response;
-}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
-    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
-    error: undefined;
-} | {
-    data: undefined;
-    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
-}) & {
-    request: Request;
-    response: Response;
-}>;
-interface ClientOptions {
-    baseUrl?: string;
-    responseStyle?: ResponseStyle;
-    throwOnError?: boolean;
-}
-type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
-type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type BuildUrlFn = <TData extends {
-    body?: unknown;
-    path?: Record<string, unknown>;
-    query?: Record<string, unknown>;
-    url: string;
-}>(options: Pick<TData, 'url'> & Options<TData>) => string;
-type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
-    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
-};
-interface TDataShape {
-    body?: unknown;
-    headers?: unknown;
-    path?: unknown;
-    query?: unknown;
-    url: string;
-}
-type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
-type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
-
-interface CommonTaskDef {
-    name: string;
-    taskReferenceName: string;
-}
-declare enum Consistency {
-    SYNCHRONOUS = "SYNCHRONOUS",
-    DURABLE = "DURABLE",
-    REGION_DURABLE = "REGION_DURABLE"
-}
-declare enum ReturnStrategy {
-    TARGET_WORKFLOW = "TARGET_WORKFLOW",
-    BLOCKING_WORKFLOW = "BLOCKING_WORKFLOW",
-    BLOCKING_TASK = "BLOCKING_TASK",
-    BLOCKING_TASK_INPUT = "BLOCKING_TASK_INPUT"
-}
-declare enum TaskResultStatusEnum {
-    IN_PROGRESS = "IN_PROGRESS",
-    FAILED = "FAILED",
-    FAILED_WITH_TERMINAL_ERROR = "FAILED_WITH_TERMINAL_ERROR",
-    COMPLETED = "COMPLETED"
-}
-declare enum TaskType {
-    START = "START",
-    SIMPLE = "SIMPLE",
-    DYNAMIC = "DYNAMIC",
-    FORK_JOIN = "FORK_JOIN",
-    FORK_JOIN_DYNAMIC = "FORK_JOIN_DYNAMIC",
-    DECISION = "DECISION",
-    SWITCH = "SWITCH",
-    JOIN = "JOIN",
-    DO_WHILE = "DO_WHILE",
-    SUB_WORKFLOW = "SUB_WORKFLOW",
-    EVENT = "EVENT",
-    WAIT = "WAIT",
-    USER_DEFINED = "USER_DEFINED",
-    HTTP = "HTTP",
-    LAMBDA = "LAMBDA",
-    INLINE = "INLINE",
-    EXCLUSIVE_JOIN = "EXCLUSIVE_JOIN",
-    TERMINAL = "TERMINAL",
-    TERMINATE = "TERMINATE",
-    KAFKA_PUBLISH = "KAFKA_PUBLISH",
-    JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
-    SET_VARIABLE = "SET_VARIABLE"
-}
-declare enum ServiceType {
-    HTTP = "HTTP",
-    MCP_REMOTE = "MCP_REMOTE",
-    gRPC = "gRPC"
-}
-type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
-interface DoWhileTaskDef extends CommonTaskDef {
-    inputParameters: Record<string, unknown>;
-    type: TaskType.DO_WHILE;
-    startDelay?: number;
-    optional?: boolean;
-    asyncComplete?: boolean;
-    loopCondition: string;
-    loopOver: TaskDefTypes[];
-}
-interface EventTaskDef extends CommonTaskDef {
-    type: TaskType.EVENT;
-    sink: string;
-    asyncComplete?: boolean;
-    optional?: boolean;
-}
-interface ForkJoinTaskDef extends CommonTaskDef {
-    type: TaskType.FORK_JOIN;
-    inputParameters?: Record<string, string>;
-    forkTasks: TaskDefTypes[][];
-}
-interface JoinTaskDef extends CommonTaskDef {
-    type: TaskType.JOIN;
-    inputParameters?: Record<string, string>;
-    joinOn: string[];
-    optional?: boolean;
-    asyncComplete?: boolean;
+interface JoinTaskDef extends CommonTaskDef {
+    type: TaskType.JOIN;
+    inputParameters?: Record<string, string>;
+    joinOn: string[];
+    optional?: boolean;
+    asyncComplete?: boolean;
 }
 interface ForkJoinDynamicDef extends CommonTaskDef {
     inputParameters: {
@@ -2775,6 +2758,19 @@ interface SignalResponse extends SignalResponse$1 {
     taskDefName?: string;
     workflowType?: string;
 }
+interface AccessKey {
+    id: string;
+    secret: string;
+}
+interface AccessKeyInfo {
+    id: string;
+    createdAt: number;
+    status: "ACTIVE" | "INACTIVE";
+}
+type ApplicationRole = "ADMIN" | "UNRESTRICTED_WORKER" | "METADATA_MANAGER" | "WORKFLOW_MANAGER" | "APPLICATION_MANAGER" | "USER" | "USER_READ_ONLY" | "WORKER" | "APPLICATION_CREATOR" | "METADATA_API" | "PROMPT_MANAGER";
+interface ExtendedConductorApplication extends Required<Omit<ExtendedConductorApplication$1, "tags">> {
+    tags?: Tag[];
+}
 
 type TimeoutPolicy = {
     type: string;
@@ -2870,609 +2866,842 @@ declare abstract class BaseHttpRequest {
     abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
 }
 
-/**
- * Functional interface for defining a worker implementation that processes tasks from a conductor queue.
- *
- * @remarks
- * Optional items allow overriding properties on a per-worker basis. Items not overridden
- * here will be inherited from the `TaskManager` options.
- */
-interface ConductorWorker {
-    taskDefName: string;
-    execute: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId">>;
-    domain?: string;
-    concurrency?: number;
-    pollInterval?: number;
-}
-
-type TaskErrorHandler = (error: Error, task?: Task) => void;
-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;
+type TaskResultStatus = NonNullable<TaskResult["status"]>;
+type TaskResultOutputData = NonNullable<TaskResult["outputData"]>;
+interface OrkesApiConfig {
+    serverUrl?: string;
+    keyId?: string;
+    keySecret?: string;
+    refreshTokenInterval?: number;
+    useEnvVars?: boolean;
+    maxHttp2Connections?: number;
 }
 
-declare const MAX_RETRIES = 3;
-declare const noopErrorHandler: TaskErrorHandler;
 /**
- * Responsible for polling and executing tasks from a queue.
- *
- * Because a `poll` in conductor "pops" a task off of a conductor queue,
- * each runner participates in the poll -> work -> update loop.
- * We could potentially split this work into a separate "poller" and "worker" pools
- * but that could lead to picking up more work than the pool of workers are actually able to handle.
+ * Creates a Conductor client with authentication and configuration
  *
+ * @param config (optional) OrkesApiConfig with keyId and keySecret
+ * @param customFetch (optional) custom fetch function
+ * @returns Client
  */
-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;
-}
-
-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>;
-}
-
-declare class ConductorSdkError extends Error {
-    private _trace;
-    private __proto__;
-    constructor(message?: string, innerError?: Error);
-}
-type TaskResultStatus = NonNullable<TaskResult["status"]>;
-type TaskResultOutputData = NonNullable<TaskResult["outputData"]>;
-interface EnhancedSignalResponse extends SignalResponse {
-    isTargetWorkflow(): boolean;
-    isBlockingWorkflow(): boolean;
-    isBlockingTask(): boolean;
-    isBlockingTaskInput(): boolean;
-    getWorkflow(): Workflow;
-    getBlockingTask(): Task;
-    getTaskInput(): Record<string, unknown>;
-    getWorkflowId(): string;
-    getTargetWorkflowId(): string;
-    hasWorkflowData(): boolean;
-    hasTaskData(): boolean;
-    getResponseType(): string;
-    isTerminal(): boolean;
-    isRunning(): boolean;
-    isPaused(): boolean;
-    getSummary(): string;
-    toDebugJSON(): Record<string, unknown>;
-    toString(): string;
-}
+declare const createConductorClient: (config?: OrkesApiConfig, customFetch?: typeof fetch) => Promise<{
+    eventResource: {
+        getQueueConfig: (queueType: string, queueName: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        putQueueConfig: (queueType: string, queueName: string, body: string) => Promise<void>;
+        deleteQueueConfig: (queueType: string, queueName: string) => Promise<void>;
+        getEventHandlers: () => Promise<EventHandler[]>;
+        updateEventHandler: (body: any) => Promise<void>;
+        addEventHandler: (body: any) => Promise<void>;
+        getQueueNames: () => Promise<{
+            [key: string]: string;
+        }>;
+        removeEventHandlerStatus: (name: string) => Promise<void>;
+        getEventHandlersForEvent: (event: string, activeOnly?: boolean) => Promise<EventHandler[]>;
+        deleteTagForEventHandler: (name: string, body: any[]) => Promise<void>;
+        getTagsForEventHandler: (name: string) => Promise<Tag[]>;
+        putTagForEventHandler: (name: string, body: any[]) => Promise<void>;
+    };
+    healthCheckResource: {
+        doCheck: () => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    metadataResource: {
+        getTaskDef: (tasktype: string, metadata?: boolean) => Promise<{
+            [key: string]: unknown;
+        }>;
+        unregisterTaskDef: (tasktype: string) => Promise<void>;
+        getAllWorkflows: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<WorkflowDef[]>;
+        update: (requestBody: any[], overwrite?: boolean) => Promise<void>;
+        create: (requestBody: any, overwrite?: boolean) => Promise<void>;
+        getTaskDefs: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<TaskDef[]>;
+        updateTaskDef: (requestBody: any) => Promise<void>;
+        registerTaskDef: (requestBody: any[]) => Promise<void>;
+        unregisterWorkflowDef: (name: string, version: number) => Promise<void>;
+        get: (name: string, version?: number, metadata?: boolean) => Promise<WorkflowDef>;
+    };
+    schedulerResource: {
+        getSchedule: (name: string) => Promise<WorkflowSchedule>;
+        deleteSchedule: (name: string) => Promise<void>;
+        getNextFewSchedules: (cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number) => Promise<number[]>;
+        pauseSchedule: (name: string) => Promise<void>;
+        pauseAllSchedules: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        resumeSchedule: (name: string) => Promise<void>;
+        requeueAllExecutionRecords: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        resumeAllSchedules: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        getAllSchedules: (workflowName?: string) => Promise<WorkflowScheduleModel[]>;
+        saveSchedule: (requestBody: any) => Promise<void>;
+        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultWorkflowScheduleExecutionModel>;
+        testTimeout: () => Promise<any>;
+    };
+    tokenResource: {
+        generateToken: (requestBody: any) => Promise<Response$1>;
+        getUserInfo: (claims?: boolean) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    workflowBulkResource: {
+        retry: (requestBody: any[]) => Promise<BulkResponse>;
+        restart: (requestBody: any[], useLatestDefinitions?: boolean) => Promise<BulkResponse>;
+        terminate: (requestBody: any[], reason?: string) => Promise<BulkResponse>;
+        resumeWorkflow: (requestBody: any[]) => Promise<BulkResponse>;
+        pauseWorkflow1: (requestBody: any[]) => Promise<BulkResponse>;
+    };
+    workflowResource: {
+        getRunningWorkflow: (name: string, version?: number, startTime?: number, endTime?: number) => Promise<string[]>;
+        executeWorkflow: (body: any, name: string, version: number, requestId?: string, waitUntilTaskRef?: string, waitForSeconds?: number, consistency?: any, returnStrategy?: any) => Promise<SignalResponse$1>;
+        startWorkflow: (requestBody: any) => Promise<string>;
+        decide: (workflowId: string) => Promise<void>;
+        rerun: (workflowId: string, requestBody: any) => Promise<string>;
+        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        pauseWorkflow: (workflowId: string) => Promise<void>;
+        skipTaskFromWorkflow: (workflowId: string, taskReferenceName: string, requestBody?: any) => Promise<void>;
+        getWorkflows: (name: string, requestBody: any[], includeClosed?: boolean, includeTasks?: boolean) => Promise<{
+            [key: string]: Workflow[];
+        }>;
+        getWorkflowStatusSummary: (workflowId: string, includeOutput?: boolean, includeVariables?: boolean) => Promise<WorkflowStatus>;
+        getWorkflows1: (name: string, correlationId: string, includeClosed?: boolean, includeTasks?: boolean) => Promise<Workflow[]>;
+        retry1: (workflowId: string, resumeSubworkflowTasks?: boolean) => Promise<void>;
+        getExecutionStatus: (workflowId: string, includeTasks?: boolean) => Promise<Workflow>;
+        terminate1: (workflowId: string, reason?: string) => Promise<void>;
+        resumeWorkflow: (workflowId: string) => Promise<void>;
+        delete: (workflowId: string, archiveWorkflow?: boolean) => Promise<void>;
+        searchWorkflowsByTasks: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        getExternalStorageLocation: (path: string, operation: string, payloadType: string) => Promise<any>;
+        startWorkflow1: (name: string, requestBody: any, version?: number, correlationId?: string, priority?: number) => Promise<string>;
+        restart1: (workflowId: string, useLatestDefinitions?: boolean) => Promise<void>;
+        search1: (queryId?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean) => Promise<any>;
+        searchWorkflowsByTasksV2: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        resetWorkflow: (workflowId: string) => Promise<void>;
+        testWorkflow: (requestBody: any) => Promise<Workflow>;
+    };
+    serviceRegistryResource: {
+        getRegisteredServices: () => Promise<ServiceRegistry[]>;
+        removeService: (name: string) => Promise<void>;
+        getService: (name: string) => Promise<ServiceRegistry>;
+        openCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
+        closeCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
+        getCircuitBreakerStatus: (name: string) => Promise<CircuitBreakerTransitionResponse>;
+        addOrUpdateService: (serviceRegistry: any) => Promise<void>;
+        addOrUpdateServiceMethod: (registryName: string, method: any) => Promise<void>;
+        removeMethod: (registryName: string, serviceName: string, method: string, methodType: string) => Promise<void>;
+        getProtoData: (registryName: string, filename: string) => Promise<string>;
+        setProtoData: (registryName: string, filename: string, data: any) => Promise<void>;
+        deleteProto: (registryName: string, filename: string) => Promise<void>;
+        getAllProtos: (registryName: string) => Promise<ProtoRegistryEntry[]>;
+        discover: (name: string, create?: boolean) => Promise<ServiceMethod[]>;
+    };
+    humanTaskResource: {
+        getConductorTaskById: (taskId: string) => Promise<Task>;
+    };
+    humanTask: {
+        deleteTaskFromHumanTaskRecords: (requestBody: any[]) => Promise<void>;
+        deleteTaskFromHumanTaskRecords1: (taskId: string) => Promise<void>;
+        search: (requestBody: any) => Promise<HumanTaskSearchResult>;
+        updateTaskOutputByRef: (workflowId: string, taskRefName: string, requestBody: any, complete?: boolean, iteration?: any[]) => Promise<any>;
+        getTask1: (taskId: string) => Promise<HumanTaskEntry>;
+        claimTask: (taskId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
+        assignAndClaim: (taskId: string, userId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
+        reassignTask: (taskId: string, requestBody: any[]) => Promise<void>;
+        releaseTask: (taskId: string) => Promise<void>;
+        skipTask: (taskId: string, reason?: string) => Promise<void>;
+        updateTaskOutput: (taskId: string, requestBody: any, complete?: boolean) => Promise<void>;
+        getAllTemplates: (name?: string, version?: number) => Promise<HumanTaskTemplate[]>;
+        saveTemplate: (requestBody: any, newVersion?: boolean) => Promise<HumanTaskTemplate>;
+        saveTemplates: (requestBody: any[], newVersion?: boolean) => Promise<HumanTaskTemplate[]>;
+        deleteTemplateByName: (name: string) => Promise<void>;
+        deleteTemplatesByNameAndVersion: (name: string, version: number) => Promise<void>;
+        getTemplateByNameAndVersion: (name: string, version: number) => Promise<HumanTaskTemplate>;
+    };
+    taskResource: {
+        poll: (tasktype: string, workerid?: string, domain?: string) => Promise<Task>;
+        allVerbose: () => Promise<{
+            [key: string]: {
+                [key: string]: {
+                    [key: string]: number;
+                };
+            };
+        }>;
+        updateTask: (workflowId: string, taskRefName: string, status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED", requestBody: any) => Promise<string>;
+        getTask: (taskId: string) => Promise<Task>;
+        all: () => Promise<{
+            [key: string]: number;
+        }>;
+        requeuePendingTask: (taskType: string) => Promise<string>;
+        search: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultTaskSummary>;
+        searchV22: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
+        getPollData: (taskType: string) => Promise<PollData[]>;
+        getTaskLogs: (taskId: string) => Promise<TaskExecLog[]>;
+        log: (taskId: string, requestBody: string) => Promise<void>;
+        getAllPollData: () => Promise<{
+            [key: string]: unknown;
+        }>;
+        batchPoll: (tasktype: string, workerid?: string, domain?: string, count?: number, timeout?: number) => Promise<Task[]>;
+        updateTask1: (requestBody: any) => Promise<string>;
+        size1: (taskType?: string[]) => Promise<{
+            [key: string]: number;
+        }>;
+        getExternalStorageLocation1: (path: string, operation: string, payloadType: string) => Promise<any>;
+        updateTaskSync: (workflowId: string, taskRefName: string, status: any, output: any, workerId?: string) => Promise<Workflow>;
+        signal: (workflowId: string, status: any, output: any, returnStrategy?: any) => Promise<SignalResponse$1>;
+        signalAsync: (workflowId: string, status: any, output: any) => Promise<SignalResponse>;
+    };
+    buildUrl: <TData extends {
+        body?: unknown;
+        path?: Record<string, unknown>;
+        query?: Record<string, unknown>;
+        url: string;
+    }>(options: Pick<TData, "url"> & Options<TData>) => string;
+    getConfig: () => Config$1<ClientOptions>;
+    request: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    setConfig: (config: Config$1<ClientOptions>) => Config$1<ClientOptions>;
+    connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+    sse: {
+        connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+        trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
+    };
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+}>;
 
-type TaskFinderPredicate = (task: Task) => boolean;
-declare const completedTaskMatchingType: (taskType: string) => TaskFinderPredicate;
-declare class WorkflowExecutor {
+declare class ApplicationClient {
     readonly _client: Client;
     constructor(client: Client);
     /**
-     * Will persist a workflow in conductor
-     * @param override If true will override the existing workflow with the definition
-     * @param workflow Complete workflow definition
-     * @returns null
+     * Get all applications
+     * @returns {Promise<ExtendedConductorApplication[]>}
+     * @throws {ConductorSdkError}
      */
-    registerWorkflow(override: boolean, workflow: WorkflowDef$1): Promise<void>;
+    getAllApplications(): Promise<ExtendedConductorApplication[]>;
     /**
-     * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
-     * @param workflowRequest
-     * @returns
+     * Create an application
+     * @param {string} applicationName
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
+    createApplication(applicationName: string): Promise<ExtendedConductorApplication>;
     /**
-     * Execute a workflow synchronously (original method - backward compatible)
+     * Get application by access key id
+     * @param {string} accessKeyId
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
+    getAppByAccessKeyId(accessKeyId: string): Promise<ExtendedConductorApplication>;
     /**
-     * Execute a workflow with return strategy support (new method)
+     * Delete an access key
+     * @param {string} applicationId
+     * @param {string} keyId
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string, waitForSeconds: number, consistency: Consistency, returnStrategy: ReturnStrategy): Promise<EnhancedSignalResponse>;
-    startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise<string>[];
-    goBackToTask(workflowInstanceId: string, taskFinderPredicate: TaskFinderPredicate, rerunWorkflowRequestOverrides?: Partial<RerunWorkflowRequest>): Promise<void>;
-    goBackToFirstTaskMatchingType(workflowInstanceId: string, taskType: string): Promise<void>;
+    deleteAccessKey(applicationId: string, keyId: string): Promise<void>;
     /**
-     * Takes an workflowInstanceId and an includeTasks and an optional retry parameter returns the whole execution status.
-     * If includeTasks flag is provided. Details of tasks execution will be returned as well,
-     * retry specifies the amount of retrys before throwing an error.
-     *
-     * @param workflowInstanceId
-     * @param includeTasks
-     * @param retry
-     * @returns
+     * Toggle the status of an access key
+     * @param {string} applicationId
+     * @param {string} keyId
+     * @returns {Promise<AccessKeyInfo>}
+     * @throws {ConductorSdkError}
      */
-    getWorkflow(workflowInstanceId: string, includeTasks: boolean, retry?: number): Promise<Workflow>;
+    toggleAccessKeyStatus(applicationId: string, keyId: string): Promise<AccessKeyInfo>;
     /**
-     *  Returns a summary of the current workflow status.
-     *
-     * @param workflowInstanceId current running workflow
-     * @param includeOutput flag to include output
-     * @param includeVariables flag to include variable
-     * @returns Promise<WorkflowStatus>
+     * Remove role from application user
+     * @param {string} applicationId
+     * @param {string} role
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): Promise<WorkflowStatus>;
+    removeRoleFromApplicationUser(applicationId: string, role: string): Promise<void>;
     /**
-     *  Returns a summary of the current workflow status.
-     *
-     * @param workflowInstanceId current running workflow
-     * @param includeOutput flag to include output
-     * @param includeVariables flag to include variable
-     * @returns Promise<WorkflowStatus>
+     * Add role to application
+     * @param {string} applicationId
+     * @param {ApplicationRole} role
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    getExecution(workflowInstanceId: string, includeTasks?: boolean): Promise<Workflow>;
+    addApplicationRole(applicationId: string, role: ApplicationRole): Promise<void>;
     /**
-     * Pauses a running workflow
-     * @param workflowInstanceId current workflow execution
-     * @returns
+     * Delete an application
+     * @param {string} applicationId
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    pause(workflowInstanceId: string): Promise<void>;
+    deleteApplication(applicationId: string): Promise<void>;
     /**
-     * Reruns workflowInstanceId workflow. with new parameters
-     *
-     * @param workflowInstanceId current workflow execution
-     * @param rerunWorkflowRequest Rerun Workflow Execution Request
-     * @returns
+     * Get an application by id
+     * @param {string} applicationId
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial<RerunWorkflowRequest>): Promise<string>;
+    getApplication(applicationId: string): Promise<ExtendedConductorApplication>;
     /**
-     * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
-     * @param workflowInstanceId
-     * @param useLatestDefinitions
-     * @returns
+     * Update an application
+     * @param {string} applicationId
+     * @param {string} newApplicationName
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    restart(workflowInstanceId: string, useLatestDefinitions: boolean): Promise<void>;
+    updateApplication(applicationId: string, newApplicationName: string): Promise<ExtendedConductorApplication>;
     /**
-     * Resumes a previously paused execution
-     *
-     * @param workflowInstanceId Running workflow workflowInstanceId
-     * @returns
+     * Get application's access keys
+     * @param {string} applicationId
+     * @returns {Promise<AccessKeyInfo[]>}
+     * @throws {ConductorSdkError}
      */
-    resume(workflowInstanceId: string): Promise<void>;
+    getAccessKeys(applicationId: string): Promise<AccessKeyInfo[]>;
     /**
-     * Retrys workflow from last failing task
-     * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows
-     *
-     * @param workflowInstanceId
-     * @param resumeSubworkflowTasks
-     * @returns
+     * Create an access key for an application
+     * @param {string} applicationId
+     * @returns {Promise<AccessKey>}
+     * @throws {ConductorSdkError}
      */
-    retry(workflowInstanceId: string, resumeSubworkflowTasks: boolean): Promise<void>;
+    createAccessKey(applicationId: string): Promise<AccessKey>;
     /**
-     * Searches for existing workflows given the following querys
-     *
-     * @param start
-     * @param size
-     * @param query
-     * @param freeText
-     * @param sort
-     * @param skipCache
-     * @returns
+     * Delete application tags
+     * @param {string} applicationId
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    search(start: number, size: number, query: string, freeText: string, sort?: string, skipCache?: boolean): Promise<ScrollableSearchResultWorkflowSummary>;
+    deleteApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
     /**
-     * Skips a task of a running workflow.
-     * by providing a skipTaskRequest you can set the input and the output of the skipped tasks
-     * @param workflowInstanceId
-     * @param taskReferenceName
-     * @param skipTaskRequest
-     * @returns
+     * Delete a single application tag
+     * @param {string} applicationId
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    skipTasksFromWorkflow(workflowInstanceId: string, taskReferenceName: string, skipTaskRequest: Partial<SkipTaskRequest>): Promise<void>;
+    deleteApplicationTag(applicationId: string, tag: Tag): Promise<void>;
     /**
-     * Takes an workflowInstanceId, and terminates a running workflow
-     * @param workflowInstanceId
-     * @param reason
-     * @returns
+     * Get application tags
+     * @param {string} applicationId
+     * @returns {Promise<Tag[]>}
+     * @throws {ConductorSdkError}
      */
-    terminate(workflowInstanceId: string, reason: string): Promise<void>;
+    getApplicationTags(applicationId: string): Promise<Tag[]>;
     /**
-     * Takes a taskId and a workflowInstanceId. Will update the task for the corresponding taskId
-     * @param taskId
-     * @param workflowInstanceId
-     * @param taskStatus
-     * @param taskOutput
-     * @returns
+     * Add application tags
+     * @param {string} applicationId
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: TaskResultOutputData): Promise<string>;
+    addApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
     /**
-     * Updates a task by reference Name
-     * @param taskReferenceName
-     * @param workflowInstanceId
-     * @param status
-     * @param taskOutput
-     * @returns
+     * Add a single application tag
+     * @param {string} applicationId
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: TaskResultOutputData): Promise<string>;
+    addApplicationTag(applicationId: string, tag: Tag): Promise<void>;
+}
+
+declare class EventClient {
+    readonly _client: Client;
+    constructor(client: Client);
     /**
-     *
-     * @param taskId
-     * @returns
+     * Get all the event handlers
+     * @returns {Promise<EventHandler[]>}
+     * @throws {ConductorSdkError}
      */
-    getTask(taskId: string): Promise<Task>;
+    getAllEventHandlers(): Promise<EventHandler[]>;
     /**
-     * Updates a task by reference name synchronously and returns the complete workflow
-     * @param taskReferenceName
-     * @param workflowInstanceId
-     * @param status
-     * @param taskOutput
-     * @param workerId - Optional
-     * @returns Promise<Workflow>
+     * Add event handlers
+     * @param {EventHandler[]} eventHandlers
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    updateTaskSync(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, workerId?: string): Promise<Workflow>;
+    addEventHandlers(eventHandlers: EventHandler[]): Promise<void>;
     /**
-     * Signals a workflow task and returns data based on the specified return strategy
-     * @param workflowInstanceId - Workflow instance ID to signal
-     * @param status - Task status to set
-     * @param taskOutput - Output data for the task
-     * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
-     * @returns Promise<SignalResponse> with data based on the return strategy
+     * Add an event handler
+     * @param {EventHandler} eventHandler
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    signal(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, returnStrategy?: ReturnStrategy): Promise<EnhancedSignalResponse>;
+    addEventHandler(eventHandler: EventHandler): Promise<void>;
     /**
-     * Signals a workflow task asynchronously (fire-and-forget)
-     * @param workflowInstanceId - Workflow instance ID to signal
-     * @param status - Task status to set
-     * @param taskOutput - Output data for the task
-     * @returns Promise<void>
+     * Update an event handler
+     * @param {EventHandler} eventHandler
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    signalAsync(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData): Promise<void>;
-}
-
-interface PollIntervalOptions {
-    pollInterval: number;
-    maxPollTimes: number;
-}
-declare class HumanExecutor {
-    readonly _client: Client;
-    constructor(client: Client);
+    updateEventHandler(eventHandler: EventHandler): Promise<void>;
     /**
-     * @deprecated use search instead
-     * Takes a set of filter parameters. return matches of human tasks for that set of parameters
-     * @param state
-     * @param assignee
-     * @param assigneeType
-     * @param claimedBy
-     * @param taskName
-     * @param freeText
-     * @param includeInputOutput
-     * @returns
+     * Handle an incoming event
+     * @param {Record<string, string>} data
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    getTasksByFilter(state: "PENDING" | "ASSIGNED" | "IN_PROGRESS" | "COMPLETED" | "TIMED_OUT", assignee?: string, assigneeType?: "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP", claimedBy?: string, taskName?: string, taskInputQuery?: string, taskOutputQuery?: string): Promise<HumanTaskEntry[]>;
+    handleIncomingEvent(data: Record<string, string>): Promise<void>;
     /**
-     * Takes a set of filter parameters. return matches of human tasks for that set of parameters
-     * @param state
-     * @param assignee
-     * @param assigneeType
-     * @param claimedBy
-     * @param taskName
-     * @param freeText
-     * @param includeInputOutput
-     * @returns Promise<HumanTaskEntry[]>
+     * Get an event handler by name
+     * @param {string} eventHandlerName
+     * @returns {Promise<EventHandler>}
+     * @throws {ConductorSdkError}
      */
-    search(searchParams: Partial<HumanTaskSearch>): Promise<HumanTaskEntry[]>;
+    getEventHandlerByName(eventHandlerName: string): Promise<EventHandler>;
     /**
-     * Takes a set of filter parameters. An polling interval options. will poll until the task returns a result
-     * @param state
-     * @param assignee
-     * @param assigneeType
-     * @param claimedBy
-     * @param taskName
-     * @param freeText
-     * @param includeInputOutput
-     * @returns Promise<HumanTaskEntry[]>
+     * Get all queue configs
+     * @returns {Promise<Record<string, string>>}
+     * @throws {ConductorSdkError}
      */
-    pollSearch(searchParams: Partial<HumanTaskSearch>, { pollInterval, maxPollTimes, }?: PollIntervalOptions): Promise<HumanTaskEntry[]>;
+    getAllQueueConfigs(): Promise<Record<string, string>>;
     /**
-     * Returns task for a given task id
-     * @param taskId
-     * @returns
+     * Delete queue config
+     * @param {string} queueType
+     * @param {string} queueName
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    getTaskById(taskId: string): Promise<HumanTaskEntry>;
+    deleteQueueConfig(queueType: string, queueName: string): Promise<void>;
     /**
-     * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
-     * @param taskId
-     * @param assignee
-     * @returns
+     * Get queue config
+     * @param {string} queueType
+     * @param {string} queueName
+     * @returns {Promise<Record<string, unknown>>}
+     * @throws {ConductorSdkError}
      */
-    claimTaskAsExternalUser(taskId: string, assignee: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    getQueueConfig(queueType: string, queueName: string): Promise<Record<string, unknown>>;
     /**
-     * Claim task as conductor user
-     * @param taskId
-     * @returns
+     * Get event handlers for a given event
+     * @param {string} event
+     * @param {boolean} [activeOnly=false] Only return active handlers.
+     * @returns {Promise<EventHandler[]>}
+     * @throws {ConductorSdkError}
      */
-    claimTaskAsConductorUser(taskId: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    getEventHandlersForEvent(event: string, activeOnly?: boolean): Promise<EventHandler[]>;
     /**
-     * Claim task as conductor user
-     * @param taskId
-     * @param assignee
-     * @returns
+     * Remove an event handler by name
+     * @param {string} name
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    releaseTask(taskId: string): Promise<void>;
+    removeEventHandler(name: string): Promise<void>;
     /**
-     * Returns a HumanTaskTemplateEntry for a given name and version
-     * @param templateId
-     * @returns
+     * Get tags for an event handler
+     * @param {string} name
+     * @returns {Promise<Tag[]>}
+     * @throws {ConductorSdkError}
      */
-    getTemplateByNameVersion(name: string, version: number): Promise<HumanTaskTemplate>;
+    getTagsForEventHandler(name: string): Promise<Tag[]>;
     /**
-     * @deprecated use getTemplate instead. name will be used as id here with version 1
-     * Returns a HumanTaskTemplateEntry for a given templateId
-     * @param templateId
-     * @returns
+     * Put tags for an event handler
+     * @param {string} name
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    getTemplateById(templateNameVersionOne: string): Promise<HumanTaskTemplate>;
+    putTagForEventHandler(name: string, tags: Tag[]): Promise<void>;
     /**
-     * Takes a taskId and a partial body. will update with given body
-     * @param taskId
-     * @param requestBody
+     * Delete tags for an event handler
+     * @param {string} name
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, unknown>>): Promise<void>;
+    deleteTagsForEventHandler(name: string, tags: Tag[]): Promise<void>;
     /**
-     * Takes a taskId and an optional partial body. will complete the task with the given body
-     * @param taskId
-     * @param requestBody
+     * Delete a tag for an event handler
+     * @param {string} name
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
+    deleteTagForEventHandler(name: string, tag: Tag): Promise<void>;
+    /**
+     * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
+     * @param {ConnectivityTestInput} input
+     * @returns {Promise<ConnectivityTestResult>}
+     * @throws {ConductorSdkError}
+     */
+    testConnectivity(input: ConnectivityTestInput): Promise<ConnectivityTestResult>;
+    /**
+     * Create or update queue config by name
+     * @deprecated Prefer server's newer endpoints if available
+     * @param {string} queueType
+     * @param {string} queueName
+     * @param {string} config
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    putQueueConfig(queueType: string, queueName: string, config: string): Promise<void>;
+    /**
+     * Test endpoint (as exposed by API)
+     * @returns {Promise<EventHandler>}
+     * @throws {ConductorSdkError}
+     */
+    test(): Promise<EventHandler>;
+    /**
+     * Get all active event handlers (execution view)
+     * @returns {Promise<SearchResultHandledEventResponse>}
+     * @throws {ConductorSdkError}
+     */
+    getAllActiveEventHandlers(): Promise<SearchResultHandledEventResponse>;
+    /**
+     * Get event executions for a specific handler
+     * @param {string} eventHandlerName
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<ExtendedEventExecution[]>}
+     * @throws {ConductorSdkError}
+     */
+    getEventExecutions(eventHandlerName: string, from?: number): Promise<ExtendedEventExecution[]>;
+    /**
+     * Get all event handlers with statistics (messages view)
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<SearchResultHandledEventResponse>}
+     * @throws {ConductorSdkError}
+     */
+    getEventHandlersWithStats(from?: number): Promise<SearchResultHandledEventResponse>;
+    /**
+     * Get event messages for a given event
+     * @param {string} event
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<EventMessage[]>}
+     * @throws {ConductorSdkError}
+     */
+    getEventMessages(event: string, from?: number): Promise<EventMessage[]>;
 }
 
-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 dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string, optional?: boolean) => ForkJoinDynamicDef;
-
-declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string, optional?: boolean) => EventTaskDef;
-declare const sqsEventTask: (taskReferenceName: string, queueName: string, optional?: boolean) => EventTaskDef;
-declare const conductorEventTask: (taskReferenceName: string, eventName: string, optional?: boolean) => EventTaskDef;
-
-declare const forkTask: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => ForkJoinTaskDef;
-declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[], optional?: boolean) => [ForkJoinTaskDef, JoinTaskDef];
-
-declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters, asyncComplete?: boolean, optional?: boolean) => HttpTaskDef;
-
-declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs", optional?: boolean) => InlineTaskDef;
-
-declare const joinTask: (taskReferenceName: string, joinOn: string[], optional?: boolean) => JoinTaskDef;
-
-declare const jsonJqTask: (taskReferenceName: string, script: string, optional?: boolean) => JsonJQTransformTaskDef;
-
-declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters, optional?: boolean) => KafkaPublishTaskDef;
-
-declare const setVariableTask: (taskReferenceName: string, inputParameters: Record<string, unknown>, optional?: boolean) => SetVariableTaskDef;
-
-declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>, optional?: boolean) => SimpleTaskDef;
-
-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;
-
-declare const taskDefinition: ({ name, ownerApp, description, retryCount, timeoutSeconds, inputKeys, outputKeys, timeoutPolicy, retryLogic, retryDelaySeconds, responseTimeoutSeconds, concurrentExecLimit, inputTemplate, rateLimitPerFrequency, rateLimitFrequencyInSeconds, ownerEmail, pollTimeoutSeconds, backoffScaleFactor, }: ExtendedTaskDef) => TaskDef;
-
-declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string) => TerminateTaskDef;
-
-declare const waitTaskDuration: (taskReferenceName: string, duration: string, optional?: boolean) => WaitTaskDef;
-declare const waitTaskUntil: (taskReferenceName: string, until: string, optional?: boolean) => WaitTaskDef;
-
-declare const workflow: (name: string, tasks: TaskDefTypes[]) => WorkflowDef$1;
-
-/**
- * Takes an optional partial SimpleTaskDef
- * generates a task replacing default values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateSimpleTask: (overrides?: Partial<SimpleTaskDef>) => SimpleTaskDef;
-
-/**
- * Takes an optional partial EventTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateEventTask: (overrides?: Partial<EventTaskDef>) => EventTaskDef;
-
-type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
-interface WorkflowDefGen extends Omit<WorkflowDef$1, "tasks"> {
-    tasks: Partial<TaskDefTypesGen>[];
+interface ConductorLogger {
+    info(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
 }
-type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
-    forkTasks: Partial<TaskDefTypesGen>[][];
-};
-type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
-    decisionCases: Record<string, Partial<TaskDefTypesGen>[]>;
-    defaultCase: Partial<TaskDefTypesGen>[];
-};
-type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
-    loopOver: Partial<TaskDefTypesGen>[];
-};
-interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "expression"> {
-    expression: string | ((...args: never[]) => unknown);
+type ConductorLogLevel = keyof typeof LOG_LEVELS;
+interface DefaultLoggerConfig {
+    level?: ConductorLogLevel;
+    tags?: object[];
 }
-interface InlineTaskDefGen extends Omit<InlineTaskDef, "inputParameters"> {
-    inputParameters: InlineTaskInputParametersGen;
+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;
 }
-type NestedTaskMapper = (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
+declare const noopLogger: ConductorLogger;
 
-declare const generateJoinTask: (overrides?: Partial<JoinTaskDef>) => JoinTaskDef;
+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;
+}
 
 /**
- * Takes an optional partial HttpTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
+ * Responsible for initializing and managing the runners that poll and work different task queues.
  */
-declare const generateHTTPTask: (overrides?: Partial<HttpTaskDef>) => HttpTaskDef;
+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>;
+}
 
 /**
- * Takes an optional partial InlineTaskDefGen
- * generates a task replacing default/fake values with provided overrides
+ * Responsible for polling and executing tasks from a queue.
  *
- * <b>note</b> that the inputParameters.expression can be either a string containing javascript
- * or a function thar returns an ES5 function
+ * 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.
  *
- * @param overrides overrides for defaults
- * @returns a fully defined task
  */
-declare const generateInlineTask: (override?: Partial<InlineTaskDefGen>) => InlineTaskDef;
+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;
+}
 
-/**
- * Takes an optional partial JsonJQTransformTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateJQTransformTask: (overrides?: Partial<JsonJQTransformTaskDef>) => JsonJQTransformTaskDef;
-
-/**
- * Takes an optional partial KafkaPublishTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateKafkaPublishTask: (overrides?: Partial<KafkaPublishTaskDef>) => KafkaPublishTaskDef;
-
-/**
- * Takes an optional partial SubWorkflowTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateSubWorkflowTask: (overrides?: Partial<SubWorkflowTaskDef>) => SubWorkflowTaskDef;
-
-/**
- * Takes an optional partial SetVariableTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateSetVariableTask: (overrides?: Partial<SetVariableTaskDef>) => SetVariableTaskDef;
-
-/**
- * Takes an optional partial TerminateTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateTerminateTask: (overrides?: Partial<TerminateTaskDef>) => TerminateTaskDef;
+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;
+}
 
-/**
- * Takes an optional partial WaitTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateWaitTask: (overrides?: Partial<WaitTaskDef>) => WaitTaskDef;
+type UserType = "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP";
+interface PollIntervalOptions {
+    pollInterval: number;
+    maxPollTimes: number;
+}
 
-declare const taskGenMapper: (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
-/**
- * Takes an optional partial WorkflowDefGen
- * generates a workflow replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generate: (overrides: Partial<WorkflowDefGen>) => WorkflowDef;
+declare class HumanExecutor {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * @deprecated use search instead
+     * Takes a set of filter parameters. return matches of human tasks for that set of parameters
+     * @param state
+     * @param assignee
+     * @param assigneeType
+     * @param claimedBy
+     * @param taskName
+     * @param freeText
+     * @param includeInputOutput
+     * @returns
+     */
+    getTasksByFilter(state: "PENDING" | "ASSIGNED" | "IN_PROGRESS" | "COMPLETED" | "TIMED_OUT", assignee?: string, assigneeType?: "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP", claimedBy?: string, taskName?: string, taskInputQuery?: string, taskOutputQuery?: string): Promise<HumanTaskEntry[]>;
+    /**
+     * Takes a set of filter parameters. return matches of human tasks for that set of parameters
+     * @param state
+     * @param assignee
+     * @param assigneeType
+     * @param claimedBy
+     * @param taskName
+     * @param freeText
+     * @param includeInputOutput
+     * @returns Promise<HumanTaskEntry[]>
+     */
+    search(searchParams: Partial<HumanTaskSearch>): Promise<HumanTaskEntry[]>;
+    /**
+     * Takes a set of filter parameters. An polling interval options. will poll until the task returns a result
+     * @param state
+     * @param assignee
+     * @param assigneeType
+     * @param claimedBy
+     * @param taskName
+     * @param freeText
+     * @param includeInputOutput
+     * @returns Promise<HumanTaskEntry[]>
+     */
+    pollSearch(searchParams: Partial<HumanTaskSearch>, { pollInterval, maxPollTimes, }?: PollIntervalOptions): Promise<HumanTaskEntry[]>;
+    /**
+     * Returns task for a given task id
+     * @param taskId
+     * @returns
+     */
+    getTaskById(taskId: string): Promise<HumanTaskEntry>;
+    /**
+     * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
+     * @param taskId
+     * @param assignee
+     * @returns
+     */
+    claimTaskAsExternalUser(taskId: string, assignee: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    /**
+     * Claim task as conductor user
+     * @param taskId
+     * @returns
+     */
+    claimTaskAsConductorUser(taskId: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    /**
+     * Claim task as conductor user
+     * @param taskId
+     * @param assignee
+     * @returns
+     */
+    releaseTask(taskId: string): Promise<void>;
+    /**
+     * Returns a HumanTaskTemplateEntry for a given name and version
+     * @param templateId
+     * @returns
+     */
+    getTemplateByNameVersion(name: string, version: number): Promise<HumanTaskTemplate>;
+    /**
+     * @deprecated use getTemplate instead. name will be used as id here with version 1
+     * Returns a HumanTaskTemplateEntry for a given templateId
+     * @param templateId
+     * @returns
+     */
+    getTemplateById(templateNameVersionOne: string): Promise<HumanTaskTemplate>;
+    /**
+     * Takes a taskId and a partial body. will update with given body
+     * @param taskId
+     * @param requestBody
+     */
+    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, unknown>>): Promise<void>;
+    /**
+     * Takes a taskId and an optional partial body. will complete the task with the given body
+     * @param taskId
+     * @param requestBody
+     */
+    completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
+}
 
-/**
- * Takes an optional partial SwitchTaskDefGen and an optional nestedMapper
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @param nestedTasksMapper function to run on array of nested tasks
- * @returns a fully defined task
- */
-declare const generateSwitchTask: (overrides?: Partial<SwitchTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => SwitchTaskDef;
-/**
- * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @param nestedTasksMapper function to run on array of nested tasks
- * @returns a fully defined task
- */
-declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => DoWhileTaskDef;
-/**
- * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @param nestedTasksMapper function to run on array of nested tasks
- * @returns a fully defined task
- */
-declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
+declare class MetadataClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Unregisters an existing task definition by name
+     *
+     * @param name
+     * @returns
+     */
+    unregisterTask(name: string): Promise<void>;
+    /**
+     * Registers a new task definition
+     *
+     * @param taskDef
+     * @returns
+     */
+    registerTask(taskDef: ExtendedTaskDef): Promise<void>;
+    /**
+     * Registers multiple task definitions (array)
+     *
+     * @param taskDefs
+     * @returns
+     */
+    registerTasks(taskDefs: ExtendedTaskDef[]): Promise<void>;
+    /**
+     * Update an existing task definition
+     *
+     * @param taskDef
+     * @returns
+     */
+    updateTask(taskDef: ExtendedTaskDef): Promise<void>;
+    /**
+     * Get an existing task definition
+     *
+     * @param taskName
+     * @returns
+     */
+    getTask(taskName: string): Promise<TaskDef>;
+    /**
+     * Creates or updates (overwrite: true) a workflow definition
+     *
+     * @param workflowDef
+     * @param overwrite
+     * @returns
+     */
+    registerWorkflowDef(workflowDef: ExtendedWorkflowDef, overwrite?: boolean): Promise<void>;
+    /**
+     * Creates or updates (overwrite: true) a workflow definition
+     *
+     * @param workflowDef
+     * @param overwrite
+     * @returns
+     */
+    getWorkflowDef(name: string, version?: number, metadata?: boolean): Promise<WorkflowDef>;
+    /**
+     * Unregister (overwrite: true) a workflow definition
+     *
+     * @param workflowDef
+     * @param overwrite
+     * @returns
+     */
+    unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
+}
 
 declare class SchedulerClient {
     readonly _client: Client;
@@ -3556,7 +3785,107 @@ declare class SchedulerClient {
     resumeAllSchedules(): Promise<void>;
 }
 
-declare class TaskClient {
+/**
+ * Client for interacting with the Service Registry API
+ */
+declare class ServiceRegistryClient {
+    readonly _client: Client;
+    constructor(client: Client);
+    /**
+     * Retrieve all registered services
+     * @returns Array of all registered services
+     */
+    getRegisteredServices(): Promise<ServiceRegistry[]>;
+    /**
+     * Remove a service by name
+     * @param name The name of the service to remove
+     * @returns Promise that resolves when service is removed
+     */
+    removeService(name: string): Promise<void>;
+    /**
+     * Get a service by name
+     * @param name The name of the service to retrieve
+     * @returns The requested service registry
+     */
+    getService(name: string): Promise<ServiceRegistry | undefined>;
+    /**
+     * Open the circuit breaker for a service
+     * @param name The name of the service
+     * @returns Response with circuit breaker status
+     */
+    openCircuitBreaker(name: string): Promise<CircuitBreakerTransitionResponse>;
+    /**
+     * Close the circuit breaker for a service
+     * @param name The name of the service
+     * @returns Response with circuit breaker status
+     */
+    closeCircuitBreaker(name: string): Promise<CircuitBreakerTransitionResponse>;
+    /**
+     * Get circuit breaker status for a service
+     * @param name The name of the service
+     * @returns Response with circuit breaker status
+     */
+    getCircuitBreakerStatus(name: string): Promise<CircuitBreakerTransitionResponse>;
+    /**
+     * Add or update a service registry
+     * @param serviceRegistry The service registry to add or update
+     * @returns Promise that resolves when service is added or updated
+     */
+    addOrUpdateService(serviceRegistry: ServiceRegistry): Promise<void>;
+    /**
+     * Add or update a service method
+     * @param registryName The name of the registry
+     * @param method The service method to add or update
+     * @returns Promise that resolves when method is added or updated
+     */
+    addOrUpdateServiceMethod(registryName: string, method: ServiceMethod): Promise<void>;
+    /**
+     * Remove a service method
+     * @param registryName The name of the registry
+     * @param serviceName The name of the service
+     * @param method The name of the method
+     * @param methodType The type of the method
+     * @returns Promise that resolves when method is removed
+     */
+    removeMethod(registryName: string, serviceName: string, method: string, methodType: string): Promise<void>;
+    /**
+     * Get proto data
+     * @param registryName The name of the registry
+     * @param filename The name of the proto file
+     * @returns The proto file data as a Blob
+     */
+    getProtoData(registryName: string, filename: string): Promise<Blob>;
+    /**
+     * Set proto data
+     * @param registryName The name of the registry
+     * @param filename The name of the proto file
+     * @param data The proto file data
+     * @returns Promise that resolves when proto data is set
+     */
+    setProtoData(registryName: string, filename: string, data: Blob): Promise<void>;
+    /**
+     * Delete a proto file
+     * @param registryName The name of the registry
+     * @param filename The name of the proto file
+     * @returns Promise that resolves when proto file is deleted
+     */
+    deleteProto(registryName: string, filename: string): Promise<void>;
+    /**
+     * Get all proto files for a registry
+     * @param registryName The name of the registry
+     * @returns List of proto registry entries
+     */
+    getAllProtos(registryName: string): Promise<ProtoRegistryEntry[]>;
+    /**
+     * Discover service methods
+     * @param name The name of the service
+     * @param create Whether to create the discovered methods (defaults to false)
+     * @returns The discovered service methods
+     */
+    discover(name: string, create?: boolean): Promise<ServiceMethod[]>;
+}
+
+declare class TaskClient {
     readonly _client: Client;
     constructor(client: Client);
     /**
@@ -3601,453 +3930,400 @@ declare class TemplateClient {
     registerTemplate(template: HumanTaskTemplate, asNewVersion?: boolean): Promise<HumanTaskTemplate>;
 }
 
-declare class MetadataClient {
+interface EnhancedSignalResponse extends SignalResponse {
+    isTargetWorkflow(): boolean;
+    isBlockingWorkflow(): boolean;
+    isBlockingTask(): boolean;
+    isBlockingTaskInput(): boolean;
+    getWorkflow(): Workflow;
+    getBlockingTask(): Task;
+    getTaskInput(): Record<string, unknown>;
+    getWorkflowId(): string;
+    getTargetWorkflowId(): string;
+    hasWorkflowData(): boolean;
+    hasTaskData(): boolean;
+    getResponseType(): string;
+    isTerminal(): boolean;
+    isRunning(): boolean;
+    isPaused(): boolean;
+    getSummary(): string;
+    toDebugJSON(): Record<string, unknown>;
+    toString(): string;
+}
+type TaskFinderPredicate = (task: Task) => boolean;
+
+declare class WorkflowExecutor {
     readonly _client: Client;
     constructor(client: Client);
     /**
-     * Unregisters an existing task definition by name
-     *
-     * @param name
-     * @returns
+     * Will persist a workflow in conductor
+     * @param override If true will override the existing workflow with the definition
+     * @param workflow Complete workflow definition
+     * @returns null
      */
-    unregisterTask(name: string): Promise<void>;
+    registerWorkflow(override: boolean, workflow: WorkflowDef): Promise<void>;
     /**
-     * Registers a new task definition
-     *
-     * @param taskDef
+     * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
+     * @param workflowRequest
      * @returns
      */
-    registerTask(taskDef: ExtendedTaskDef): Promise<void>;
+    startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
     /**
-     * Registers multiple task definitions (array)
+     * Execute a workflow synchronously (original method - backward compatible)
+     */
+    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
+    /**
+     * Execute a workflow with return strategy support (new method)
+     */
+    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string, waitForSeconds: number, consistency: Consistency, returnStrategy: ReturnStrategy): Promise<EnhancedSignalResponse>;
+    startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise<string>[];
+    goBackToTask(workflowInstanceId: string, taskFinderPredicate: TaskFinderPredicate, rerunWorkflowRequestOverrides?: Partial<RerunWorkflowRequest>): Promise<void>;
+    goBackToFirstTaskMatchingType(workflowInstanceId: string, taskType: string): Promise<void>;
+    /**
+     * Takes an workflowInstanceId and an includeTasks and an optional retry parameter returns the whole execution status.
+     * If includeTasks flag is provided. Details of tasks execution will be returned as well,
+     * retry specifies the amount of retrys before throwing an error.
      *
-     * @param taskDefs
+     * @param workflowInstanceId
+     * @param includeTasks
+     * @param retry
      * @returns
      */
-    registerTasks(taskDefs: ExtendedTaskDef[]): Promise<void>;
+    getWorkflow(workflowInstanceId: string, includeTasks: boolean, retry?: number): Promise<Workflow>;
     /**
-     * Update an existing task definition
+     *  Returns a summary of the current workflow status.
      *
-     * @param taskDef
-     * @returns
+     * @param workflowInstanceId current running workflow
+     * @param includeOutput flag to include output
+     * @param includeVariables flag to include variable
+     * @returns Promise<WorkflowStatus>
      */
-    updateTask(taskDef: ExtendedTaskDef): Promise<void>;
+    getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): Promise<WorkflowStatus>;
     /**
-     * Get an existing task definition
+     *  Returns a summary of the current workflow status.
      *
-     * @param taskName
+     * @param workflowInstanceId current running workflow
+     * @param includeOutput flag to include output
+     * @param includeVariables flag to include variable
+     * @returns Promise<WorkflowStatus>
+     */
+    getExecution(workflowInstanceId: string, includeTasks?: boolean): Promise<Workflow>;
+    /**
+     * Pauses a running workflow
+     * @param workflowInstanceId current workflow execution
      * @returns
      */
-    getTask(taskName: string): Promise<TaskDef>;
+    pause(workflowInstanceId: string): Promise<void>;
     /**
-     * Creates or updates (overwrite: true) a workflow definition
+     * Reruns workflowInstanceId workflow. with new parameters
      *
-     * @param workflowDef
-     * @param overwrite
+     * @param workflowInstanceId current workflow execution
+     * @param rerunWorkflowRequest Rerun Workflow Execution Request
      * @returns
      */
-    registerWorkflowDef(workflowDef: ExtendedWorkflowDef, overwrite?: boolean): Promise<void>;
+    reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial<RerunWorkflowRequest>): Promise<string>;
     /**
-     * Creates or updates (overwrite: true) a workflow definition
-     *
-     * @param workflowDef
-     * @param overwrite
+     * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
+     * @param workflowInstanceId
+     * @param useLatestDefinitions
      * @returns
      */
-    getWorkflowDef(name: string, version?: number, metadata?: boolean): Promise<WorkflowDef$1>;
+    restart(workflowInstanceId: string, useLatestDefinitions: boolean): Promise<void>;
     /**
-     * Unregister (overwrite: true) a workflow definition
+     * Resumes a previously paused execution
      *
-     * @param workflowDef
-     * @param overwrite
+     * @param workflowInstanceId Running workflow workflowInstanceId
      * @returns
      */
-    unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
-}
-
-declare class EventClient {
-    readonly _client: Client;
-    constructor(client: Client);
+    resume(workflowInstanceId: string): Promise<void>;
     /**
-     * Get all the event handlers
-     * @returns {Promise<EventHandler[]>}
-     * @throws {ConductorSdkError}
+     * Retrys workflow from last failing task
+     * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows
+     *
+     * @param workflowInstanceId
+     * @param resumeSubworkflowTasks
+     * @returns
      */
-    getAllEventHandlers(): Promise<EventHandler[]>;
+    retry(workflowInstanceId: string, resumeSubworkflowTasks: boolean): Promise<void>;
     /**
-     * Add event handlers
-     * @param {EventHandler[]} eventHandlers
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Searches for existing workflows given the following querys
+     *
+     * @param start
+     * @param size
+     * @param query
+     * @param freeText
+     * @param sort
+     * @param skipCache
+     * @returns
      */
-    addEventHandlers(eventHandlers: EventHandler[]): Promise<void>;
+    search(start: number, size: number, query: string, freeText: string, sort?: string, skipCache?: boolean): Promise<ScrollableSearchResultWorkflowSummary>;
     /**
-     * Add an event handler
-     * @param {EventHandler} eventHandler
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Skips a task of a running workflow.
+     * by providing a skipTaskRequest you can set the input and the output of the skipped tasks
+     * @param workflowInstanceId
+     * @param taskReferenceName
+     * @param skipTaskRequest
+     * @returns
      */
-    addEventHandler(eventHandler: EventHandler): Promise<void>;
+    skipTasksFromWorkflow(workflowInstanceId: string, taskReferenceName: string, skipTaskRequest: Partial<SkipTaskRequest>): Promise<void>;
     /**
-     * Update an event handler
-     * @param {EventHandler} eventHandler
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Takes an workflowInstanceId, and terminates a running workflow
+     * @param workflowInstanceId
+     * @param reason
+     * @returns
      */
-    updateEventHandler(eventHandler: EventHandler): Promise<void>;
+    terminate(workflowInstanceId: string, reason: string): Promise<void>;
     /**
-     * Handle an incoming event
-     * @param {Record<string, string>} data
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Takes a taskId and a workflowInstanceId. Will update the task for the corresponding taskId
+     * @param taskId
+     * @param workflowInstanceId
+     * @param taskStatus
+     * @param taskOutput
+     * @returns
      */
-    handleIncomingEvent(data: Record<string, string>): Promise<void>;
+    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: TaskResultOutputData): Promise<string>;
     /**
-     * Get an event handler by name
-     * @param {string} eventHandlerName
-     * @returns {Promise<EventHandler>}
-     * @throws {ConductorSdkError}
+     * Updates a task by reference Name
+     * @param taskReferenceName
+     * @param workflowInstanceId
+     * @param status
+     * @param taskOutput
+     * @returns
      */
-    getEventHandlerByName(eventHandlerName: string): Promise<EventHandler>;
+    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: TaskResultOutputData): Promise<string>;
     /**
-     * Get all queue configs
-     * @returns {Promise<Record<string, string>>}
-     * @throws {ConductorSdkError}
+     *
+     * @param taskId
+     * @returns
      */
-    getAllQueueConfigs(): Promise<Record<string, string>>;
+    getTask(taskId: string): Promise<Task>;
     /**
-     * Delete queue config
-     * @param {string} queueType
-     * @param {string} queueName
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Updates a task by reference name synchronously and returns the complete workflow
+     * @param taskReferenceName
+     * @param workflowInstanceId
+     * @param status
+     * @param taskOutput
+     * @param workerId - Optional
+     * @returns Promise<Workflow>
      */
-    deleteQueueConfig(queueType: string, queueName: string): Promise<void>;
+    updateTaskSync(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, workerId?: string): Promise<Workflow>;
     /**
-     * Get queue config
-     * @param {string} queueType
-     * @param {string} queueName
-     * @returns {Promise<Record<string, unknown>>}
-     * @throws {ConductorSdkError}
+     * Signals a workflow task and returns data based on the specified return strategy
+     * @param workflowInstanceId - Workflow instance ID to signal
+     * @param status - Task status to set
+     * @param taskOutput - Output data for the task
+     * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
+     * @returns Promise<SignalResponse> with data based on the return strategy
      */
-    getQueueConfig(queueType: string, queueName: string): Promise<Record<string, unknown>>;
+    signal(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, returnStrategy?: ReturnStrategy): Promise<EnhancedSignalResponse>;
     /**
-     * Get event handlers for a given event
-     * @param {string} event
-     * @param {boolean} [activeOnly=false] Only return active handlers.
-     * @returns {Promise<EventHandler[]>}
-     * @throws {ConductorSdkError}
-     */
-    getEventHandlersForEvent(event: string, activeOnly?: boolean): Promise<EventHandler[]>;
-    /**
-     * Remove an event handler by name
-     * @param {string} name
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    removeEventHandler(name: string): Promise<void>;
-    /**
-     * Get tags for an event handler
-     * @param {string} name
-     * @returns {Promise<Tag[]>}
-     * @throws {ConductorSdkError}
-     */
-    getTagsForEventHandler(name: string): Promise<Tag[]>;
-    /**
-     * Put tags for an event handler
-     * @param {string} name
-     * @param {Tag[]} tags
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    putTagForEventHandler(name: string, tags: Tag[]): Promise<void>;
-    /**
-     * Delete tags for an event handler
-     * @param {string} name
-     * @param {Tag[]} tags
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    deleteTagsForEventHandler(name: string, tags: Tag[]): Promise<void>;
-    /**
-     * Delete a tag for an event handler
-     * @param {string} name
-     * @param {Tag} tag
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    deleteTagForEventHandler(name: string, tag: Tag): Promise<void>;
-    /**
-     * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
-     * @param {ConnectivityTestInput} input
-     * @returns {Promise<ConnectivityTestResult>}
-     * @throws {ConductorSdkError}
-     */
-    testConnectivity(input: ConnectivityTestInput): Promise<ConnectivityTestResult>;
-    /**
-     * Create or update queue config by name
-     * @deprecated Prefer server's newer endpoints if available
-     * @param {string} queueType
-     * @param {string} queueName
-     * @param {string} config
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    putQueueConfig(queueType: string, queueName: string, config: string): Promise<void>;
-    /**
-     * Test endpoint (as exposed by API)
-     * @returns {Promise<EventHandler>}
-     * @throws {ConductorSdkError}
-     */
-    test(): Promise<EventHandler>;
-    /**
-     * Get all active event handlers (execution view)
-     * @returns {Promise<SearchResultHandledEventResponse>}
-     * @throws {ConductorSdkError}
-     */
-    getAllActiveEventHandlers(): Promise<SearchResultHandledEventResponse>;
-    /**
-     * Get event executions for a specific handler
-     * @param {string} eventHandlerName
-     * @param {number} [from] Pagination cursor
-     * @returns {Promise<ExtendedEventExecution[]>}
-     * @throws {ConductorSdkError}
-     */
-    getEventExecutions(eventHandlerName: string, from?: number): Promise<ExtendedEventExecution[]>;
-    /**
-     * Get all event handlers with statistics (messages view)
-     * @param {number} [from] Pagination cursor
-     * @returns {Promise<SearchResultHandledEventResponse>}
-     * @throws {ConductorSdkError}
-     */
-    getEventHandlersWithStats(from?: number): Promise<SearchResultHandledEventResponse>;
-    /**
-     * Get event messages for a given event
-     * @param {string} event
-     * @param {number} [from] Pagination cursor
-     * @returns {Promise<EventMessage[]>}
-     * @throws {ConductorSdkError}
+     * Signals a workflow task asynchronously (fire-and-forget)
+     * @param workflowInstanceId - Workflow instance ID to signal
+     * @param status - Task status to set
+     * @param taskOutput - Output data for the task
+     * @returns Promise<void>
      */
-    getEventMessages(event: string, from?: number): Promise<EventMessage[]>;
+    signalAsync(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData): Promise<void>;
 }
 
-interface OrkesApiConfig {
-    serverUrl?: string;
-    keyId?: string;
-    keySecret?: string;
-    refreshTokenInterval?: number;
-    useEnvVars?: boolean;
-    maxHttp2Connections?: number;
+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 dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string, optional?: boolean) => ForkJoinDynamicDef;
+
+declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string, optional?: boolean) => EventTaskDef;
+declare const sqsEventTask: (taskReferenceName: string, queueName: string, optional?: boolean) => EventTaskDef;
+declare const conductorEventTask: (taskReferenceName: string, eventName: string, optional?: boolean) => EventTaskDef;
+
+declare const forkTask: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => ForkJoinTaskDef;
+declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[], optional?: boolean) => [ForkJoinTaskDef, JoinTaskDef];
+
+declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters, asyncComplete?: boolean, optional?: boolean) => HttpTaskDef;
+
+declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs", optional?: boolean) => InlineTaskDef;
+
+declare const joinTask: (taskReferenceName: string, joinOn: string[], optional?: boolean) => JoinTaskDef;
+
+declare const jsonJqTask: (taskReferenceName: string, script: string, optional?: boolean) => JsonJQTransformTaskDef;
+
+declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters, optional?: boolean) => KafkaPublishTaskDef;
+
+declare const setVariableTask: (taskReferenceName: string, inputParameters: Record<string, unknown>, optional?: boolean) => SetVariableTaskDef;
+
+declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>, optional?: boolean) => SimpleTaskDef;
+
+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;
+
+declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string) => TerminateTaskDef;
+
+declare const waitTaskDuration: (taskReferenceName: string, duration: string, optional?: boolean) => WaitTaskDef;
+declare const waitTaskUntil: (taskReferenceName: string, until: string, optional?: boolean) => WaitTaskDef;
+
+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;
+
+/**
+ * Takes an optional partial SimpleTaskDef
+ * generates a task replacing default values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateSimpleTask: (overrides?: Partial<SimpleTaskDef>) => SimpleTaskDef;
+
+/**
+ * Takes an optional partial EventTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateEventTask: (overrides?: Partial<EventTaskDef>) => EventTaskDef;
+
+type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
+interface WorkflowDefGen extends Omit<WorkflowDef, "tasks"> {
+    tasks: Partial<TaskDefTypesGen>[];
 }
+type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
+    forkTasks: Partial<TaskDefTypesGen>[][];
+};
+type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
+    decisionCases: Record<string, Partial<TaskDefTypesGen>[]>;
+    defaultCase: Partial<TaskDefTypesGen>[];
+};
+type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
+    loopOver: Partial<TaskDefTypesGen>[];
+};
+interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "expression"> {
+    expression: string | ((...args: never[]) => unknown);
+}
+interface InlineTaskDefGen extends Omit<InlineTaskDef, "inputParameters"> {
+    inputParameters: InlineTaskInputParametersGen;
+}
+type NestedTaskMapper = (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
+
+declare const generateJoinTask: (overrides?: Partial<JoinTaskDef>) => JoinTaskDef;
 
 /**
- * Takes a config with keyId and keySecret returns a promise with an instance of Client
+ * Takes an optional partial HttpTaskDef
+ * generates a task replacing default/fake values with provided overrides
  *
- * @param config (optional) OrkesApiConfig with keyId and keySecret
- * @param customFetch (optional) custom fetch function
- * @param requestHandler DEPRECATED! (optional) ConductorHttpRequest handler, replaced with customFetch
- * @returns Client
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
  */
-declare const orkesConductorClient: (config?: OrkesApiConfig, customFetch?: typeof fetch) => Promise<{
-    eventResource: {
-        getQueueConfig: (queueType: string, queueName: string) => Promise<{
-            [key: string]: unknown;
-        }>;
-        putQueueConfig: (queueType: string, queueName: string, body: string) => Promise<void>;
-        deleteQueueConfig: (queueType: string, queueName: string) => Promise<void>;
-        getEventHandlers: () => Promise<EventHandler[]>;
-        updateEventHandler: (body: any) => Promise<void>;
-        addEventHandler: (body: any) => Promise<void>;
-        getQueueNames: () => Promise<{
-            [key: string]: string;
-        }>;
-        removeEventHandlerStatus: (name: string) => Promise<void>;
-        getEventHandlersForEvent: (event: string, activeOnly?: boolean) => Promise<EventHandler[]>;
-        deleteTagForEventHandler: (name: string, body: any[]) => Promise<void>;
-        getTagsForEventHandler: (name: string) => Promise<Tag[]>;
-        putTagForEventHandler: (name: string, body: any[]) => Promise<void>;
-    };
-    healthCheckResource: {
-        doCheck: () => Promise<{
-            [key: string]: unknown;
-        }>;
-    };
-    metadataResource: {
-        getTaskDef: (tasktype: string, metadata?: boolean) => Promise<{
-            [key: string]: unknown;
-        }>;
-        unregisterTaskDef: (tasktype: string) => Promise<void>;
-        getAllWorkflows: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<WorkflowDef$1[]>;
-        update: (requestBody: any[], overwrite?: boolean) => Promise<void>;
-        create: (requestBody: any, overwrite?: boolean) => Promise<void>;
-        getTaskDefs: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<TaskDef[]>;
-        updateTaskDef: (requestBody: any) => Promise<void>;
-        registerTaskDef: (requestBody: any[]) => Promise<void>;
-        unregisterWorkflowDef: (name: string, version: number) => Promise<void>;
-        get: (name: string, version?: number, metadata?: boolean) => Promise<WorkflowDef$1>;
-    };
-    schedulerResource: {
-        getSchedule: (name: string) => Promise<WorkflowSchedule>;
-        deleteSchedule: (name: string) => Promise<void>;
-        getNextFewSchedules: (cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number) => Promise<number[]>;
-        pauseSchedule: (name: string) => Promise<void>;
-        pauseAllSchedules: () => Promise<{
-            [key: string]: unknown;
-        }>;
-        resumeSchedule: (name: string) => Promise<void>;
-        requeueAllExecutionRecords: () => Promise<{
-            [key: string]: unknown;
-        }>;
-        resumeAllSchedules: () => Promise<{
-            [key: string]: unknown;
-        }>;
-        getAllSchedules: (workflowName?: string) => Promise<WorkflowScheduleModel[]>;
-        saveSchedule: (requestBody: any) => Promise<void>;
-        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultWorkflowScheduleExecutionModel>;
-        testTimeout: () => Promise<any>;
-    };
-    tokenResource: {
-        generateToken: (requestBody: any) => Promise<Response$1>;
-        getUserInfo: (claims?: boolean) => Promise<{
-            [key: string]: unknown;
-        }>;
-    };
-    workflowBulkResource: {
-        retry: (requestBody: any[]) => Promise<BulkResponse>;
-        restart: (requestBody: any[], useLatestDefinitions?: boolean) => Promise<BulkResponse>;
-        terminate: (requestBody: any[], reason?: string) => Promise<BulkResponse>;
-        resumeWorkflow: (requestBody: any[]) => Promise<BulkResponse>;
-        pauseWorkflow1: (requestBody: any[]) => Promise<BulkResponse>;
-    };
-    workflowResource: {
-        getRunningWorkflow: (name: string, version?: number, startTime?: number, endTime?: number) => Promise<string[]>;
-        executeWorkflow: (body: any, name: string, version: number, requestId?: string, waitUntilTaskRef?: string, waitForSeconds?: number, consistency?: any, returnStrategy?: any) => Promise<SignalResponse$1>;
-        startWorkflow: (requestBody: any) => Promise<string>;
-        decide: (workflowId: string) => Promise<void>;
-        rerun: (workflowId: string, requestBody: any) => Promise<string>;
-        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
-        pauseWorkflow: (workflowId: string) => Promise<void>;
-        skipTaskFromWorkflow: (workflowId: string, taskReferenceName: string, requestBody?: any) => Promise<void>;
-        getWorkflows: (name: string, requestBody: any[], includeClosed?: boolean, includeTasks?: boolean) => Promise<{
-            [key: string]: Workflow[];
-        }>;
-        getWorkflowStatusSummary: (workflowId: string, includeOutput?: boolean, includeVariables?: boolean) => Promise<WorkflowStatus>;
-        getWorkflows1: (name: string, correlationId: string, includeClosed?: boolean, includeTasks?: boolean) => Promise<Workflow[]>;
-        retry1: (workflowId: string, resumeSubworkflowTasks?: boolean) => Promise<void>;
-        getExecutionStatus: (workflowId: string, includeTasks?: boolean) => Promise<Workflow>;
-        terminate1: (workflowId: string, reason?: string) => Promise<void>;
-        resumeWorkflow: (workflowId: string) => Promise<void>;
-        delete: (workflowId: string, archiveWorkflow?: boolean) => Promise<void>;
-        searchWorkflowsByTasks: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
-        getExternalStorageLocation: (path: string, operation: string, payloadType: string) => Promise<any>;
-        startWorkflow1: (name: string, requestBody: any, version?: number, correlationId?: string, priority?: number) => Promise<string>;
-        restart1: (workflowId: string, useLatestDefinitions?: boolean) => Promise<void>;
-        search1: (queryId?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean) => Promise<any>;
-        searchWorkflowsByTasksV2: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
-        resetWorkflow: (workflowId: string) => Promise<void>;
-        testWorkflow: (requestBody: any) => Promise<Workflow>;
-    };
-    serviceRegistryResource: {
-        getRegisteredServices: () => Promise<ServiceRegistry[]>;
-        removeService: (name: string) => Promise<void>;
-        getService: (name: string) => Promise<ServiceRegistry>;
-        openCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
-        closeCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
-        getCircuitBreakerStatus: (name: string) => Promise<CircuitBreakerTransitionResponse>;
-        addOrUpdateService: (serviceRegistry: any) => Promise<void>;
-        addOrUpdateServiceMethod: (registryName: string, method: any) => Promise<void>;
-        removeMethod: (registryName: string, serviceName: string, method: string, methodType: string) => Promise<void>;
-        getProtoData: (registryName: string, filename: string) => Promise<string>;
-        setProtoData: (registryName: string, filename: string, data: any) => Promise<void>;
-        deleteProto: (registryName: string, filename: string) => Promise<void>;
-        getAllProtos: (registryName: string) => Promise<ProtoRegistryEntry[]>;
-        discover: (name: string, create?: boolean) => Promise<ServiceMethod[]>;
-    };
-    humanTaskResource: {
-        getConductorTaskById: (taskId: string) => Promise<Task>;
-    };
-    humanTask: {
-        deleteTaskFromHumanTaskRecords: (requestBody: any[]) => Promise<void>;
-        deleteTaskFromHumanTaskRecords1: (taskId: string) => Promise<void>;
-        search: (requestBody: any) => Promise<HumanTaskSearchResult>;
-        updateTaskOutputByRef: (workflowId: string, taskRefName: string, requestBody: any, complete?: boolean, iteration?: any[]) => Promise<any>;
-        getTask1: (taskId: string) => Promise<HumanTaskEntry>;
-        claimTask: (taskId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
-        assignAndClaim: (taskId: string, userId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
-        reassignTask: (taskId: string, requestBody: any[]) => Promise<void>;
-        releaseTask: (taskId: string) => Promise<void>;
-        skipTask: (taskId: string, reason?: string) => Promise<void>;
-        updateTaskOutput: (taskId: string, requestBody: any, complete?: boolean) => Promise<void>;
-        getAllTemplates: (name?: string, version?: number) => Promise<HumanTaskTemplate[]>;
-        saveTemplate: (requestBody: any, newVersion?: boolean) => Promise<HumanTaskTemplate>;
-        saveTemplates: (requestBody: any[], newVersion?: boolean) => Promise<HumanTaskTemplate[]>;
-        deleteTemplateByName: (name: string) => Promise<void>;
-        deleteTemplatesByNameAndVersion: (name: string, version: number) => Promise<void>;
-        getTemplateByNameAndVersion: (name: string, version: number) => Promise<HumanTaskTemplate>;
-    };
-    taskResource: {
-        poll: (tasktype: string, workerid?: string, domain?: string) => Promise<Task>;
-        allVerbose: () => Promise<{
-            [key: string]: {
-                [key: string]: {
-                    [key: string]: number;
-                };
-            };
-        }>;
-        updateTask: (workflowId: string, taskRefName: string, status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED", requestBody: any) => Promise<string>;
-        getTask: (taskId: string) => Promise<Task>;
-        all: () => Promise<{
-            [key: string]: number;
-        }>;
-        requeuePendingTask: (taskType: string) => Promise<string>;
-        search: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultTaskSummary>;
-        searchV22: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
-        getPollData: (taskType: string) => Promise<PollData[]>;
-        getTaskLogs: (taskId: string) => Promise<TaskExecLog[]>;
-        log: (taskId: string, requestBody: string) => Promise<void>;
-        getAllPollData: () => Promise<{
-            [key: string]: unknown;
-        }>;
-        batchPoll: (tasktype: string, workerid?: string, domain?: string, count?: number, timeout?: number) => Promise<Task[]>;
-        updateTask1: (requestBody: any) => Promise<string>;
-        size1: (taskType?: string[]) => Promise<{
-            [key: string]: number;
-        }>;
-        getExternalStorageLocation1: (path: string, operation: string, payloadType: string) => Promise<any>;
-        updateTaskSync: (workflowId: string, taskRefName: string, status: any, output: any, workerId?: string) => Promise<Workflow>;
-        signal: (workflowId: string, status: any, output: any, returnStrategy?: any) => Promise<SignalResponse$1>;
-        signalAsync: (workflowId: string, status: any, output: any) => Promise<SignalResponse>;
-    };
-    buildUrl: <TData extends {
-        body?: unknown;
-        path?: Record<string, unknown>;
-        query?: Record<string, unknown>;
-        url: string;
-    }>(options: Pick<TData, "url"> & Options<TData>) => string;
-    getConfig: () => Config<ClientOptions>;
-    request: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    setConfig: (config: Config<ClientOptions>) => Config<ClientOptions>;
-    connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-    sse: {
-        connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-        trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-    };
-    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
-}>;
+declare const generateHTTPTask: (overrides?: Partial<HttpTaskDef>) => HttpTaskDef;
+
+/**
+ * Takes an optional partial InlineTaskDefGen
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * <b>note</b> that the inputParameters.expression can be either a string containing javascript
+ * or a function thar returns an ES5 function
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateInlineTask: (override?: Partial<InlineTaskDefGen>) => InlineTaskDef;
+
+/**
+ * Takes an optional partial JsonJQTransformTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateJQTransformTask: (overrides?: Partial<JsonJQTransformTaskDef>) => JsonJQTransformTaskDef;
+
+/**
+ * Takes an optional partial KafkaPublishTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateKafkaPublishTask: (overrides?: Partial<KafkaPublishTaskDef>) => KafkaPublishTaskDef;
+
+/**
+ * Takes an optional partial SubWorkflowTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateSubWorkflowTask: (overrides?: Partial<SubWorkflowTaskDef>) => SubWorkflowTaskDef;
+
+/**
+ * Takes an optional partial SetVariableTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateSetVariableTask: (overrides?: Partial<SetVariableTaskDef>) => SetVariableTaskDef;
+
+/**
+ * Takes an optional partial TerminateTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateTerminateTask: (overrides?: Partial<TerminateTaskDef>) => TerminateTaskDef;
+
+/**
+ * Takes an optional partial WaitTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateWaitTask: (overrides?: Partial<WaitTaskDef>) => WaitTaskDef;
+
+declare const taskGenMapper: (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
+/**
+ * Takes an optional partial WorkflowDefGen
+ * generates a workflow replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generate: (overrides: Partial<WorkflowDefGen>) => WorkflowDef;
+
+/**
+ * Takes an optional partial SwitchTaskDefGen and an optional nestedMapper
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @param nestedTasksMapper function to run on array of nested tasks
+ * @returns a fully defined task
+ */
+declare const generateSwitchTask: (overrides?: Partial<SwitchTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => SwitchTaskDef;
+/**
+ * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @param nestedTasksMapper function to run on array of nested tasks
+ * @returns a fully defined task
+ */
+declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => DoWhileTaskDef;
+/**
+ * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @param nestedTasksMapper function to run on array of nested tasks
+ * @returns a fully defined task
+ */
+declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
+
+declare class ConductorSdkError extends Error {
+    private _trace;
+    private __proto__;
+    constructor(message?: string, innerError?: Error);
+}
 
-export { type Action, ApiError, type ApiRequestOptions, type ApiResult, type Auth, BaseHttpRequest, CancelError, CancelablePromise, type CircuitBreakerTransitionResponse, type Client, type ClientOptions, type CommonTaskDef, type ConductorClient, type ConductorLogLevel, type ConductorLogger, ConductorSdkError, type ConductorWorker, type Config, type ConnectivityTestInput, type ConnectivityTestResult, Consistency, DefaultLogger, type DefaultLoggerConfig, type DoWhileTaskDef, type EnhancedSignalResponse, EventClient, type EventHandler, type EventMessage, type EventTaskDef, type ExtendedEventExecution, type ExtendedTaskDef, type ExtendedWorkflowDef, type ExternalStorageLocation, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateTokenRequest, type HTScrollableSearchResultHumanTaskEntry, type HttpInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type JoinTaskDef, type JsonJQTransformTaskDef, type KafkaPublishInputParameters, type KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, type Middleware, type OnCancel, type OpenAPIConfig, type OrkesApiConfig, type PollData, type ProtoRegistryEntry, type QuerySerializerOptions, type RequestOptions, type RerunWorkflowRequest, type ResolvedRequestOptions, type Response$1 as Response, ReturnStrategy, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, type ScrollableSearchResultWorkflowSummary, type SearchResultHandledEventResponse, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, type ServiceMethod, type ServiceRegistry, ServiceType, type SetVariableTaskDef, type SignalResponse, type SimpleTaskDef, type SkipTaskRequest, type StartWorkflow, type StartWorkflowRequest, type StreamEvent, type SubWorkflowParams, type SubWorkflowTaskDef, type SwitchTaskDef, type Tag, type Task, TaskClient, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskFinderPredicate, type TaskListSearchResultSummary, TaskManager, type TaskManagerConfig, type TaskManagerOptions, type TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerOptions, type TaskSummary, TaskType, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type UserFormTemplate, type WaitTaskDef, type Workflow, type WorkflowDef$1 as WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, completedTaskMatchingType, conductorEventTask, doWhileTask, dynamicForkTask, eventTask, forkTask, forkTaskJoin, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, httpTask, inlineTask, joinTask, jsonJqTask, kafkaPublishTask, newLoopTask, noopErrorHandler, noopLogger, orkesConductorClient, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };
+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 };