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

package/dist/index.d.mts

@@ -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;
@@ -1723,7 +1997,7 @@ type ServiceOptionsOrBuilder = {
 };
 type ServiceRegistry = {
     circuitBreakerEnabled?: boolean;
-    config?: Config$2;
+    config?: Config;
     methods?: Array<ServiceMethod>;
     name?: string;
     requestParams?: Array<RequestParam>;
@@ -1795,7 +2069,7 @@ type StartWorkflowRequest = {
         [key: string]: string;
     };
     version?: number;
-    workflowDef?: WorkflowDef$1;
+    workflowDef?: WorkflowDef;
 };
 type StateChangeEvent = {
     payload?: {
@@ -2070,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;
@@ -2276,320 +2550,20 @@ 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>;
-}
-
-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>;
-}
-
-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;
-}
-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;
-}
-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<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 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 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 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",
@@ -2892,735 +2866,777 @@ 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;
+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>;
+}>;
+
+declare class ApplicationClient {
+    readonly _client: Client;
+    constructor(client: Client);
     /**
-     * Starts polling for work
+     * Get all applications
+     * @returns {Promise<ExtendedConductorApplication[]>}
+     * @throws {ConductorSdkError}
      */
-    startPolling: () => void;
+    getAllApplications(): Promise<ExtendedConductorApplication[]>;
     /**
-     * Stops Polling for work
+     * Create an application
+     * @param {string} applicationName
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    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;
+    createApplication(applicationName: string): Promise<ExtendedConductorApplication>;
     /**
-     * new options will get merged to existing options
-     * @param options new options to update polling options
+     * Get application by access key id
+     * @param {string} accessKeyId
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    updatePollingOptions: (options: Partial<TaskManagerOptions>) => void;
-    sanityCheck: () => void;
+    getAppByAccessKeyId(accessKeyId: string): Promise<ExtendedConductorApplication>;
     /**
-     * Start polling for tasks
+     * Delete an access key
+     * @param {string} applicationId
+     * @param {string} keyId
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    startPolling: () => void;
+    deleteAccessKey(applicationId: string, keyId: string): Promise<void>;
     /**
-     * Stops polling for tasks
+     * Toggle the status of an access key
+     * @param {string} applicationId
+     * @param {string} keyId
+     * @returns {Promise<AccessKeyInfo>}
+     * @throws {ConductorSdkError}
      */
-    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;
-}
-
-type TaskFinderPredicate = (task: Task) => boolean;
-declare const completedTaskMatchingType: (taskType: string) => TaskFinderPredicate;
-declare class WorkflowExecutor {
-    readonly _client: Client;
-    constructor(client: Client);
+    toggleAccessKeyStatus(applicationId: string, keyId: string): Promise<AccessKeyInfo>;
     /**
-     * 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
+     * Remove role from application user
+     * @param {string} applicationId
+     * @param {string} role
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    registerWorkflow(override: boolean, workflow: WorkflowDef$1): Promise<void>;
+    removeRoleFromApplicationUser(applicationId: string, role: string): Promise<void>;
     /**
-     * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
-     * @param workflowRequest
-     * @returns
+     * Add role to application
+     * @param {string} applicationId
+     * @param {ApplicationRole} role
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
+    addApplicationRole(applicationId: string, role: ApplicationRole): Promise<void>;
     /**
-     * Execute a workflow synchronously (original method - backward compatible)
+     * Delete an application
+     * @param {string} applicationId
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
+    deleteApplication(applicationId: string): Promise<void>;
     /**
-     * Execute a workflow with return strategy support (new method)
+     * Get an application by id
+     * @param {string} applicationId
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @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>;
+    getApplication(applicationId: string): Promise<ExtendedConductorApplication>;
     /**
-     * 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
+     * Update an application
+     * @param {string} applicationId
+     * @param {string} newApplicationName
+     * @returns {Promise<ExtendedConductorApplication>}
+     * @throws {ConductorSdkError}
      */
-    getWorkflow(workflowInstanceId: string, includeTasks: boolean, retry?: number): Promise<Workflow>;
+    updateApplication(applicationId: string, newApplicationName: string): Promise<ExtendedConductorApplication>;
     /**
-     *  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>
+     * Get application's access keys
+     * @param {string} applicationId
+     * @returns {Promise<AccessKeyInfo[]>}
+     * @throws {ConductorSdkError}
      */
-    getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): Promise<WorkflowStatus>;
+    getAccessKeys(applicationId: 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>
+     * Create an access key for an application
+     * @param {string} applicationId
+     * @returns {Promise<AccessKey>}
+     * @throws {ConductorSdkError}
      */
-    getExecution(workflowInstanceId: string, includeTasks?: boolean): Promise<Workflow>;
+    createAccessKey(applicationId: string): Promise<AccessKey>;
     /**
-     * Pauses a running workflow
-     * @param workflowInstanceId current workflow execution
-     * @returns
+     * Delete application tags
+     * @param {string} applicationId
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    pause(workflowInstanceId: string): Promise<void>;
+    deleteApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
     /**
-     * Reruns workflowInstanceId workflow. with new parameters
-     *
-     * @param workflowInstanceId current workflow execution
-     * @param rerunWorkflowRequest Rerun Workflow Execution Request
-     * @returns
+     * Delete a single application tag
+     * @param {string} applicationId
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial<RerunWorkflowRequest>): Promise<string>;
+    deleteApplicationTag(applicationId: string, tag: Tag): Promise<void>;
     /**
-     * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
-     * @param workflowInstanceId
-     * @param useLatestDefinitions
-     * @returns
+     * Get application tags
+     * @param {string} applicationId
+     * @returns {Promise<Tag[]>}
+     * @throws {ConductorSdkError}
      */
-    restart(workflowInstanceId: string, useLatestDefinitions: boolean): Promise<void>;
+    getApplicationTags(applicationId: string): Promise<Tag[]>;
     /**
-     * Resumes a previously paused execution
-     *
-     * @param workflowInstanceId Running workflow workflowInstanceId
-     * @returns
+     * Add application tags
+     * @param {string} applicationId
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    resume(workflowInstanceId: string): Promise<void>;
+    addApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
     /**
-     * Retrys workflow from last failing task
-     * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows
-     *
-     * @param workflowInstanceId
-     * @param resumeSubworkflowTasks
-     * @returns
+     * Add a single application tag
+     * @param {string} applicationId
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    retry(workflowInstanceId: string, resumeSubworkflowTasks: boolean): Promise<void>;
+    addApplicationTag(applicationId: string, tag: Tag): Promise<void>;
+}
+
+declare class EventClient {
+    readonly _client: Client;
+    constructor(client: Client);
     /**
-     * Searches for existing workflows given the following querys
-     *
-     * @param start
-     * @param size
-     * @param query
-     * @param freeText
-     * @param sort
-     * @param skipCache
-     * @returns
+     * Get all the event handlers
+     * @returns {Promise<EventHandler[]>}
+     * @throws {ConductorSdkError}
      */
-    search(start: number, size: number, query: string, freeText: string, sort?: string, skipCache?: boolean): Promise<ScrollableSearchResultWorkflowSummary>;
+    getAllEventHandlers(): Promise<EventHandler[]>;
     /**
-     * Skips a task of a running workflow.
-     * by providing a skipTaskRequest you can set the input and the output of the skipped tasks
-     * @param workflowInstanceId
-     * @param taskReferenceName
-     * @param skipTaskRequest
-     * @returns
-     */
-    skipTasksFromWorkflow(workflowInstanceId: string, taskReferenceName: string, skipTaskRequest: Partial<SkipTaskRequest>): Promise<void>;
+     * Add event handlers
+     * @param {EventHandler[]} eventHandlers
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
+     */
+    addEventHandlers(eventHandlers: EventHandler[]): Promise<void>;
     /**
-     * Takes an workflowInstanceId, and terminates a running workflow
-     * @param workflowInstanceId
-     * @param reason
-     * @returns
+     * Add an event handler
+     * @param {EventHandler} eventHandler
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    terminate(workflowInstanceId: string, reason: string): Promise<void>;
+    addEventHandler(eventHandler: EventHandler): Promise<void>;
     /**
-     * Takes a taskId and a workflowInstanceId. Will update the task for the corresponding taskId
-     * @param taskId
-     * @param workflowInstanceId
-     * @param taskStatus
-     * @param taskOutput
-     * @returns
+     * Update an event handler
+     * @param {EventHandler} eventHandler
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: TaskResultOutputData): Promise<string>;
+    updateEventHandler(eventHandler: EventHandler): Promise<void>;
     /**
-     * Updates a task by reference Name
-     * @param taskReferenceName
-     * @param workflowInstanceId
-     * @param status
-     * @param taskOutput
-     * @returns
+     * Handle an incoming event
+     * @param {Record<string, string>} data
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: TaskResultOutputData): Promise<string>;
+    handleIncomingEvent(data: Record<string, string>): Promise<void>;
     /**
-     *
-     * @param taskId
-     * @returns
+     * Get an event handler by name
+     * @param {string} eventHandlerName
+     * @returns {Promise<EventHandler>}
+     * @throws {ConductorSdkError}
      */
-    getTask(taskId: string): Promise<Task>;
+    getEventHandlerByName(eventHandlerName: string): 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>
+     * Get all queue configs
+     * @returns {Promise<Record<string, string>>}
+     * @throws {ConductorSdkError}
      */
-    updateTaskSync(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, workerId?: string): Promise<Workflow>;
+    getAllQueueConfigs(): Promise<Record<string, string>>;
     /**
-     * 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
+     * Delete queue config
+     * @param {string} queueType
+     * @param {string} queueName
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    signal(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, returnStrategy?: ReturnStrategy): Promise<EnhancedSignalResponse>;
+    deleteQueueConfig(queueType: string, queueName: string): 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>
+     * Get queue config
+     * @param {string} queueType
+     * @param {string} queueName
+     * @returns {Promise<Record<string, unknown>>}
+     * @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);
+    getQueueConfig(queueType: string, queueName: string): Promise<Record<string, unknown>>;
     /**
-     * @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
+     * Get event handlers for a given event
+     * @param {string} event
+     * @param {boolean} [activeOnly=false] Only return active handlers.
+     * @returns {Promise<EventHandler[]>}
+     * @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[]>;
+    getEventHandlersForEvent(event: string, activeOnly?: boolean): Promise<EventHandler[]>;
     /**
-     * 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[]>
+     * Remove an event handler by name
+     * @param {string} name
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    search(searchParams: Partial<HumanTaskSearch>): Promise<HumanTaskEntry[]>;
+    removeEventHandler(name: string): Promise<void>;
     /**
-     * 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 tags for an event handler
+     * @param {string} name
+     * @returns {Promise<Tag[]>}
+     * @throws {ConductorSdkError}
      */
-    pollSearch(searchParams: Partial<HumanTaskSearch>, { pollInterval, maxPollTimes, }?: PollIntervalOptions): Promise<HumanTaskEntry[]>;
+    getTagsForEventHandler(name: string): Promise<Tag[]>;
     /**
-     * Returns task for a given task id
-     * @param taskId
-     * @returns
+     * Put tags for an event handler
+     * @param {string} name
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    getTaskById(taskId: string): Promise<HumanTaskEntry>;
+    putTagForEventHandler(name: string, tags: Tag[]): Promise<void>;
     /**
-     * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
-     * @param taskId
-     * @param assignee
-     * @returns
+     * Delete tags for an event handler
+     * @param {string} name
+     * @param {Tag[]} tags
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    claimTaskAsExternalUser(taskId: string, assignee: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    deleteTagsForEventHandler(name: string, tags: Tag[]): Promise<void>;
     /**
-     * Claim task as conductor user
-     * @param taskId
-     * @returns
+     * Delete a tag for an event handler
+     * @param {string} name
+     * @param {Tag} tag
+     * @returns {Promise<void>}
+     * @throws {ConductorSdkError}
      */
-    claimTaskAsConductorUser(taskId: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
+    deleteTagForEventHandler(name: string, tag: Tag): Promise<void>;
     /**
-     * Claim task as conductor user
-     * @param taskId
-     * @param assignee
-     * @returns
+     * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
+     * @param {ConnectivityTestInput} input
+     * @returns {Promise<ConnectivityTestResult>}
+     * @throws {ConductorSdkError}
      */
-    releaseTask(taskId: string): Promise<void>;
+    testConnectivity(input: ConnectivityTestInput): Promise<ConnectivityTestResult>;
     /**
-     * Returns a HumanTaskTemplateEntry for a given name and version
-     * @param templateId
-     * @returns
+     * 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}
      */
-    getTemplateByNameVersion(name: string, version: number): Promise<HumanTaskTemplate>;
+    putQueueConfig(queueType: string, queueName: string, config: string): Promise<void>;
     /**
-     * @deprecated use getTemplate instead. name will be used as id here with version 1
-     * Returns a HumanTaskTemplateEntry for a given templateId
-     * @param templateId
-     * @returns
+     * Test endpoint (as exposed by API)
+     * @returns {Promise<EventHandler>}
+     * @throws {ConductorSdkError}
      */
-    getTemplateById(templateNameVersionOne: string): Promise<HumanTaskTemplate>;
+    test(): Promise<EventHandler>;
     /**
-     * Takes a taskId and a partial body. will update with given body
-     * @param taskId
-     * @param requestBody
+     * Get all active event handlers (execution view)
+     * @returns {Promise<SearchResultHandledEventResponse>}
+     * @throws {ConductorSdkError}
      */
-    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, unknown>>): Promise<void>;
+    getAllActiveEventHandlers(): Promise<SearchResultHandledEventResponse>;
     /**
-     * Takes a taskId and an optional partial body. will complete the task with the given body
-     * @param taskId
-     * @param requestBody
+     * Get event executions for a specific handler
+     * @param {string} eventHandlerName
+     * @param {number} [from] Pagination cursor
+     * @returns {Promise<ExtendedEventExecution[]>}
+     * @throws {ConductorSdkError}
      */
-    completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
+    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 generateJoinTask: (overrides?: Partial<JoinTaskDef>) => JoinTaskDef;
-
-/**
- * Takes an optional partial HttpTaskDef
- * generates a task replacing default/fake values with provided overrides
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateHTTPTask: (overrides?: Partial<HttpTaskDef>) => HttpTaskDef;
-
-/**
- * Takes an optional partial InlineTaskDefGen
- * generates a task replacing default/fake values with provided overrides
- *
- * <b>note</b> that the inputParameters.expression can be either a string containing javascript
- * or a function thar returns an ES5 function
- *
- * @param overrides overrides for defaults
- * @returns a fully defined task
- */
-declare const generateInlineTask: (override?: Partial<InlineTaskDefGen>) => InlineTaskDef;
+declare const noopLogger: ConductorLogger;
 
-/**
- * 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;
+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 KafkaPublishTaskDef
- * 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 generateKafkaPublishTask: (overrides?: Partial<KafkaPublishTaskDef>) => KafkaPublishTaskDef;
+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 SubWorkflowTaskDef
- * generates a task replacing default/fake values with provided overrides
+ * Responsible for polling and executing tasks from a queue.
  *
- * @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
+ * 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 generateSetVariableTask: (overrides?: Partial<SetVariableTaskDef>) => SetVariableTaskDef;
+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 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;
-
-/**
- * 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 SchedulerClient {
+declare class HumanExecutor {
     readonly _client: Client;
     constructor(client: Client);
     /**
-     * Create or update a schedule for a specified workflow with a corresponding start workflow request
-     * @param requestBody
+     * @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
      */
-    saveSchedule(param: SaveScheduleRequest): Promise<void>;
+    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[]>;
     /**
-     * Searches for existing scheduler execution based on below parameters
-     *
-     * @param start
-     * @param size
-     * @param sort
+     * 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 query
-     * @returns SearchResultWorkflowScheduleExecutionModel
+     * @param includeInputOutput
+     * @returns Promise<HumanTaskEntry[]>
      */
-    search(start: number, size?: number, sort?: string, freeText?: string, query?: string): Promise<SearchResultWorkflowScheduleExecutionModel>;
+    search(searchParams: Partial<HumanTaskSearch>): Promise<HumanTaskEntry[]>;
     /**
-     * Get an existing schedule by name
-     * @param name
-     * @returns WorkflowSchedule
+     * 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[]>
      */
-    getSchedule(name: string): Promise<WorkflowSchedule>;
+    pollSearch(searchParams: Partial<HumanTaskSearch>, { pollInterval, maxPollTimes, }?: PollIntervalOptions): Promise<HumanTaskEntry[]>;
     /**
-     * Pauses an existing schedule by name
-     * @param name
+     * Returns task for a given task id
+     * @param taskId
      * @returns
      */
-    pauseSchedule(name: string): Promise<void>;
+    getTaskById(taskId: string): Promise<HumanTaskEntry>;
     /**
-     * Resume a paused schedule by name
-     *
-     * @param name
+     * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
+     * @param taskId
+     * @param assignee
      * @returns
      */
-    resumeSchedule(name: string): Promise<void>;
+    claimTaskAsExternalUser(taskId: string, assignee: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
     /**
-     * Deletes an existing scheduler execution by name
-     *
-     * @param name
+     * Claim task as conductor user
+     * @param taskId
      * @returns
      */
-    deleteSchedule(name: string): Promise<void>;
-    /**
-     * Get all existing workflow schedules and optionally filter by workflow name
-     * @param workflowName
-     * @returns Array<WorkflowScheduleModel>
-     */
-    getAllSchedules(workflowName?: string): Promise<WorkflowScheduleModel[]>;
-    /**
-     * Get list of the next x (default 3, max 5) execution times for a scheduler
-     * @param cronExpression
-     * @param scheduleStartTime
-     * @param scheduleEndTime
-     * @param limit
-     * @returns number OK
-     * @throws ApiError
-     */
-    getNextFewSchedules(cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): Promise<number[]>;
-    /**
-     * Pause all scheduling in a single conductor server instance (for debugging only)
-     * @returns any OK
-     * @throws ApiError
-     */
-    pauseAllSchedules(): Promise<void>;
+    claimTaskAsConductorUser(taskId: string, options?: Record<string, boolean>): Promise<HumanTaskEntry>;
     /**
-     * Requeue all execution records
-     * @returns any OK
-     * @throws ApiError
+     * Claim task as conductor user
+     * @param taskId
+     * @param assignee
+     * @returns
      */
-    requeueAllExecutionRecords(): Promise<void>;
+    releaseTask(taskId: string): Promise<void>;
     /**
-     * Resume all scheduling
-     * @returns any OK
-     * @throws ApiError
+     * Returns a HumanTaskTemplateEntry for a given name and version
+     * @param templateId
+     * @returns
      */
-    resumeAllSchedules(): Promise<void>;
-}
-
-declare class TaskClient {
-    readonly _client: Client;
-    constructor(client: Client);
+    getTemplateByNameVersion(name: string, version: number): Promise<HumanTaskTemplate>;
     /**
-     * Searches for existing scheduler execution based on below parameters
-     *
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultWorkflowScheduleExecutionModel
+     * @deprecated use getTemplate instead. name will be used as id here with version 1
+     * Returns a HumanTaskTemplateEntry for a given templateId
+     * @param templateId
+     * @returns
      */
-    search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise<SearchResultTaskSummary>;
+    getTemplateById(templateNameVersionOne: string): Promise<HumanTaskTemplate>;
     /**
-     * Get an existing schedule by Id
+     * Takes a taskId and a partial body. will update with given body
      * @param taskId
-     * @returns Task
-     */
-    getTask(taskId: string): Promise<Task>;
-    /**
-     * Update task result status
-     *
-     * @param workflowId
-     * @param taskReferenceName
-     * @param status
-     * @param outputData
-     * @param workerId
-     * @returns
+     * @param requestBody
      */
-    updateTaskResult(workflowId: string, taskRefName: string, status: TaskResultStatus, outputData: Record<string, unknown>): Promise<string>;
-}
-
-declare class TemplateClient {
-    readonly _client: Client;
-    constructor(client: Client);
+    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, unknown>>): Promise<void>;
     /**
-     * Register a new human task template
-     *
-     * @param template
-     * @returns
+     * Takes a taskId and an optional partial body. will complete the task with the given body
+     * @param taskId
+     * @param requestBody
      */
-    registerTemplate(template: HumanTaskTemplate, asNewVersion?: boolean): Promise<HumanTaskTemplate>;
+    completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
 }
 
 declare class MetadataClient {
@@ -3676,7 +3692,7 @@ declare class MetadataClient {
      * @param overwrite
      * @returns
      */
-    getWorkflowDef(name: string, version?: number, metadata?: boolean): Promise<WorkflowDef$1>;
+    getWorkflowDef(name: string, version?: number, metadata?: boolean): Promise<WorkflowDef>;
     /**
      * Unregister (overwrite: true) a workflow definition
      *
@@ -3687,170 +3703,86 @@ declare class MetadataClient {
     unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
 }
 
-declare class EventClient {
+declare class SchedulerClient {
     readonly _client: Client;
     constructor(client: Client);
     /**
-     * Get all the event handlers
-     * @returns {Promise<EventHandler[]>}
-     * @throws {ConductorSdkError}
+     * Create or update a schedule for a specified workflow with a corresponding start workflow request
+     * @param requestBody
+     * @returns
      */
-    getAllEventHandlers(): Promise<EventHandler[]>;
+    saveSchedule(param: SaveScheduleRequest): Promise<void>;
     /**
-     * Add event handlers
-     * @param {EventHandler[]} eventHandlers
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Searches for existing scheduler execution based on below parameters
+     *
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultWorkflowScheduleExecutionModel
      */
-    addEventHandlers(eventHandlers: EventHandler[]): Promise<void>;
+    search(start: number, size?: number, sort?: string, freeText?: string, query?: string): Promise<SearchResultWorkflowScheduleExecutionModel>;
     /**
-     * Add an event handler
-     * @param {EventHandler} eventHandler
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Get an existing schedule by name
+     * @param name
+     * @returns WorkflowSchedule
      */
-    addEventHandler(eventHandler: EventHandler): Promise<void>;
+    getSchedule(name: string): Promise<WorkflowSchedule>;
     /**
-     * Update an event handler
-     * @param {EventHandler} eventHandler
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Pauses an existing schedule by name
+     * @param name
+     * @returns
      */
-    updateEventHandler(eventHandler: EventHandler): Promise<void>;
+    pauseSchedule(name: string): Promise<void>;
     /**
-     * Handle an incoming event
-     * @param {Record<string, string>} data
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Resume a paused schedule by name
+     *
+     * @param name
+     * @returns
      */
-    handleIncomingEvent(data: Record<string, string>): Promise<void>;
+    resumeSchedule(name: string): Promise<void>;
     /**
-     * Get an event handler by name
-     * @param {string} eventHandlerName
-     * @returns {Promise<EventHandler>}
-     * @throws {ConductorSdkError}
+     * Deletes an existing scheduler execution by name
+     *
+     * @param name
+     * @returns
      */
-    getEventHandlerByName(eventHandlerName: string): Promise<EventHandler>;
+    deleteSchedule(name: string): Promise<void>;
     /**
-     * Get all queue configs
-     * @returns {Promise<Record<string, string>>}
-     * @throws {ConductorSdkError}
+     * Get all existing workflow schedules and optionally filter by workflow name
+     * @param workflowName
+     * @returns Array<WorkflowScheduleModel>
      */
-    getAllQueueConfigs(): Promise<Record<string, string>>;
-    /**
-     * Delete queue config
-     * @param {string} queueType
-     * @param {string} queueName
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    deleteQueueConfig(queueType: string, queueName: string): Promise<void>;
-    /**
-     * Get queue config
-     * @param {string} queueType
-     * @param {string} queueName
-     * @returns {Promise<Record<string, unknown>>}
-     * @throws {ConductorSdkError}
-     */
-    getQueueConfig(queueType: string, queueName: string): Promise<Record<string, unknown>>;
-    /**
-     * Get event handlers for a given event
-     * @param {string} event
-     * @param {boolean} [activeOnly=false] Only return active handlers.
-     * @returns {Promise<EventHandler[]>}
-     * @throws {ConductorSdkError}
-     */
-    getEventHandlersForEvent(event: string, activeOnly?: boolean): Promise<EventHandler[]>;
-    /**
-     * Remove an event handler by name
-     * @param {string} name
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    removeEventHandler(name: string): Promise<void>;
-    /**
-     * Get tags for an event handler
-     * @param {string} name
-     * @returns {Promise<Tag[]>}
-     * @throws {ConductorSdkError}
-     */
-    getTagsForEventHandler(name: string): Promise<Tag[]>;
-    /**
-     * Put tags for an event handler
-     * @param {string} name
-     * @param {Tag[]} tags
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    putTagForEventHandler(name: string, tags: Tag[]): Promise<void>;
-    /**
-     * Delete tags for an event handler
-     * @param {string} name
-     * @param {Tag[]} tags
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    deleteTagsForEventHandler(name: string, tags: Tag[]): Promise<void>;
-    /**
-     * Delete a tag for an event handler
-     * @param {string} name
-     * @param {Tag} tag
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    deleteTagForEventHandler(name: string, tag: Tag): Promise<void>;
-    /**
-     * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
-     * @param {ConnectivityTestInput} input
-     * @returns {Promise<ConnectivityTestResult>}
-     * @throws {ConductorSdkError}
-     */
-    testConnectivity(input: ConnectivityTestInput): Promise<ConnectivityTestResult>;
-    /**
-     * Create or update queue config by name
-     * @deprecated Prefer server's newer endpoints if available
-     * @param {string} queueType
-     * @param {string} queueName
-     * @param {string} config
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
-     */
-    putQueueConfig(queueType: string, queueName: string, config: string): Promise<void>;
-    /**
-     * Test endpoint (as exposed by API)
-     * @returns {Promise<EventHandler>}
-     * @throws {ConductorSdkError}
-     */
-    test(): Promise<EventHandler>;
+    getAllSchedules(workflowName?: string): Promise<WorkflowScheduleModel[]>;
     /**
-     * Get all active event handlers (execution view)
-     * @returns {Promise<SearchResultHandledEventResponse>}
-     * @throws {ConductorSdkError}
+     * Get list of the next x (default 3, max 5) execution times for a scheduler
+     * @param cronExpression
+     * @param scheduleStartTime
+     * @param scheduleEndTime
+     * @param limit
+     * @returns number OK
+     * @throws ApiError
      */
-    getAllActiveEventHandlers(): Promise<SearchResultHandledEventResponse>;
+    getNextFewSchedules(cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): Promise<number[]>;
     /**
-     * Get event executions for a specific handler
-     * @param {string} eventHandlerName
-     * @param {number} [from] Pagination cursor
-     * @returns {Promise<ExtendedEventExecution[]>}
-     * @throws {ConductorSdkError}
+     * Pause all scheduling in a single conductor server instance (for debugging only)
+     * @returns any OK
+     * @throws ApiError
      */
-    getEventExecutions(eventHandlerName: string, from?: number): Promise<ExtendedEventExecution[]>;
+    pauseAllSchedules(): Promise<void>;
     /**
-     * Get all event handlers with statistics (messages view)
-     * @param {number} [from] Pagination cursor
-     * @returns {Promise<SearchResultHandledEventResponse>}
-     * @throws {ConductorSdkError}
+     * Requeue all execution records
+     * @returns any OK
+     * @throws ApiError
      */
-    getEventHandlersWithStats(from?: number): Promise<SearchResultHandledEventResponse>;
+    requeueAllExecutionRecords(): Promise<void>;
     /**
-     * Get event messages for a given event
-     * @param {string} event
-     * @param {number} [from] Pagination cursor
-     * @returns {Promise<EventMessage[]>}
-     * @throws {ConductorSdkError}
+     * Resume all scheduling
+     * @returns any OK
+     * @throws ApiError
      */
-    getEventMessages(event: string, from?: number): Promise<EventMessage[]>;
+    resumeAllSchedules(): Promise<void>;
 }
 
 /**
@@ -3953,355 +3885,445 @@ declare class ServiceRegistryClient {
     discover(name: string, create?: boolean): Promise<ServiceMethod[]>;
 }
 
-declare class ApplicationClient {
+declare class TaskClient {
     readonly _client: Client;
     constructor(client: Client);
     /**
-     * Get all applications
-     * @returns {Promise<ExtendedConductorApplication[]>}
-     * @throws {ConductorSdkError}
-     */
-    getAllApplications(): Promise<ExtendedConductorApplication[]>;
-    /**
-     * Create an application
-     * @param {string} applicationName
-     * @returns {Promise<ExtendedConductorApplication>}
-     * @throws {ConductorSdkError}
+     * Searches for existing scheduler execution based on below parameters
+     *
+     * @param start
+     * @param size
+     * @param sort
+     * @param freeText
+     * @param query
+     * @returns SearchResultWorkflowScheduleExecutionModel
      */
-    createApplication(applicationName: string): Promise<ExtendedConductorApplication>;
+    search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise<SearchResultTaskSummary>;
     /**
-     * Get application by access key id
-     * @param {string} accessKeyId
-     * @returns {Promise<ExtendedConductorApplication>}
-     * @throws {ConductorSdkError}
+     * Get an existing schedule by Id
+     * @param taskId
+     * @returns Task
      */
-    getAppByAccessKeyId(accessKeyId: string): Promise<ExtendedConductorApplication>;
+    getTask(taskId: string): Promise<Task>;
     /**
-     * Delete an access key
-     * @param {string} applicationId
-     * @param {string} keyId
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Update task result status
+     *
+     * @param workflowId
+     * @param taskReferenceName
+     * @param status
+     * @param outputData
+     * @param workerId
+     * @returns
      */
-    deleteAccessKey(applicationId: string, keyId: string): Promise<void>;
+    updateTaskResult(workflowId: string, taskRefName: string, status: TaskResultStatus, outputData: Record<string, unknown>): Promise<string>;
+}
+
+declare class TemplateClient {
+    readonly _client: Client;
+    constructor(client: Client);
     /**
-     * Toggle the status of an access key
-     * @param {string} applicationId
-     * @param {string} keyId
-     * @returns {Promise<AccessKeyInfo>}
-     * @throws {ConductorSdkError}
+     * Register a new human task template
+     *
+     * @param template
+     * @returns
      */
-    toggleAccessKeyStatus(applicationId: string, keyId: string): Promise<AccessKeyInfo>;
+    registerTemplate(template: HumanTaskTemplate, asNewVersion?: boolean): Promise<HumanTaskTemplate>;
+}
+
+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);
     /**
-     * Remove role from application user
-     * @param {string} applicationId
-     * @param {string} role
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * 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
      */
-    removeRoleFromApplicationUser(applicationId: string, role: string): Promise<void>;
+    registerWorkflow(override: boolean, workflow: WorkflowDef): Promise<void>;
     /**
-     * Add role to application
-     * @param {string} applicationId
-     * @param {ApplicationRole} role
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
+     * @param workflowRequest
+     * @returns
      */
-    addApplicationRole(applicationId: string, role: ApplicationRole): Promise<void>;
+    startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
     /**
-     * Delete an application
-     * @param {string} applicationId
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Execute a workflow synchronously (original method - backward compatible)
      */
-    deleteApplication(applicationId: string): Promise<void>;
+    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
     /**
-     * Get an application by id
-     * @param {string} applicationId
-     * @returns {Promise<ExtendedConductorApplication>}
-     * @throws {ConductorSdkError}
+     * Execute a workflow with return strategy support (new method)
      */
-    getApplication(applicationId: string): Promise<ExtendedConductorApplication>;
+    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>;
     /**
-     * Update an application
-     * @param {string} applicationId
-     * @param {string} newApplicationName
-     * @returns {Promise<ExtendedConductorApplication>}
-     * @throws {ConductorSdkError}
+     * 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
      */
-    updateApplication(applicationId: string, newApplicationName: string): Promise<ExtendedConductorApplication>;
+    getWorkflow(workflowInstanceId: string, includeTasks: boolean, retry?: number): Promise<Workflow>;
     /**
-     * Get application's access keys
-     * @param {string} applicationId
-     * @returns {Promise<AccessKeyInfo[]>}
-     * @throws {ConductorSdkError}
+     *  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>
      */
-    getAccessKeys(applicationId: string): Promise<AccessKeyInfo[]>;
+    getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): Promise<WorkflowStatus>;
     /**
-     * Create an access key for an application
-     * @param {string} applicationId
-     * @returns {Promise<AccessKey>}
-     * @throws {ConductorSdkError}
+     *  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>
      */
-    createAccessKey(applicationId: string): Promise<AccessKey>;
+    getExecution(workflowInstanceId: string, includeTasks?: boolean): Promise<Workflow>;
     /**
-     * Delete application tags
-     * @param {string} applicationId
-     * @param {Tag[]} tags
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Pauses a running workflow
+     * @param workflowInstanceId current workflow execution
+     * @returns
      */
-    deleteApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
+    pause(workflowInstanceId: string): Promise<void>;
     /**
-     * Delete a single application tag
-     * @param {string} applicationId
-     * @param {Tag} tag
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Reruns workflowInstanceId workflow. with new parameters
+     *
+     * @param workflowInstanceId current workflow execution
+     * @param rerunWorkflowRequest Rerun Workflow Execution Request
+     * @returns
      */
-    deleteApplicationTag(applicationId: string, tag: Tag): Promise<void>;
+    reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial<RerunWorkflowRequest>): Promise<string>;
     /**
-     * Get application tags
-     * @param {string} applicationId
-     * @returns {Promise<Tag[]>}
-     * @throws {ConductorSdkError}
+     * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
+     * @param workflowInstanceId
+     * @param useLatestDefinitions
+     * @returns
      */
-    getApplicationTags(applicationId: string): Promise<Tag[]>;
+    restart(workflowInstanceId: string, useLatestDefinitions: boolean): Promise<void>;
     /**
-     * Add application tags
-     * @param {string} applicationId
-     * @param {Tag[]} tags
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Resumes a previously paused execution
+     *
+     * @param workflowInstanceId Running workflow workflowInstanceId
+     * @returns
      */
-    addApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
+    resume(workflowInstanceId: string): Promise<void>;
     /**
-     * Add a single application tag
-     * @param {string} applicationId
-     * @param {Tag} tag
-     * @returns {Promise<void>}
-     * @throws {ConductorSdkError}
+     * Retrys workflow from last failing task
+     * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows
+     *
+     * @param workflowInstanceId
+     * @param resumeSubworkflowTasks
+     * @returns
      */
-    addApplicationTag(applicationId: string, tag: Tag): Promise<void>;
+    retry(workflowInstanceId: string, resumeSubworkflowTasks: boolean): Promise<void>;
+    /**
+     * Searches for existing workflows given the following querys
+     *
+     * @param start
+     * @param size
+     * @param query
+     * @param freeText
+     * @param sort
+     * @param skipCache
+     * @returns
+     */
+    search(start: number, size: number, query: string, freeText: string, sort?: string, skipCache?: boolean): Promise<ScrollableSearchResultWorkflowSummary>;
+    /**
+     * Skips a task of a running workflow.
+     * by providing a skipTaskRequest you can set the input and the output of the skipped tasks
+     * @param workflowInstanceId
+     * @param taskReferenceName
+     * @param skipTaskRequest
+     * @returns
+     */
+    skipTasksFromWorkflow(workflowInstanceId: string, taskReferenceName: string, skipTaskRequest: Partial<SkipTaskRequest>): Promise<void>;
+    /**
+     * Takes an workflowInstanceId, and terminates a running workflow
+     * @param workflowInstanceId
+     * @param reason
+     * @returns
+     */
+    terminate(workflowInstanceId: string, reason: string): Promise<void>;
+    /**
+     * Takes a taskId and a workflowInstanceId. Will update the task for the corresponding taskId
+     * @param taskId
+     * @param workflowInstanceId
+     * @param taskStatus
+     * @param taskOutput
+     * @returns
+     */
+    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: TaskResultOutputData): Promise<string>;
+    /**
+     * Updates a task by reference Name
+     * @param taskReferenceName
+     * @param workflowInstanceId
+     * @param status
+     * @param taskOutput
+     * @returns
+     */
+    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: TaskResultOutputData): Promise<string>;
+    /**
+     *
+     * @param taskId
+     * @returns
+     */
+    getTask(taskId: string): Promise<Task>;
+    /**
+     * 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>
+     */
+    updateTaskSync(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, workerId?: string): Promise<Workflow>;
+    /**
+     * 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
+     */
+    signal(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, returnStrategy?: ReturnStrategy): Promise<EnhancedSignalResponse>;
+    /**
+     * 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>
+     */
+    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 a config with keyId and keySecret returns a promise with an instance of Client
+ * Takes an optional partial SimpleTaskDef
+ * generates a task replacing default 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 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 an optional partial HttpTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateHTTPTask: (overrides?: Partial<HttpTaskDef>) => HttpTaskDef;
+
+/**
+ * Takes an optional partial InlineTaskDefGen
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * <b>note</b> that the inputParameters.expression can be either a string containing javascript
+ * or a function thar returns an ES5 function
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateInlineTask: (override?: Partial<InlineTaskDefGen>) => InlineTaskDef;
+
+/**
+ * Takes an optional partial JsonJQTransformTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateJQTransformTask: (overrides?: Partial<JsonJQTransformTaskDef>) => JsonJQTransformTaskDef;
+
+/**
+ * Takes an optional partial KafkaPublishTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateKafkaPublishTask: (overrides?: Partial<KafkaPublishTaskDef>) => KafkaPublishTaskDef;
+
+/**
+ * Takes an optional partial SubWorkflowTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateSubWorkflowTask: (overrides?: Partial<SubWorkflowTaskDef>) => SubWorkflowTaskDef;
+
+/**
+ * Takes an optional partial SetVariableTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateSetVariableTask: (overrides?: Partial<SetVariableTaskDef>) => SetVariableTaskDef;
+
+/**
+ * Takes an optional partial TerminateTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateTerminateTask: (overrides?: Partial<TerminateTaskDef>) => TerminateTaskDef;
+
+/**
+ * Takes an optional partial WaitTaskDef
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generateWaitTask: (overrides?: Partial<WaitTaskDef>) => WaitTaskDef;
+
+declare const taskGenMapper: (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
+/**
+ * Takes an optional partial WorkflowDefGen
+ * generates a workflow replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @returns a fully defined task
+ */
+declare const generate: (overrides: Partial<WorkflowDefGen>) => WorkflowDef;
+
+/**
+ * Takes an optional partial SwitchTaskDefGen and an optional nestedMapper
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @param nestedTasksMapper function to run on array of nested tasks
+ * @returns a fully defined task
+ */
+declare const generateSwitchTask: (overrides?: Partial<SwitchTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => SwitchTaskDef;
+/**
+ * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @param nestedTasksMapper function to run on array of nested tasks
+ * @returns a fully defined task
+ */
+declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => DoWhileTaskDef;
+/**
+ * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
+ * generates a task replacing default/fake values with provided overrides
+ *
+ * @param overrides overrides for defaults
+ * @param nestedTasksMapper function to run on array of nested tasks
+ * @returns a fully defined task
+ */
+declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
+
+declare class ConductorSdkError extends Error {
+    private _trace;
+    private __proto__;
+    constructor(message?: string, innerError?: Error);
+}
 
-export { type AccessKey, type AccessKeyInfo, type Action, ApiError, type ApiRequestOptions, type ApiResult, ApplicationClient, type ApplicationRole, type Auth, BaseHttpRequest, CancelError, CancelablePromise, type CircuitBreakerTransitionResponse, type Client, type ClientOptions, type CommonTaskDef, type ConductorClient, type 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 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, 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, 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 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 };