npm - @io-orkes/conductor-javascript - Versions diffs - 2.1.4 → 2.2.0 - Mend

@io-orkes/conductor-javascript 2.1.4 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.d.mts CHANGED Viewed

@@ -1,1541 +1,2528 @@
-declare type ApiRequestOptions = {
-    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
-    readonly url: string;
-    readonly path?: Record<string, any>;
-    readonly cookies?: Record<string, any>;
-    readonly headers?: Record<string, any>;
-    readonly query?: Record<string, any>;
-    readonly formData?: Record<string, any>;
-    readonly body?: any;
-    readonly mediaType?: string;
-    readonly responseHeader?: string;
-    readonly errors?: Record<number, string>;
-};
-declare class CancelError extends Error {
-    constructor(message: string);
-    get isCancelled(): boolean;
-}
-interface OnCancel {
-    readonly isResolved: boolean;
-    readonly isRejected: boolean;
-    readonly isCancelled: boolean;
-    (cancelHandler: () => void): void;
+interface ConductorLogger {
+    info(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
 }
-declare class CancelablePromise<T> implements Promise<T> {
-    readonly [Symbol.toStringTag]: string;
-    private _isResolved;
-    private _isRejected;
-    private _isCancelled;
-    private readonly _cancelHandlers;
-    private readonly _promise;
-    private _resolve?;
-    private _reject?;
-    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
-    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
-    finally(onFinally?: (() => void) | null): Promise<T>;
-    cancel(): void;
-    get isCancelled(): boolean;
+type ConductorLogLevel = keyof typeof LOG_LEVELS;
+interface DefaultLoggerConfig {
+    level?: ConductorLogLevel;
+    tags?: object[];
 }
-declare type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
-declare type Headers = Record<string, string>;
-declare type OpenAPIConfig = {
-    BASE: string;
-    VERSION: string;
-    WITH_CREDENTIALS: boolean;
-    CREDENTIALS: 'include' | 'omit' | 'same-origin';
-    TOKEN?: string | Resolver<string>;
-    USERNAME?: string | Resolver<string>;
-    PASSWORD?: string | Resolver<string>;
-    HEADERS?: Headers | Resolver<Headers>;
-    ENCODE_PATH?: (path: string) => string;
+declare const LOG_LEVELS: {
+    readonly DEBUG: 10;
+    readonly INFO: 30;
+    readonly ERROR: 60;
 };
-declare abstract class BaseHttpRequest {
-    readonly config: OpenAPIConfig;
-    constructor(config: OpenAPIConfig);
-    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+declare class DefaultLogger implements ConductorLogger {
+    private readonly tags;
+    private readonly level;
+    constructor(config?: DefaultLoggerConfig);
+    private log;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
 }
+declare const noopLogger: ConductorLogger;
-declare type StartWorkflow = {
+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 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 Declaration = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Declaration;
+    descriptorForType?: Descriptor;
+    fullName?: string;
+    fullNameBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    number?: number;
+    parserForType?: ParserDeclaration;
+    repeated?: boolean;
+    reserved?: boolean;
+    serializedSize?: number;
+    type?: string;
+    typeBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type DeclarationOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    fullName?: string;
+    fullNameBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    number?: number;
+    repeated?: boolean;
+    reserved?: boolean;
+    type?: string;
+    typeBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type Descriptor = {
+    containingType?: Descriptor;
+    enumTypes?: Array<EnumDescriptor>;
+    extendable?: boolean;
+    extensions?: Array<FieldDescriptor>;
+    fields?: Array<FieldDescriptor>;
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
     name?: string;
-    version?: number;
-    correlationId?: string;
-    input?: Record<string, any>;
-    taskToDomain?: Record<string, string>;
+    nestedTypes?: Array<Descriptor>;
+    oneofs?: Array<OneofDescriptor>;
+    options?: MessageOptions;
+    proto?: DescriptorProto;
+    realOneofs?: Array<OneofDescriptor>;
 };
-declare type TaskDetails = {
-    workflowId?: string;
-    taskRefName?: string;
-    output?: Record<string, any>;
-    taskId?: string;
+type DescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: DescriptorProto;
+    descriptorForType?: Descriptor;
+    enumTypeCount?: number;
+    enumTypeList?: Array<EnumDescriptorProto>;
+    enumTypeOrBuilderList?: Array<EnumDescriptorProtoOrBuilder>;
+    extensionCount?: number;
+    extensionList?: Array<FieldDescriptorProto>;
+    extensionOrBuilderList?: Array<FieldDescriptorProtoOrBuilder>;
+    extensionRangeCount?: number;
+    extensionRangeList?: Array<ExtensionRange>;
+    extensionRangeOrBuilderList?: Array<ExtensionRangeOrBuilder>;
+    fieldCount?: number;
+    fieldList?: Array<FieldDescriptorProto>;
+    fieldOrBuilderList?: Array<FieldDescriptorProtoOrBuilder>;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    nestedTypeCount?: number;
+    nestedTypeList?: Array<DescriptorProto>;
+    nestedTypeOrBuilderList?: Array<DescriptorProtoOrBuilder>;
+    oneofDeclCount?: number;
+    oneofDeclList?: Array<OneofDescriptorProto>;
+    oneofDeclOrBuilderList?: Array<OneofDescriptorProtoOrBuilder>;
+    options?: MessageOptions;
+    optionsOrBuilder?: MessageOptionsOrBuilder;
+    parserForType?: ParserDescriptorProto;
+    reservedNameCount?: number;
+    reservedNameList?: Array<string>;
+    reservedRangeCount?: number;
+    reservedRangeList?: Array<ReservedRange>;
+    reservedRangeOrBuilderList?: Array<ReservedRangeOrBuilder>;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
 };
-declare type Action = {
-    action?: 'start_workflow' | 'complete_task' | 'fail_task';
-    start_workflow?: StartWorkflow;
-    complete_task?: TaskDetails;
-    fail_task?: TaskDetails;
-    expandInlineJSON?: boolean;
+type DescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    enumTypeCount?: number;
+    enumTypeList?: Array<EnumDescriptorProto>;
+    enumTypeOrBuilderList?: Array<EnumDescriptorProtoOrBuilder>;
+    extensionCount?: number;
+    extensionList?: Array<FieldDescriptorProto>;
+    extensionOrBuilderList?: Array<FieldDescriptorProtoOrBuilder>;
+    extensionRangeCount?: number;
+    extensionRangeList?: Array<ExtensionRange>;
+    extensionRangeOrBuilderList?: Array<ExtensionRangeOrBuilder>;
+    fieldCount?: number;
+    fieldList?: Array<FieldDescriptorProto>;
+    fieldOrBuilderList?: Array<FieldDescriptorProtoOrBuilder>;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    nestedTypeCount?: number;
+    nestedTypeList?: Array<DescriptorProto>;
+    oneofDeclCount?: number;
+    oneofDeclList?: Array<OneofDescriptorProto>;
+    oneofDeclOrBuilderList?: Array<OneofDescriptorProtoOrBuilder>;
+    options?: MessageOptions;
+    optionsOrBuilder?: MessageOptionsOrBuilder;
+    reservedNameCount?: number;
+    reservedNameList?: Array<string>;
+    reservedRangeCount?: number;
+    reservedRangeList?: Array<ReservedRange>;
+    reservedRangeOrBuilderList?: Array<ReservedRangeOrBuilder>;
+    unknownFields?: UnknownFieldSet;
 };
-declare type EventHandler = {
-    name: string;
-    event: string;
-    condition?: string;
-    actions: Array<Action>;
-    active?: boolean;
-    evaluatorType?: string;
+type EditionDefault = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: EditionDefault;
+    descriptorForType?: Descriptor;
+    edition?: 'EDITION_UNKNOWN' | 'EDITION_PROTO2' | 'EDITION_PROTO3' | 'EDITION_2023' | 'EDITION_1_TEST_ONLY' | 'EDITION_2_TEST_ONLY' | 'EDITION_99997_TEST_ONLY' | 'EDITION_99998_TEST_ONLY' | 'EDITION_99999_TEST_ONLY';
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserEditionDefault;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+    value?: string;
+    valueBytes?: ByteString;
 };
-declare class EventResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Get queue config by name
-     * @param queueType
-     * @param queueName
-     * @returns any OK
-     * @throws ApiError
-     */
-    getQueueConfig(queueType: string, queueName: string): CancelablePromise<any>;
-    /**
-     * Create or update queue config by name
-     * @param queueType
-     * @param queueName
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    putQueueConfig(queueType: string, queueName: string, requestBody: string): CancelablePromise<any>;
-    /**
-     * Delete queue config by name
-     * @param queueType
-     * @param queueName
-     * @returns any OK
-     * @throws ApiError
-     */
-    deleteQueueConfig(queueType: string, queueName: string): CancelablePromise<any>;
-    /**
-     * Get all the event handlers
-     * @returns EventHandler OK
-     * @throws ApiError
-     */
-    getEventHandlers(): CancelablePromise<Array<EventHandler>>;
-    /**
-     * Update an existing event handler.
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    updateEventHandler(requestBody: EventHandler): CancelablePromise<any>;
-    /**
-     * Add a new event handler.
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    addEventHandler(requestBody: EventHandler): CancelablePromise<any>;
-    /**
-     * Get all queue configs
-     * @returns any OK
-     * @throws ApiError
-     */
-    getQueueNames(): CancelablePromise<any>;
-    /**
-     * Remove an event handler
-     * @param name
-     * @returns any OK
-     * @throws ApiError
-     */
-    removeEventHandlerStatus(name: string): CancelablePromise<any>;
+type EditionDefaultOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    edition?: 'EDITION_UNKNOWN' | 'EDITION_PROTO2' | 'EDITION_PROTO3' | 'EDITION_2023' | 'EDITION_1_TEST_ONLY' | 'EDITION_2_TEST_ONLY' | 'EDITION_99997_TEST_ONLY' | 'EDITION_99998_TEST_ONLY' | 'EDITION_99999_TEST_ONLY';
+    initializationErrorString?: string;
+    initialized?: boolean;
+    unknownFields?: UnknownFieldSet;
+    value?: string;
+    valueBytes?: ByteString;
+};
+type EnumDescriptor = {
+    closed?: boolean;
+    containingType?: Descriptor;
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
+    name?: string;
+    options?: EnumOptions;
+    proto?: EnumDescriptorProto;
+    values?: Array<EnumValueDescriptor>;
+};
+type EnumDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: EnumDescriptorProto;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: EnumOptions;
+    optionsOrBuilder?: EnumOptionsOrBuilder;
+    parserForType?: ParserEnumDescriptorProto;
+    reservedNameCount?: number;
+    reservedNameList?: Array<string>;
+    reservedRangeCount?: number;
+    reservedRangeList?: Array<EnumReservedRange>;
+    reservedRangeOrBuilderList?: Array<EnumReservedRangeOrBuilder>;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+    valueCount?: number;
+    valueList?: Array<EnumValueDescriptorProto>;
+    valueOrBuilderList?: Array<EnumValueDescriptorProtoOrBuilder>;
+};
+type EnumDescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: EnumOptions;
+    optionsOrBuilder?: EnumOptionsOrBuilder;
+    reservedNameCount?: number;
+    reservedNameList?: Array<string>;
+    reservedRangeCount?: number;
+    reservedRangeList?: Array<EnumReservedRange>;
+    reservedRangeOrBuilderList?: Array<EnumReservedRangeOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+    valueCount?: number;
+    valueList?: Array<EnumValueDescriptorProto>;
+    valueOrBuilderList?: Array<EnumValueDescriptorProtoOrBuilder>;
+};
+type EnumOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    allowAlias?: boolean;
+    defaultInstanceForType?: EnumOptions;
+    deprecated?: boolean;
     /**
-     * Get event handlers for a given event
-     * @param event
-     * @param activeOnly
-     * @returns EventHandler OK
-     * @throws ApiError
+     * @deprecated
      */
-    getEventHandlersForEvent(event: string, activeOnly?: boolean): CancelablePromise<Array<EventHandler>>;
-}
-declare class HealthCheckResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
+    deprecatedLegacyJsonFieldConflicts?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserEnumOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allowAlias?: boolean;
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
     /**
-     * @returns any OK
-     * @throws ApiError
+     * @deprecated
      */
-    doCheck(): CancelablePromise<Record<string, any>>;
-}
-declare type TaskDef = {
-    ownerApp?: string;
+    deprecatedLegacyJsonFieldConflicts?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumReservedRange = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: EnumReservedRange;
+    descriptorForType?: Descriptor;
+    end?: number;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserEnumReservedRange;
+    serializedSize?: number;
+    start?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumReservedRangeOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    end?: number;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    start?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumValueDescriptor = {
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
+    name?: string;
+    number?: number;
+    options?: EnumValueOptions;
+    proto?: EnumValueDescriptorProto;
+    type?: EnumDescriptor;
+};
+type EnumValueDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: EnumValueDescriptorProto;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    number?: number;
+    options?: EnumValueOptions;
+    optionsOrBuilder?: EnumValueOptionsOrBuilder;
+    parserForType?: ParserEnumValueDescriptorProto;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumValueDescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    number?: number;
+    options?: EnumValueOptions;
+    optionsOrBuilder?: EnumValueOptionsOrBuilder;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumValueOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    debugRedact?: boolean;
+    defaultInstanceForType?: EnumValueOptions;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserEnumValueOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type EnumValueOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    debugRedact?: boolean;
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type EventHandler = {
+    actions?: Array<Action>;
+    active?: boolean;
+    condition?: string;
+    createdBy?: string;
+    description?: string;
+    evaluatorType?: string;
+    event?: string;
+    name?: string;
+    orgId?: string;
+    tags?: Array<Tag>;
+};
+type ExtendedTaskDef$1 = {
+    backoffScaleFactor?: number;
+    baseType?: string;
+    concurrentExecLimit?: number;
     createTime?: number;
-    updateTime?: number;
     createdBy?: string;
-    updatedBy?: string;
-    name: string;
     description?: string;
-    retryCount?: number;
-    timeoutSeconds: number;
+    enforceSchema?: boolean;
+    executionNameSpace?: string;
     inputKeys?: Array<string>;
-    outputKeys?: Array<string>;
-    timeoutPolicy?: 'RETRY' | 'TIME_OUT_WF' | 'ALERT_ONLY';
-    retryLogic?: 'FIXED' | 'EXPONENTIAL_BACKOFF' | 'LINEAR_BACKOFF';
-    retryDelaySeconds?: number;
-    responseTimeoutSeconds?: number;
-    concurrentExecLimit?: number;
-    inputTemplate?: Record<string, any>;
-    rateLimitPerFrequency?: number;
-    rateLimitFrequencyInSeconds?: number;
+    inputSchema?: SchemaDef;
+    inputTemplate?: {
+        [key: string]: unknown;
+    };
     isolationGroupId?: string;
-    executionNameSpace?: string;
+    name: string;
+    outputKeys?: Array<string>;
+    outputSchema?: SchemaDef;
+    overwriteTags?: boolean;
+    ownerApp?: string;
     ownerEmail?: string;
     pollTimeoutSeconds?: number;
-    backoffScaleFactor?: number;
-};
-declare type SubWorkflowParams = {
-    name: string;
-    version?: number;
-    taskToDomain?: Record<string, string>;
-    workflowDefinition?: WorkflowDef$1;
-    idempotencyKey?: string;
-    idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING';
-};
-declare type WorkflowTask = {
-    name: string;
-    taskReferenceName: string;
-    description?: string;
-    inputParameters?: Record<string, any>;
-    type?: string;
-    dynamicTaskNameParam?: string;
-    /**
-     * @deprecated
-     */
-    caseValueParam?: string;
-    /**
-     * @deprecated
-     */
-    caseExpression?: string;
-    scriptExpression?: string;
-    decisionCases?: Record<string, Array<WorkflowTask>>;
-    /**
-     * @deprecated
-     */
-    dynamicForkJoinTasksParam?: string;
-    dynamicForkTasksParam?: string;
-    dynamicForkTasksInputParamName?: string;
-    defaultCase?: Array<WorkflowTask>;
-    forkTasks?: Array<Array<WorkflowTask>>;
-    startDelay?: number;
-    subWorkflowParam?: SubWorkflowParams;
-    joinOn?: Array<string>;
-    sink?: string;
-    optional?: boolean;
-    taskDefinition?: TaskDef;
-    rateLimited?: boolean;
-    defaultExclusiveJoinTask?: Array<string>;
-    asyncComplete?: boolean;
-    loopCondition?: string;
-    loopOver?: Array<WorkflowTask>;
+    rateLimitFrequencyInSeconds?: number;
+    rateLimitPerFrequency?: number;
+    responseTimeoutSeconds?: number;
     retryCount?: number;
-    evaluatorType?: string;
-    expression?: string;
-    workflowTaskType?: 'SIMPLE' | 'DYNAMIC' | 'FORK_JOIN' | 'FORK_JOIN_DYNAMIC' | 'DECISION' | 'SWITCH' | 'JOIN' | 'DO_WHILE' | 'SUB_WORKFLOW' | 'START_WORKFLOW' | 'EVENT' | 'WAIT' | 'HUMAN' | 'USER_DEFINED' | 'HTTP' | 'LAMBDA' | 'INLINE' | 'EXCLUSIVE_JOIN' | 'TERMINATE' | 'KAFKA_PUBLISH' | 'JSON_JQ_TRANSFORM' | 'SET_VARIABLE';
+    retryDelaySeconds?: number;
+    retryLogic?: 'FIXED' | 'EXPONENTIAL_BACKOFF' | 'LINEAR_BACKOFF';
+    tags?: Array<Tag>;
+    timeoutPolicy?: 'RETRY' | 'TIME_OUT_WF' | 'ALERT_ONLY';
+    timeoutSeconds: number;
+    totalTimeoutSeconds: number;
+    updateTime?: number;
+    updatedBy?: string;
 };
-declare type WorkflowDef$1 = {
-    ownerApp?: string;
+type ExtendedWorkflowDef = {
+    cacheConfig?: CacheConfig;
     createTime?: number;
-    updateTime?: number;
     createdBy?: string;
-    updatedBy?: string;
-    name: string;
     description?: string;
-    version?: number;
-    tasks: Array<WorkflowTask>;
-    inputParameters?: Array<string>;
-    outputParameters?: Record<string, any>;
+    enforceSchema?: boolean;
     failureWorkflow?: string;
-    schemaVersion?: number;
-    restartable?: boolean;
-    workflowStatusListenerEnabled?: boolean;
+    inputParameters?: Array<string>;
+    inputSchema?: SchemaDef;
+    inputTemplate?: {
+        [key: string]: unknown;
+    };
+    maskedFields?: Array<string>;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    name: string;
+    outputParameters?: {
+        [key: string]: unknown;
+    };
+    outputSchema?: SchemaDef;
+    overwriteTags?: boolean;
+    ownerApp?: string;
     ownerEmail?: string;
+    rateLimitConfig?: RateLimitConfig;
+    restartable?: boolean;
+    schemaVersion?: number;
+    tags?: Array<Tag>;
+    tasks: Array<WorkflowTask>;
     timeoutPolicy?: 'TIME_OUT_WF' | 'ALERT_ONLY';
     timeoutSeconds: number;
-    variables?: Record<string, any>;
-    inputTemplate?: Record<string, any>;
+    updateTime?: number;
+    updatedBy?: string;
+    variables?: {
+        [key: string]: unknown;
+    };
+    version?: number;
+    workflowStatusListenerEnabled?: boolean;
+    workflowStatusListenerSink?: string;
 };
-declare class MetadataResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Gets the task definition
-     * @param tasktype
-     * @param metadata
-     * @returns TaskDef OK
-     * @throws ApiError
-     */
-    getTaskDef(tasktype: string, metadata?: boolean): CancelablePromise<TaskDef>;
-    /**
-     * Remove a task definition
-     * @param tasktype
-     * @returns any OK
-     * @throws ApiError
-     */
-    unregisterTaskDef(tasktype: string): CancelablePromise<any>;
-    /**
-     * Retrieves all workflow definition along with blueprint
-     * @param access
-     * @param metadata
-     * @param tagKey
-     * @param tagValue
-     * @returns WorkflowDef OK
-     * @throws ApiError
-     */
-    getAllWorkflows(access?: string, metadata?: boolean, tagKey?: string, tagValue?: string): CancelablePromise<Array<WorkflowDef$1>>;
-    /**
-     * Create or update workflow definition(s)
-     * @param requestBody
-     * @param overwrite
-     * @returns any OK
-     * @throws ApiError
-     */
-    update(requestBody: Array<WorkflowDef$1>, overwrite?: boolean): CancelablePromise<any>;
-    /**
-     * Create a new workflow definition
-     * @param requestBody
-     * @param overwrite
-     * @returns any OK
-     * @throws ApiError
-     */
-    create(requestBody: WorkflowDef$1, overwrite?: boolean): CancelablePromise<any>;
-    /**
-     * Gets all task definition
-     * @param access
-     * @param metadata
-     * @param tagKey
-     * @param tagValue
-     * @returns TaskDef OK
-     * @throws ApiError
-     */
-    getTaskDefs(access?: string, metadata?: boolean, tagKey?: string, tagValue?: string): CancelablePromise<Array<TaskDef>>;
-    /**
-     * Update an existing task
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    updateTaskDef(requestBody: TaskDef): CancelablePromise<any>;
+type ExtensionRange = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: ExtensionRange;
+    descriptorForType?: Descriptor;
+    end?: number;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    options?: ExtensionRangeOptions;
+    optionsOrBuilder?: ExtensionRangeOptionsOrBuilder;
+    parserForType?: ParserExtensionRange;
+    serializedSize?: number;
+    start?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type ExtensionRangeOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    declarationCount?: number;
+    declarationList?: Array<Declaration>;
+    declarationOrBuilderList?: Array<DeclarationOrBuilder>;
+    defaultInstanceForType?: ExtensionRangeOptions;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserExtensionRangeOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+    verification?: 'DECLARATION' | 'UNVERIFIED';
+};
+type ExtensionRangeOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    declarationCount?: number;
+    declarationList?: Array<Declaration>;
+    declarationOrBuilderList?: Array<DeclarationOrBuilder>;
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+    verification?: 'DECLARATION' | 'UNVERIFIED';
+};
+type ExtensionRangeOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    end?: number;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    options?: ExtensionRangeOptions;
+    optionsOrBuilder?: ExtensionRangeOptionsOrBuilder;
+    start?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type FeatureSet = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: FeatureSet;
+    descriptorForType?: Descriptor;
+    enumType?: 'ENUM_TYPE_UNKNOWN' | 'OPEN' | 'CLOSED';
+    fieldPresence?: 'FIELD_PRESENCE_UNKNOWN' | 'EXPLICIT' | 'IMPLICIT' | 'LEGACY_REQUIRED';
+    initializationErrorString?: string;
+    initialized?: boolean;
+    jsonFormat?: 'JSON_FORMAT_UNKNOWN' | 'ALLOW' | 'LEGACY_BEST_EFFORT';
+    messageEncoding?: 'MESSAGE_ENCODING_UNKNOWN' | 'LENGTH_PREFIXED' | 'DELIMITED';
+    parserForType?: ParserFeatureSet;
+    repeatedFieldEncoding?: 'REPEATED_FIELD_ENCODING_UNKNOWN' | 'PACKED' | 'EXPANDED';
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+    utf8Validation?: 'UTF8_VALIDATION_UNKNOWN' | 'NONE' | 'VERIFY';
+};
+type FeatureSetOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    enumType?: 'ENUM_TYPE_UNKNOWN' | 'OPEN' | 'CLOSED';
+    fieldPresence?: 'FIELD_PRESENCE_UNKNOWN' | 'EXPLICIT' | 'IMPLICIT' | 'LEGACY_REQUIRED';
+    initializationErrorString?: string;
+    initialized?: boolean;
+    jsonFormat?: 'JSON_FORMAT_UNKNOWN' | 'ALLOW' | 'LEGACY_BEST_EFFORT';
+    messageEncoding?: 'MESSAGE_ENCODING_UNKNOWN' | 'LENGTH_PREFIXED' | 'DELIMITED';
+    repeatedFieldEncoding?: 'REPEATED_FIELD_ENCODING_UNKNOWN' | 'PACKED' | 'EXPANDED';
+    unknownFields?: UnknownFieldSet;
+    utf8Validation?: 'UTF8_VALIDATION_UNKNOWN' | 'NONE' | 'VERIFY';
+};
+type FieldDescriptor = {
+    containingOneof?: OneofDescriptor;
+    containingType?: Descriptor;
+    defaultValue?: {
+        [key: string]: unknown;
+    };
+    enumType?: EnumDescriptor;
+    extension?: boolean;
+    extensionScope?: Descriptor;
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
+    javaType?: 'INT' | 'LONG' | 'FLOAT' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'BYTE_STRING' | 'ENUM' | 'MESSAGE';
+    jsonName?: string;
+    liteJavaType?: 'INT' | 'LONG' | 'FLOAT' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'BYTE_STRING' | 'ENUM' | 'MESSAGE';
+    liteType?: 'DOUBLE' | 'FLOAT' | 'INT64' | 'UINT64' | 'INT32' | 'FIXED64' | 'FIXED32' | 'BOOL' | 'STRING' | 'GROUP' | 'MESSAGE' | 'BYTES' | 'UINT32' | 'ENUM' | 'SFIXED32' | 'SFIXED64' | 'SINT32' | 'SINT64';
+    mapField?: boolean;
+    messageType?: Descriptor;
+    name?: string;
+    number?: number;
+    optional?: boolean;
+    options?: FieldOptions;
+    packable?: boolean;
+    packed?: boolean;
+    proto?: FieldDescriptorProto;
+    realContainingOneof?: OneofDescriptor;
+    repeated?: boolean;
+    required?: boolean;
+    type?: 'DOUBLE' | 'FLOAT' | 'INT64' | 'UINT64' | 'INT32' | 'FIXED64' | 'FIXED32' | 'BOOL' | 'STRING' | 'GROUP' | 'MESSAGE' | 'BYTES' | 'UINT32' | 'ENUM' | 'SFIXED32' | 'SFIXED64' | 'SINT32' | 'SINT64';
+};
+type FieldDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: FieldDescriptorProto;
+    defaultValue?: string;
+    defaultValueBytes?: ByteString;
+    descriptorForType?: Descriptor;
+    extendee?: string;
+    extendeeBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    jsonName?: string;
+    jsonNameBytes?: ByteString;
+    label?: 'LABEL_OPTIONAL' | 'LABEL_REPEATED' | 'LABEL_REQUIRED';
+    name?: string;
+    nameBytes?: ByteString;
+    number?: number;
+    oneofIndex?: number;
+    options?: FieldOptions;
+    optionsOrBuilder?: FieldOptionsOrBuilder;
+    parserForType?: ParserFieldDescriptorProto;
+    proto3Optional?: boolean;
+    serializedSize?: number;
+    type?: 'TYPE_DOUBLE' | 'TYPE_FLOAT' | 'TYPE_INT64' | 'TYPE_UINT64' | 'TYPE_INT32' | 'TYPE_FIXED64' | 'TYPE_FIXED32' | 'TYPE_BOOL' | 'TYPE_STRING' | 'TYPE_GROUP' | 'TYPE_MESSAGE' | 'TYPE_BYTES' | 'TYPE_UINT32' | 'TYPE_ENUM' | 'TYPE_SFIXED32' | 'TYPE_SFIXED64' | 'TYPE_SINT32' | 'TYPE_SINT64';
+    typeName?: string;
+    typeNameBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type FieldDescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    defaultValue?: string;
+    defaultValueBytes?: ByteString;
+    descriptorForType?: Descriptor;
+    extendee?: string;
+    extendeeBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    jsonName?: string;
+    jsonNameBytes?: ByteString;
+    label?: 'LABEL_OPTIONAL' | 'LABEL_REPEATED' | 'LABEL_REQUIRED';
+    name?: string;
+    nameBytes?: ByteString;
+    number?: number;
+    oneofIndex?: number;
+    options?: FieldOptions;
+    optionsOrBuilder?: FieldOptionsOrBuilder;
+    proto3Optional?: boolean;
+    type?: 'TYPE_DOUBLE' | 'TYPE_FLOAT' | 'TYPE_INT64' | 'TYPE_UINT64' | 'TYPE_INT32' | 'TYPE_FIXED64' | 'TYPE_FIXED32' | 'TYPE_BOOL' | 'TYPE_STRING' | 'TYPE_GROUP' | 'TYPE_MESSAGE' | 'TYPE_BYTES' | 'TYPE_UINT32' | 'TYPE_ENUM' | 'TYPE_SFIXED32' | 'TYPE_SFIXED64' | 'TYPE_SINT32' | 'TYPE_SINT64';
+    typeName?: string;
+    typeNameBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type FieldOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    ctype?: 'STRING' | 'CORD' | 'STRING_PIECE';
+    debugRedact?: boolean;
+    defaultInstanceForType?: FieldOptions;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    editionDefaultsCount?: number;
+    editionDefaultsList?: Array<EditionDefault>;
+    editionDefaultsOrBuilderList?: Array<EditionDefaultOrBuilder>;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    jstype?: 'JS_NORMAL' | 'JS_STRING' | 'JS_NUMBER';
+    lazy?: boolean;
+    packed?: boolean;
+    parserForType?: ParserFieldOptions;
+    retention?: 'RETENTION_UNKNOWN' | 'RETENTION_RUNTIME' | 'RETENTION_SOURCE';
+    serializedSize?: number;
+    targetsCount?: number;
+    targetsList?: Array<'TARGET_TYPE_UNKNOWN' | 'TARGET_TYPE_FILE' | 'TARGET_TYPE_EXTENSION_RANGE' | 'TARGET_TYPE_MESSAGE' | 'TARGET_TYPE_FIELD' | 'TARGET_TYPE_ONEOF' | 'TARGET_TYPE_ENUM' | 'TARGET_TYPE_ENUM_ENTRY' | 'TARGET_TYPE_SERVICE' | 'TARGET_TYPE_METHOD'>;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+    unverifiedLazy?: boolean;
+    weak?: boolean;
+};
+type FieldOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    ctype?: 'STRING' | 'CORD' | 'STRING_PIECE';
+    debugRedact?: boolean;
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    editionDefaultsCount?: number;
+    editionDefaultsList?: Array<EditionDefault>;
+    editionDefaultsOrBuilderList?: Array<EditionDefaultOrBuilder>;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    jstype?: 'JS_NORMAL' | 'JS_STRING' | 'JS_NUMBER';
+    lazy?: boolean;
+    packed?: boolean;
+    retention?: 'RETENTION_UNKNOWN' | 'RETENTION_RUNTIME' | 'RETENTION_SOURCE';
+    targetsCount?: number;
+    targetsList?: Array<'TARGET_TYPE_UNKNOWN' | 'TARGET_TYPE_FILE' | 'TARGET_TYPE_EXTENSION_RANGE' | 'TARGET_TYPE_MESSAGE' | 'TARGET_TYPE_FIELD' | 'TARGET_TYPE_ONEOF' | 'TARGET_TYPE_ENUM' | 'TARGET_TYPE_ENUM_ENTRY' | 'TARGET_TYPE_SERVICE' | 'TARGET_TYPE_METHOD'>;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+    unverifiedLazy?: boolean;
+    weak?: boolean;
+};
+type FileDescriptor = {
+    dependencies?: Array<FileDescriptor>;
+    edition?: 'EDITION_UNKNOWN' | 'EDITION_PROTO2' | 'EDITION_PROTO3' | 'EDITION_2023' | 'EDITION_1_TEST_ONLY' | 'EDITION_2_TEST_ONLY' | 'EDITION_99997_TEST_ONLY' | 'EDITION_99998_TEST_ONLY' | 'EDITION_99999_TEST_ONLY';
+    editionName?: string;
+    enumTypes?: Array<EnumDescriptor>;
+    extensions?: Array<FieldDescriptor>;
+    file?: FileDescriptor;
+    fullName?: string;
+    messageTypes?: Array<Descriptor>;
+    name?: string;
+    options?: FileOptions;
+    package?: string;
+    proto?: FileDescriptorProto;
+    publicDependencies?: Array<FileDescriptor>;
+    services?: Array<ServiceDescriptor>;
     /**
-     * Create or update task definition(s)
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
+     * @deprecated
      */
-    registerTaskDef(requestBody: Array<TaskDef>): CancelablePromise<any>;
+    syntax?: 'UNKNOWN' | 'PROTO2' | 'PROTO3' | 'EDITIONS';
+};
+type FileDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: FileDescriptorProto;
+    dependencyCount?: number;
+    dependencyList?: Array<string>;
+    descriptorForType?: Descriptor;
+    edition?: 'EDITION_UNKNOWN' | 'EDITION_PROTO2' | 'EDITION_PROTO3' | 'EDITION_2023' | 'EDITION_1_TEST_ONLY' | 'EDITION_2_TEST_ONLY' | 'EDITION_99997_TEST_ONLY' | 'EDITION_99998_TEST_ONLY' | 'EDITION_99999_TEST_ONLY';
+    enumTypeCount?: number;
+    enumTypeList?: Array<EnumDescriptorProto>;
+    enumTypeOrBuilderList?: Array<EnumDescriptorProtoOrBuilder>;
+    extensionCount?: number;
+    extensionList?: Array<FieldDescriptorProto>;
+    extensionOrBuilderList?: Array<FieldDescriptorProtoOrBuilder>;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    messageTypeCount?: number;
+    messageTypeList?: Array<DescriptorProto>;
+    messageTypeOrBuilderList?: Array<DescriptorProtoOrBuilder>;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: FileOptions;
+    optionsOrBuilder?: FileOptionsOrBuilder;
+    package?: string;
+    packageBytes?: ByteString;
+    parserForType?: ParserFileDescriptorProto;
+    publicDependencyCount?: number;
+    publicDependencyList?: Array<number>;
+    serializedSize?: number;
+    serviceCount?: number;
+    serviceList?: Array<ServiceDescriptorProto>;
+    serviceOrBuilderList?: Array<ServiceDescriptorProtoOrBuilder>;
+    sourceCodeInfo?: SourceCodeInfo;
+    sourceCodeInfoOrBuilder?: SourceCodeInfoOrBuilder;
+    syntax?: string;
+    syntaxBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+    weakDependencyCount?: number;
+    weakDependencyList?: Array<number>;
+};
+type FileOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    ccEnableArenas?: boolean;
+    ccGenericServices?: boolean;
+    csharpNamespace?: string;
+    csharpNamespaceBytes?: ByteString;
+    defaultInstanceForType?: FileOptions;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    goPackage?: string;
+    goPackageBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
     /**
-     * Removes workflow definition. It does not remove workflows associated with the definition.
-     * @param name
-     * @param version
-     * @returns any OK
-     * @throws ApiError
+     * @deprecated
      */
-    unregisterWorkflowDef(name: string, version: number): CancelablePromise<any>;
+    javaGenerateEqualsAndHash?: boolean;
+    javaGenericServices?: boolean;
+    javaMultipleFiles?: boolean;
+    javaOuterClassname?: string;
+    javaOuterClassnameBytes?: ByteString;
+    javaPackage?: string;
+    javaPackageBytes?: ByteString;
+    javaStringCheckUtf8?: boolean;
+    objcClassPrefix?: string;
+    objcClassPrefixBytes?: ByteString;
+    optimizeFor?: 'SPEED' | 'CODE_SIZE' | 'LITE_RUNTIME';
+    parserForType?: ParserFileOptions;
+    phpClassPrefix?: string;
+    phpClassPrefixBytes?: ByteString;
+    phpGenericServices?: boolean;
+    phpMetadataNamespace?: string;
+    phpMetadataNamespaceBytes?: ByteString;
+    phpNamespace?: string;
+    phpNamespaceBytes?: ByteString;
+    pyGenericServices?: boolean;
+    rubyPackage?: string;
+    rubyPackageBytes?: ByteString;
+    serializedSize?: number;
+    swiftPrefix?: string;
+    swiftPrefixBytes?: ByteString;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type FileOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    ccEnableArenas?: boolean;
+    ccGenericServices?: boolean;
+    csharpNamespace?: string;
+    csharpNamespaceBytes?: ByteString;
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    goPackage?: string;
+    goPackageBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
     /**
-     * Retrieves workflow definition along with blueprint
-     * @param name
-     * @param version
-     * @param metadata
-     * @returns WorkflowDef OK
-     * @throws ApiError
+     * @deprecated
      */
-    get(name: string, version?: number, metadata?: boolean): CancelablePromise<WorkflowDef$1>;
-}
-declare type StartWorkflowRequest = {
-    name: string;
-    version?: number;
-    correlationId?: string;
-    input?: Record<string, any>;
-    taskToDomain?: Record<string, string>;
-    workflowDef?: WorkflowDef$1;
-    externalInputPayloadStoragePath?: string;
-    idempotencyKey?: string;
-    idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING';
-    priority?: number;
-    createdBy?: string;
+    javaGenerateEqualsAndHash?: boolean;
+    javaGenericServices?: boolean;
+    javaMultipleFiles?: boolean;
+    javaOuterClassname?: string;
+    javaOuterClassnameBytes?: ByteString;
+    javaPackage?: string;
+    javaPackageBytes?: ByteString;
+    javaStringCheckUtf8?: boolean;
+    objcClassPrefix?: string;
+    objcClassPrefixBytes?: ByteString;
+    optimizeFor?: 'SPEED' | 'CODE_SIZE' | 'LITE_RUNTIME';
+    phpClassPrefix?: string;
+    phpClassPrefixBytes?: ByteString;
+    phpGenericServices?: boolean;
+    phpMetadataNamespace?: string;
+    phpMetadataNamespaceBytes?: ByteString;
+    phpNamespace?: string;
+    phpNamespaceBytes?: ByteString;
+    pyGenericServices?: boolean;
+    rubyPackage?: string;
+    rubyPackageBytes?: ByteString;
+    swiftPrefix?: string;
+    swiftPrefixBytes?: ByteString;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
 };
-declare type SaveScheduleRequest = {
-    name: string;
-    cronExpression: string;
-    runCatchupScheduleInstances?: boolean;
-    paused?: boolean;
-    startWorkflowRequest?: StartWorkflowRequest;
+type GenerateTokenRequest = {
+    expiration?: number;
+    keyId: string;
+    keySecret: string;
+};
+type HumanTaskAssignment = {
+    assignee?: HumanTaskUser;
+    slaMinutes?: number;
+};
+type HumanTaskDefinition = {
+    assignmentCompletionStrategy?: 'LEAVE_OPEN' | 'TERMINATE';
+    assignments?: Array<HumanTaskAssignment>;
+    displayName?: string;
+    fullTemplate?: HumanTaskTemplate;
+    taskTriggers?: Array<HumanTaskTrigger>;
+    userFormTemplate?: UserFormTemplate;
+};
+type HumanTaskEntry = {
+    assignee?: HumanTaskUser;
+    claimant?: HumanTaskUser;
     createdBy?: string;
+    createdOn?: number;
+    definitionName?: string;
+    displayName?: string;
+    humanTaskDef?: HumanTaskDefinition;
+    input?: {
+        [key: string]: unknown;
+    };
+    output?: {
+        [key: string]: unknown;
+    };
+    ownerApp?: string;
+    state?: 'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT' | 'DELETED';
+    taskId?: string;
+    taskRefName?: string;
     updatedBy?: string;
-    scheduleStartTime?: number;
-    scheduleEndTime?: number;
-};
-declare type WorkflowScheduleExecutionModel = {
-    executionId?: string;
-    scheduleName?: string;
-    scheduledTime?: number;
-    executionTime?: number;
-    workflowName?: string;
+    updatedOn?: number;
     workflowId?: string;
-    reason?: string;
-    stackTrace?: string;
-    startWorkflowRequest?: StartWorkflowRequest;
-    state?: 'POLLED' | 'FAILED' | 'EXECUTED';
+    workflowName?: string;
 };
-declare type SearchResultWorkflowScheduleExecutionModel = {
+type HumanTaskSearch = {
+    assignees?: Array<HumanTaskUser>;
+    claimants?: Array<HumanTaskUser>;
+    definitionNames?: Array<string>;
+    displayNames?: Array<string>;
+    fullTextQuery?: string;
+    searchType?: 'ADMIN' | 'INBOX';
+    size?: number;
+    start?: number;
+    states?: Array<'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT' | 'DELETED'>;
+    taskInputQuery?: string;
+    taskOutputQuery?: string;
+    taskRefNames?: Array<string>;
+    updateEndTime?: number;
+    updateStartTime?: number;
+    workflowIds?: Array<string>;
+    workflowNames?: Array<string>;
+};
+type HumanTaskSearchResult = {
+    hits?: number;
+    pageSizeLimit?: number;
+    results?: Array<HumanTaskEntry>;
+    start?: number;
     totalHits?: number;
-    results?: Array<WorkflowScheduleExecutionModel>;
 };
-declare type WorkflowSchedule = {
-    name?: string;
-    cronExpression?: string;
-    runCatchupScheduleInstances?: boolean;
-    paused?: boolean;
-    startWorkflowRequest?: StartWorkflowRequest;
-    scheduleStartTime?: number;
-    scheduleEndTime?: number;
+type HumanTaskTemplate = {
     createTime?: number;
-    updatedTime?: number;
     createdBy?: string;
+    jsonSchema: {
+        [key: string]: unknown;
+    };
+    name: string;
+    ownerApp?: string;
+    tags?: Array<Tag>;
+    templateUI: {
+        [key: string]: unknown;
+    };
+    updateTime?: number;
     updatedBy?: string;
+    version: number;
 };
-declare class SchedulerResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Get an existing workflow schedule by name
-     * @param name
-     * @returns any OK
-     * @throws ApiError
-     */
-    getSchedule(name: string): CancelablePromise<any>;
-    /**
-     * Deletes an existing workflow schedule by name
-     * @param name
-     * @returns any OK
-     * @throws ApiError
-     */
-    deleteSchedule(name: string): CancelablePromise<any>;
+type HumanTaskTrigger = {
+    startWorkflowRequest?: StartWorkflowRequest;
+    triggerType?: 'ASSIGNEE_CHANGED' | 'CLAIMANT_CHANGED' | 'PENDING' | 'IN_PROGRESS' | 'ASSIGNED' | 'COMPLETED' | 'TIMED_OUT';
+};
+type HumanTaskUser = {
+    user?: string;
+    userType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
+};
+type Location = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Location;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    leadingComments?: string;
+    leadingCommentsBytes?: ByteString;
+    leadingDetachedCommentsCount?: number;
+    leadingDetachedCommentsList?: Array<string>;
+    parserForType?: ParserLocation;
+    pathCount?: number;
+    pathList?: Array<number>;
+    serializedSize?: number;
+    spanCount?: number;
+    spanList?: Array<number>;
+    trailingComments?: string;
+    trailingCommentsBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type LocationOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    leadingComments?: string;
+    leadingCommentsBytes?: ByteString;
+    leadingDetachedCommentsCount?: number;
+    leadingDetachedCommentsList?: Array<string>;
+    pathCount?: number;
+    pathList?: Array<number>;
+    spanCount?: number;
+    spanList?: Array<number>;
+    trailingComments?: string;
+    trailingCommentsBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type Message = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: MessageLite;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserMessage;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type MessageLite = {
+    defaultInstanceForType?: MessageLite;
+    initialized?: boolean;
+    parserForType?: ParserMessageLite;
+    serializedSize?: number;
+};
+type MessageOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: MessageOptions;
+    deprecated?: boolean;
     /**
-     * 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
+     * @deprecated
      */
-    getNextFewSchedules(cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): CancelablePromise<Array<number>>;
+    deprecatedLegacyJsonFieldConflicts?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    mapEntry?: boolean;
+    messageSetWireFormat?: boolean;
+    noStandardDescriptorAccessor?: boolean;
+    parserForType?: ParserMessageOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type MessageOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
     /**
-     * Pauses an existing schedule by name
-     * @param name
-     * @returns any OK
-     * @throws ApiError
+     * @deprecated
      */
-    pauseSchedule(name: string): CancelablePromise<any>;
+    deprecatedLegacyJsonFieldConflicts?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    mapEntry?: boolean;
+    messageSetWireFormat?: boolean;
+    noStandardDescriptorAccessor?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type MethodDescriptor = {
+    clientStreaming?: boolean;
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
+    inputType?: Descriptor;
+    name?: string;
+    options?: MethodOptions;
+    outputType?: Descriptor;
+    proto?: MethodDescriptorProto;
+    serverStreaming?: boolean;
+    service?: ServiceDescriptor;
+};
+type MethodDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    clientStreaming?: boolean;
+    defaultInstanceForType?: MethodDescriptorProto;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    inputType?: string;
+    inputTypeBytes?: ByteString;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: MethodOptions;
+    optionsOrBuilder?: MethodOptionsOrBuilder;
+    outputType?: string;
+    outputTypeBytes?: ByteString;
+    parserForType?: ParserMethodDescriptorProto;
+    serializedSize?: number;
+    serverStreaming?: boolean;
+    unknownFields?: UnknownFieldSet;
+};
+type MethodDescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    clientStreaming?: boolean;
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    inputType?: string;
+    inputTypeBytes?: ByteString;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: MethodOptions;
+    optionsOrBuilder?: MethodOptionsOrBuilder;
+    outputType?: string;
+    outputTypeBytes?: ByteString;
+    serverStreaming?: boolean;
+    unknownFields?: UnknownFieldSet;
+};
+type MethodOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: MethodOptions;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    idempotencyLevel?: 'IDEMPOTENCY_UNKNOWN' | 'NO_SIDE_EFFECTS' | 'IDEMPOTENT';
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserMethodOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type MethodOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    idempotencyLevel?: 'IDEMPOTENCY_UNKNOWN' | 'NO_SIDE_EFFECTS' | 'IDEMPOTENT';
+    initializationErrorString?: string;
+    initialized?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type NamePart = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: NamePart;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    isExtension?: boolean;
+    namePart?: string;
+    namePartBytes?: ByteString;
+    parserForType?: ParserNamePart;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type NamePartOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    isExtension?: boolean;
+    namePart?: string;
+    namePartBytes?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type OneofDescriptor = {
+    containingType?: Descriptor;
+    fieldCount?: number;
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
+    name?: string;
+    options?: OneofOptions;
+    proto?: OneofDescriptorProto;
     /**
-     * Pause all scheduling in a single conductor server instance (for debugging only)
-     * @returns any OK
-     * @throws ApiError
+     * @deprecated
      */
-    pauseAllSchedules(): CancelablePromise<Record<string, any>>;
-    /**
-     * Resume a paused schedule by name
-     * @param name
-     * @returns any OK
-     * @throws ApiError
-     */
-    resumeSchedule(name: string): CancelablePromise<any>;
-    /**
-     * Requeue all execution records
-     * @returns any OK
-     * @throws ApiError
-     */
-    requeueAllExecutionRecords(): CancelablePromise<Record<string, any>>;
-    /**
-     * Resume all scheduling
-     * @returns any OK
-     * @throws ApiError
-     */
-    resumeAllSchedules(): CancelablePromise<Record<string, any>>;
-    /**
-     * Get all existing workflow schedules and optionally filter by workflow name
-     * @param workflowName
-     * @returns WorkflowSchedule OK
-     * @throws ApiError
-     */
-    getAllSchedules(workflowName?: string): CancelablePromise<Array<WorkflowSchedule>>;
-    /**
-     * Create or update a schedule for a specified workflow with a corresponding start workflow request
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    saveSchedule(requestBody: SaveScheduleRequest): CancelablePromise<any>;
-    /**
-     * Test timeout - do not use in production
-     * @returns any OK
-     * @throws ApiError
-     */
-    testTimeout(): CancelablePromise<any>;
-    /**
-     * Search for workflows based on payload and other parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultWorkflowScheduleExecutionModel OK
-     * @throws ApiError
-     */
-    searchV21(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflowScheduleExecutionModel>;
-}
-declare type ExternalStorageLocation = {
-    uri?: string;
-    path?: string;
+    synthetic?: boolean;
 };
-declare type PollData = {
-    queueName?: string;
+type OneofDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: OneofDescriptorProto;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: OneofOptions;
+    optionsOrBuilder?: OneofOptionsOrBuilder;
+    parserForType?: ParserOneofDescriptorProto;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type OneofDescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: OneofOptions;
+    optionsOrBuilder?: OneofOptionsOrBuilder;
+    unknownFields?: UnknownFieldSet;
+};
+type OneofOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: OneofOptions;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserOneofOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type OneofOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type OrkesCircuitBreakerConfig = {
+    automaticTransitionFromOpenToHalfOpenEnabled?: boolean;
+    failureRateThreshold?: number;
+    maxWaitDurationInHalfOpenState?: number;
+    minimumNumberOfCalls?: number;
+    permittedNumberOfCallsInHalfOpenState?: number;
+    slidingWindowSize?: number;
+    slowCallDurationThreshold?: number;
+    slowCallRateThreshold?: number;
+    waitDurationInOpenState?: number;
+};
+type Parser = {
+    [key: string]: unknown;
+};
+type ParserAny = {
+    [key: string]: unknown;
+};
+type ParserDeclaration = {
+    [key: string]: unknown;
+};
+type ParserDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserEditionDefault = {
+    [key: string]: unknown;
+};
+type ParserEnumDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserEnumOptions = {
+    [key: string]: unknown;
+};
+type ParserEnumReservedRange = {
+    [key: string]: unknown;
+};
+type ParserEnumValueDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserEnumValueOptions = {
+    [key: string]: unknown;
+};
+type ParserExtensionRange = {
+    [key: string]: unknown;
+};
+type ParserExtensionRangeOptions = {
+    [key: string]: unknown;
+};
+type ParserFeatureSet = {
+    [key: string]: unknown;
+};
+type ParserFieldDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserFieldOptions = {
+    [key: string]: unknown;
+};
+type ParserFileDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserFileOptions = {
+    [key: string]: unknown;
+};
+type ParserLocation = {
+    [key: string]: unknown;
+};
+type ParserMessage = {
+    [key: string]: unknown;
+};
+type ParserMessageLite = {
+    [key: string]: unknown;
+};
+type ParserMessageOptions = {
+    [key: string]: unknown;
+};
+type ParserMethodDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserMethodOptions = {
+    [key: string]: unknown;
+};
+type ParserNamePart = {
+    [key: string]: unknown;
+};
+type ParserOneofDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserOneofOptions = {
+    [key: string]: unknown;
+};
+type ParserReservedRange = {
+    [key: string]: unknown;
+};
+type ParserServiceDescriptorProto = {
+    [key: string]: unknown;
+};
+type ParserServiceOptions = {
+    [key: string]: unknown;
+};
+type ParserSourceCodeInfo = {
+    [key: string]: unknown;
+};
+type ParserUninterpretedOption = {
+    [key: string]: unknown;
+};
+type PollData = {
     domain?: string;
-    workerId?: string;
     lastPollTime?: number;
+    queueName?: string;
+    workerId?: string;
 };
-declare type Task = {
-    taskType?: string;
-    status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
-    inputData?: Record<string, any>;
-    referenceTaskName?: string;
-    retryCount?: number;
-    seq?: number;
+type ProtoRegistryEntry = {
+    data?: string;
+    filename?: string;
+    serviceName?: string;
+};
+type RateLimitConfig = {
+    concurrentExecLimit?: number;
+    rateLimitKey?: string;
+};
+type RequestParam = {
+    name?: string;
+    required?: boolean;
+    schema?: Schema;
+    type?: string;
+};
+type RerunWorkflowRequest = {
     correlationId?: string;
-    pollCount?: number;
-    taskDefName?: string;
-    scheduledTime?: number;
-    startTime?: number;
-    endTime?: number;
+    reRunFromTaskId?: string;
+    reRunFromWorkflowId?: string;
+    taskInput?: {
+        [key: string]: unknown;
+    };
+    workflowInput?: {
+        [key: string]: unknown;
+    };
+};
+type ReservedRange = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: ReservedRange;
+    descriptorForType?: Descriptor;
+    end?: number;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserReservedRange;
+    serializedSize?: number;
+    start?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type ReservedRangeOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    end?: number;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    start?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type Response$1 = {
+    [key: string]: unknown;
+};
+type SaveScheduleRequest = {
+    createdBy?: string;
+    cronExpression: string;
+    description?: string;
+    name: string;
+    paused?: boolean;
+    runCatchupScheduleInstances?: boolean;
+    scheduleEndTime?: number;
+    scheduleStartTime?: number;
+    startWorkflowRequest: StartWorkflowRequest;
+    updatedBy?: string;
+    zoneId?: string;
+};
+type Schema = {
+    defaultValue?: {
+        [key: string]: unknown;
+    };
+    format?: string;
+    type?: string;
+};
+type SchemaDef = {
+    createTime?: number;
+    createdBy?: string;
+    data?: {
+        [key: string]: unknown;
+    };
+    externalRef?: string;
+    name: string;
+    ownerApp?: string;
+    type: 'JSON' | 'AVRO' | 'PROTOBUF';
     updateTime?: number;
-    startDelayInSeconds?: number;
-    retriedTaskId?: string;
-    retried?: boolean;
-    executed?: boolean;
-    callbackFromWorker?: boolean;
-    responseTimeoutSeconds?: number;
-    workflowInstanceId?: string;
-    workflowType?: string;
-    taskId?: string;
-    reasonForIncompletion?: string;
-    callbackAfterSeconds?: number;
-    workerId?: string;
-    outputData?: Record<string, any>;
-    workflowTask?: WorkflowTask;
-    domain?: string;
-    rateLimitPerFrequency?: number;
-    rateLimitFrequencyInSeconds?: number;
-    externalInputPayloadStoragePath?: string;
-    externalOutputPayloadStoragePath?: string;
-    workflowPriority?: number;
-    executionNameSpace?: string;
-    isolationGroupId?: string;
-    iteration?: number;
-    subWorkflowId?: string;
-    subworkflowChanged?: boolean;
-    queueWaitTime?: number;
-    taskDefinition?: TaskDef;
-    loopOverTask?: boolean;
+    updatedBy?: string;
+    version: number;
 };
-declare type SearchResultTask = {
+type ScrollableSearchResultWorkflowSummary = {
+    queryId?: string;
+    results?: Array<WorkflowSummary>;
     totalHits?: number;
-    results?: Array<Task>;
 };
-declare type TaskSummary = {
-    workflowId?: string;
-    workflowType?: string;
-    correlationId?: string;
-    scheduledTime?: string;
-    startTime?: string;
-    updateTime?: string;
-    endTime?: string;
-    status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
-    reasonForIncompletion?: string;
-    executionTime?: number;
-    queueWaitTime?: number;
-    taskDefName?: string;
-    taskType?: string;
-    input?: string;
-    output?: string;
-    taskId?: string;
-    externalInputPayloadStoragePath?: string;
-    externalOutputPayloadStoragePath?: string;
-    workflowPriority?: number;
+type SearchResultTaskSummary = {
+    results?: Array<TaskSummary>;
+    totalHits?: number;
 };
-declare type SearchResultTaskSummary = {
+type SearchResultWorkflowScheduleExecutionModel = {
+    results?: Array<WorkflowScheduleExecutionModel>;
     totalHits?: number;
-    results?: Array<TaskSummary>;
 };
-declare type TaskExecLog = {
-    log?: string;
-    taskId?: string;
-    createdTime?: number;
+type ServiceDescriptor = {
+    file?: FileDescriptor;
+    fullName?: string;
+    index?: number;
+    methods?: Array<MethodDescriptor>;
+    name?: string;
+    options?: ServiceOptions;
+    proto?: ServiceDescriptorProto;
 };
-declare type TaskResult = {
-    workflowInstanceId: string;
-    taskId: string;
-    reasonForIncompletion?: string;
-    callbackAfterSeconds?: number;
-    workerId?: string;
-    status?: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED';
-    outputData?: Record<string, any>;
-    logs?: Array<TaskExecLog>;
-    externalOutputPayloadStoragePath?: string;
-    subWorkflowId?: string;
+type ServiceDescriptorProto = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: ServiceDescriptorProto;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    methodCount?: number;
+    methodList?: Array<MethodDescriptorProto>;
+    methodOrBuilderList?: Array<MethodDescriptorProtoOrBuilder>;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: ServiceOptions;
+    optionsOrBuilder?: ServiceOptionsOrBuilder;
+    parserForType?: ParserServiceDescriptorProto;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
 };
-declare class TaskResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Poll for a task of a certain type
-     * @param tasktype
-     * @param workerid
-     * @param domain
-     * @returns Task OK
-     * @throws ApiError
-     */
-    poll(tasktype: string, workerid?: string, domain?: string): CancelablePromise<Task>;
-    /**
-     * Get the details about each queue
-     * @returns number OK
-     * @throws ApiError
-     */
-    allVerbose(): CancelablePromise<Record<string, Record<string, Record<string, number>>>>;
-    /**
-     * Update a task By Ref Name
-     * @param workflowId
-     * @param taskRefName
-     * @param status
-     * @param requestBody
-     * @returns string OK
-     * @throws ApiError
-     */
-    updateTask(workflowId: string, taskRefName: string, status: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED', requestBody: Record<string, any>): CancelablePromise<string>;
-    /**
-     * Get task by Id
-     * @param taskId
-     * @returns Task OK
-     * @throws ApiError
-     */
-    getTask(taskId: string): CancelablePromise<Task>;
-    /**
-     * Get the details about each queue
-     * @returns number OK
-     * @throws ApiError
-     */
-    all(): CancelablePromise<Record<string, number>>;
-    /**
-     * Requeue pending tasks
-     * @param taskType
-     * @returns string OK
-     * @throws ApiError
-     */
-    requeuePendingTask(taskType: string): CancelablePromise<string>;
-    /**
-     * Search for tasks based in payload and other parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultTaskSummary OK
-     * @throws ApiError
-     */
-    search(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultTaskSummary>;
-    /**
-     * Search for tasks based in payload and other parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultTask OK
-     * @throws ApiError
-     */
-    searchV22(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultTask>;
-    /**
-     * Get the last poll data for a given task type
-     * @param taskType
-     * @returns PollData OK
-     * @throws ApiError
-     */
-    getPollData(taskType: string): CancelablePromise<Array<PollData>>;
-    /**
-     * Get Task Execution Logs
-     * @param taskId
-     * @returns TaskExecLog OK
-     * @throws ApiError
-     */
-    getTaskLogs(taskId: string): CancelablePromise<Array<TaskExecLog>>;
-    /**
-     * Log Task Execution Details
-     * @param taskId
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    log(taskId: string, requestBody: string): CancelablePromise<any>;
-    /**
-     * Get the last poll data for all task types
-     * @returns PollData OK
-     * @throws ApiError
-     */
-    getAllPollData(): CancelablePromise<Array<PollData>>;
-    /**
-     * Batch poll for a task of a certain type
-     * @param tasktype
-     * @param workerid
-     * @param domain
-     * @param count
-     * @param timeout
-     * @returns Task OK
-     * @throws ApiError
-     */
-    batchPoll(tasktype: string, workerid?: string, domain?: string, count?: number, timeout?: number): CancelablePromise<Array<Task>>;
-    /**
-     * Update a task
-     * @param requestBody
-     * @returns string OK
-     * @throws ApiError
-     */
-    updateTask1(requestBody: TaskResult): CancelablePromise<string>;
-    /**
-     * Get Task type queue sizes
-     * @param taskType
-     * @returns number OK
-     * @throws ApiError
-     */
-    size1(taskType?: Array<string>): CancelablePromise<Record<string, number>>;
-    /**
-     * Get the external uri where the task payload is to be stored
-     * @param path
-     * @param operation
-     * @param payloadType
-     * @returns ExternalStorageLocation OK
-     * @throws ApiError
-     */
-    getExternalStorageLocation1(path: string, operation: string, payloadType: string): CancelablePromise<ExternalStorageLocation>;
-}
-declare type GenerateTokenRequest = {
-    keyId: string;
-    keySecret: string;
-    refreshTokenInterval?: number;
+type ServiceDescriptorProtoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    methodCount?: number;
+    methodList?: Array<MethodDescriptorProto>;
+    methodOrBuilderList?: Array<MethodDescriptorProtoOrBuilder>;
+    name?: string;
+    nameBytes?: ByteString;
+    options?: ServiceOptions;
+    optionsOrBuilder?: ServiceOptionsOrBuilder;
+    unknownFields?: UnknownFieldSet;
 };
-declare type Response$1 = {};
-declare class TokenResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Generate JWT with the given access key
-     * @param requestBody
-     * @returns Response OK
-     * @throws ApiError
-     */
-    generateToken(requestBody: GenerateTokenRequest): CancelablePromise<Response$1>;
-    /**
-     * Get the user info from the token
-     * @returns any OK
-     * @throws ApiError
-     */
-    getUserInfo(): CancelablePromise<any>;
-}
-declare type BulkResponse = {
-    bulkErrorResults?: Record<string, string>;
-    bulkSuccessfulResults?: Array<string>;
+type ServiceMethod = {
+    exampleInput?: {
+        [key: string]: unknown;
+    };
+    id?: number;
+    inputType?: string;
+    methodName?: string;
+    methodType?: string;
+    operationName?: string;
+    outputType?: string;
+    requestParams?: Array<RequestParam>;
 };
-declare class WorkflowBulkResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Retry the last failed task for each workflow from the list
-     * @param requestBody
-     * @returns BulkResponse OK
-     * @throws ApiError
-     */
-    retry(requestBody: Array<string>): CancelablePromise<BulkResponse>;
-    /**
-     * Restart the list of completed workflow
-     * @param requestBody
-     * @param useLatestDefinitions
-     * @returns BulkResponse OK
-     * @throws ApiError
-     */
-    restart(requestBody: Array<string>, useLatestDefinitions?: boolean): CancelablePromise<BulkResponse>;
-    /**
-     * Terminate workflows execution
-     * @param requestBody
-     * @param reason
-     * @returns BulkResponse OK
-     * @throws ApiError
-     */
-    terminate(requestBody: Array<string>, reason?: string): CancelablePromise<BulkResponse>;
-    /**
-     * Resume the list of workflows
-     * @param requestBody
-     * @returns BulkResponse OK
-     * @throws ApiError
-     */
-    resumeWorkflow(requestBody: Array<string>): CancelablePromise<BulkResponse>;
+type ServiceOptions = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    allFieldsRaw?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: ServiceOptions;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    parserForType?: ParserServiceOptions;
+    serializedSize?: number;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type ServiceOptionsOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    deprecated?: boolean;
+    descriptorForType?: Descriptor;
+    features?: FeatureSet;
+    featuresOrBuilder?: FeatureSetOrBuilder;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    uninterpretedOptionCount?: number;
+    uninterpretedOptionList?: Array<UninterpretedOption>;
+    uninterpretedOptionOrBuilderList?: Array<UninterpretedOptionOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type ServiceRegistry = {
+    circuitBreakerEnabled?: boolean;
+    config?: Config$2;
+    methods?: Array<ServiceMethod>;
+    name?: string;
+    requestParams?: Array<RequestParam>;
+    serviceURI?: string;
+    type?: 'HTTP' | 'gRPC' | 'MCP_REMOTE';
+};
+type SignalResponse$1 = {
+    correlationId?: string;
+    input?: {
+        [key: string]: unknown;
+    };
+    output?: {
+        [key: string]: unknown;
+    };
+    requestId?: string;
+    responseType?: 'TARGET_WORKFLOW' | 'BLOCKING_WORKFLOW' | 'BLOCKING_TASK' | 'BLOCKING_TASK_INPUT';
+    targetWorkflowId?: string;
+    targetWorkflowStatus?: string;
+    workflowId?: string;
+};
+type SkipTaskRequest = {
+    taskInput?: {
+        [key: string]: unknown;
+    };
+    taskOutput?: {
+        [key: string]: unknown;
+    };
+};
+type SourceCodeInfo = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: SourceCodeInfo;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    locationCount?: number;
+    locationList?: Array<Location>;
+    locationOrBuilderList?: Array<LocationOrBuilder>;
+    parserForType?: ParserSourceCodeInfo;
+    serializedSize?: number;
+    unknownFields?: UnknownFieldSet;
+};
+type SourceCodeInfoOrBuilder = {
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    locationCount?: number;
+    locationList?: Array<Location>;
+    locationOrBuilderList?: Array<LocationOrBuilder>;
+    unknownFields?: UnknownFieldSet;
+};
+type StartWorkflowRequest = {
+    correlationId?: string;
+    createdBy?: string;
+    externalInputPayloadStoragePath?: string;
+    idempotencyKey?: string;
+    idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING' | 'FAIL_ON_RUNNING';
+    input?: {
+        [key: string]: unknown;
+    };
+    name: string;
+    priority?: number;
+    taskToDomain?: {
+        [key: string]: string;
+    };
+    version?: number;
+    workflowDef?: WorkflowDef$1;
+};
+type StateChangeEvent = {
+    payload?: {
+        [key: string]: unknown;
+    };
+    type: string;
+};
+type SubWorkflowParams = {
+    idempotencyKey?: string;
+    idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING' | 'FAIL_ON_RUNNING';
+    name?: string;
+    priority?: {
+        [key: string]: unknown;
+    };
+    taskToDomain?: {
+        [key: string]: string;
+    };
+    version?: number;
+    workflowDefinition?: {
+        [key: string]: unknown;
+    };
+};
+type Tag = {
+    key?: string;
     /**
-     * Pause the list of workflows
-     * @param requestBody
-     * @returns BulkResponse OK
-     * @throws ApiError
+     * @deprecated
      */
-    pauseWorkflow1(requestBody: Array<string>): CancelablePromise<BulkResponse>;
-}
-declare type RerunWorkflowRequest = {
-    reRunFromWorkflowId?: string;
-    workflowInput?: Record<string, any>;
-    reRunFromTaskId?: string;
-    taskInput?: Record<string, any>;
+    type?: string;
+    value?: string;
+};
+type Task = {
+    callbackAfterSeconds?: number;
+    callbackFromWorker?: boolean;
     correlationId?: string;
+    domain?: string;
+    endTime?: number;
+    executed?: boolean;
+    executionNameSpace?: string;
+    externalInputPayloadStoragePath?: string;
+    externalOutputPayloadStoragePath?: string;
+    firstStartTime?: number;
+    inputData?: {
+        [key: string]: unknown;
+    };
+    isolationGroupId?: string;
+    iteration?: number;
+    loopOverTask?: boolean;
+    outputData?: {
+        [key: string]: unknown;
+    };
+    parentTaskId?: string;
+    pollCount?: number;
+    queueWaitTime?: number;
+    rateLimitFrequencyInSeconds?: number;
+    rateLimitPerFrequency?: number;
+    reasonForIncompletion?: string;
+    referenceTaskName?: string;
+    responseTimeoutSeconds?: number;
+    retried?: boolean;
+    retriedTaskId?: string;
+    retryCount?: number;
+    scheduledTime?: number;
+    seq?: number;
+    startDelayInSeconds?: number;
+    startTime?: number;
+    status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
+    subWorkflowId?: string;
+    subworkflowChanged?: boolean;
+    taskDefName?: string;
+    taskDefinition?: TaskDef;
+    taskId?: string;
+    taskType?: string;
+    updateTime?: number;
+    workerId?: string;
+    workflowInstanceId?: string;
+    workflowPriority?: number;
+    workflowTask?: WorkflowTask;
+    workflowType?: string;
+};
+type TaskDef = {
+    backoffScaleFactor?: number;
+    baseType?: string;
+    concurrentExecLimit?: number;
+    createTime?: number;
+    createdBy?: string;
+    description?: string;
+    enforceSchema?: boolean;
+    executionNameSpace?: string;
+    inputKeys?: Array<string>;
+    inputSchema?: SchemaDef;
+    inputTemplate?: {
+        [key: string]: unknown;
+    };
+    isolationGroupId?: string;
+    name: string;
+    outputKeys?: Array<string>;
+    outputSchema?: SchemaDef;
+    ownerApp?: string;
+    ownerEmail?: string;
+    pollTimeoutSeconds?: number;
+    rateLimitFrequencyInSeconds?: number;
+    rateLimitPerFrequency?: number;
+    responseTimeoutSeconds?: number;
+    retryCount?: number;
+    retryDelaySeconds?: number;
+    retryLogic?: 'FIXED' | 'EXPONENTIAL_BACKOFF' | 'LINEAR_BACKOFF';
+    timeoutPolicy?: 'RETRY' | 'TIME_OUT_WF' | 'ALERT_ONLY';
+    timeoutSeconds: number;
+    totalTimeoutSeconds: number;
+    updateTime?: number;
+    updatedBy?: string;
 };
-declare type WorkflowSummary = {
-    workflowType?: string;
-    version?: number;
+type TaskDetails = {
+    output?: {
+        [key: string]: unknown;
+    };
+    outputMessage?: Any;
+    taskId?: string;
+    taskRefName?: string;
     workflowId?: string;
+};
+type TaskExecLog = {
+    createdTime?: number;
+    log?: string;
+    taskId?: string;
+};
+type TaskListSearchResultSummary = {
+    results?: Array<Task>;
+    summary?: {
+        [key: string]: number;
+    };
+    totalHits?: number;
+};
+type TaskResult = {
+    callbackAfterSeconds?: number;
+    extendLease?: boolean;
+    externalOutputPayloadStoragePath?: string;
+    logs?: Array<TaskExecLog>;
+    outputData?: {
+        [key: string]: unknown;
+    };
+    reasonForIncompletion?: string;
+    status?: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED';
+    subWorkflowId?: string;
+    taskId: string;
+    workerId?: string;
+    workflowInstanceId: string;
+};
+type TaskSummary = {
     correlationId?: string;
-    startTime?: string;
-    updateTime?: string;
     endTime?: string;
-    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
-    input?: string;
-    output?: string;
-    reasonForIncompletion?: string;
     executionTime?: number;
-    event?: string;
-    failedReferenceTaskNames?: string;
     externalInputPayloadStoragePath?: string;
     externalOutputPayloadStoragePath?: string;
-    priority?: number;
-    createdBy?: string;
-    outputSize?: number;
-    inputSize?: number;
+    input?: string;
+    output?: string;
+    queueWaitTime?: number;
+    reasonForIncompletion?: string;
+    scheduledTime?: string;
+    startTime?: string;
+    status?: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
+    taskDefName?: string;
+    taskId?: string;
+    taskReferenceName?: string;
+    taskType?: string;
+    updateTime?: string;
+    workflowId?: string;
+    workflowPriority?: number;
+    workflowType?: string;
 };
-declare type ScrollableSearchResultWorkflowSummary = {
-    results?: Array<WorkflowSummary>;
-    totalHits?: number;
+type TerminateWorkflow = {
+    terminationReason?: string;
+    workflowId?: string;
 };
-declare type Workflow = {
-    ownerApp?: string;
+type UninterpretedOption = {
+    aggregateValue?: string;
+    aggregateValueBytes?: ByteString;
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: UninterpretedOption;
+    descriptorForType?: Descriptor;
+    doubleValue?: number;
+    identifierValue?: string;
+    identifierValueBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    nameCount?: number;
+    nameList?: Array<NamePart>;
+    nameOrBuilderList?: Array<NamePartOrBuilder>;
+    negativeIntValue?: number;
+    parserForType?: ParserUninterpretedOption;
+    positiveIntValue?: number;
+    serializedSize?: number;
+    stringValue?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type UninterpretedOptionOrBuilder = {
+    aggregateValue?: string;
+    aggregateValueBytes?: ByteString;
+    allFields?: {
+        [key: string]: unknown;
+    };
+    defaultInstanceForType?: Message;
+    descriptorForType?: Descriptor;
+    doubleValue?: number;
+    identifierValue?: string;
+    identifierValueBytes?: ByteString;
+    initializationErrorString?: string;
+    initialized?: boolean;
+    nameCount?: number;
+    nameList?: Array<NamePart>;
+    nameOrBuilderList?: Array<NamePartOrBuilder>;
+    negativeIntValue?: number;
+    positiveIntValue?: number;
+    stringValue?: ByteString;
+    unknownFields?: UnknownFieldSet;
+};
+type UnknownFieldSet = {
+    defaultInstanceForType?: UnknownFieldSet;
+    initialized?: boolean;
+    parserForType?: Parser;
+    serializedSize?: number;
+    serializedSizeAsMessageSet?: number;
+};
+type UpdateWorkflowVariables = {
+    appendArray?: boolean;
+    variables?: {
+        [key: string]: unknown;
+    };
+    workflowId?: string;
+};
+type UserFormTemplate = {
+    name?: string;
+    version?: number;
+};
+type Workflow = {
+    correlationId?: string;
     createTime?: number;
-    updateTime?: number;
     createdBy?: string;
-    updatedBy?: string;
-    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
-    idempotencyKey?: string;
     endTime?: number;
-    workflowId?: string;
-    parentWorkflowId?: string;
-    parentWorkflowTaskId?: string;
-    tasks?: Array<Task>;
-    input?: Record<string, any>;
-    output?: Record<string, any>;
-    correlationId?: string;
-    reRunFromWorkflowId?: string;
-    reasonForIncompletion?: string;
     event?: string;
-    taskToDomain?: Record<string, string>;
-    failedReferenceTaskNames?: Array<string>;
-    workflowDefinition?: WorkflowDef$1;
     externalInputPayloadStoragePath?: string;
     externalOutputPayloadStoragePath?: string;
-    priority?: number;
-    variables?: Record<string, any>;
+    failedReferenceTaskNames?: Array<string>;
+    failedTaskNames?: Array<string>;
+    history?: Array<Workflow>;
+    idempotencyKey?: string;
+    input?: {
+        [key: string]: unknown;
+    };
     lastRetriedTime?: number;
+    output?: {
+        [key: string]: unknown;
+    };
+    ownerApp?: string;
+    parentWorkflowId?: string;
+    parentWorkflowTaskId?: string;
+    priority?: number;
+    rateLimitKey?: string;
+    rateLimited?: boolean;
+    reRunFromWorkflowId?: string;
+    reasonForIncompletion?: string;
     startTime?: number;
-    workflowVersion?: number;
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    taskToDomain?: {
+        [key: string]: string;
+    };
+    tasks?: Array<Task>;
+    updateTime?: number;
+    updatedBy?: string;
+    variables?: {
+        [key: string]: unknown;
+    };
+    workflowDefinition?: WorkflowDef$1;
+    workflowId?: string;
     workflowName?: string;
+    workflowVersion?: number;
 };
-declare type SearchResultWorkflow = {
-    totalHits?: number;
-    results?: Array<Workflow>;
-};
-declare type SearchResultWorkflowSummary = {
-    totalHits?: number;
-    results?: Array<WorkflowSummary>;
-};
-declare type SkipTaskRequest = {
-    taskInput?: Record<string, any>;
-    taskOutput?: Record<string, any>;
+type WorkflowDef$1 = {
+    cacheConfig?: CacheConfig;
+    createTime?: number;
+    createdBy?: string;
+    description?: string;
+    enforceSchema?: boolean;
+    failureWorkflow?: string;
+    inputParameters?: Array<string>;
+    inputSchema?: SchemaDef;
+    inputTemplate?: {
+        [key: string]: unknown;
+    };
+    maskedFields?: Array<string>;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    name: string;
+    outputParameters?: {
+        [key: string]: unknown;
+    };
+    outputSchema?: SchemaDef;
+    ownerApp?: string;
+    ownerEmail?: string;
+    rateLimitConfig?: RateLimitConfig;
+    restartable?: boolean;
+    schemaVersion?: number;
+    tasks: Array<WorkflowTask>;
+    timeoutPolicy?: 'TIME_OUT_WF' | 'ALERT_ONLY';
+    timeoutSeconds: number;
+    updateTime?: number;
+    updatedBy?: string;
+    variables?: {
+        [key: string]: unknown;
+    };
+    version?: number;
+    workflowStatusListenerEnabled?: boolean;
+    workflowStatusListenerSink?: string;
 };
-declare type WorkflowRun = {
+type WorkflowRun = {
     correlationId?: string;
     createTime?: number;
     createdBy?: string;
+    input?: {
+        [key: string]: unknown;
+    };
+    output?: {
+        [key: string]: unknown;
+    };
     priority?: number;
     requestId?: string;
-    status?: string;
+    responseType?: 'TARGET_WORKFLOW' | 'BLOCKING_WORKFLOW' | 'BLOCKING_TASK' | 'BLOCKING_TASK_INPUT';
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    targetWorkflowId?: string;
+    targetWorkflowStatus?: string;
     tasks?: Array<Task>;
     updateTime?: number;
+    variables?: {
+        [key: string]: unknown;
+    };
     workflowId?: string;
-    variables?: Record<string, object>;
-    input?: Record<string, object>;
-    output?: Record<string, object>;
 };
-declare type WorkflowStatus = {
-    workflowId?: string;
-    correlationId?: string;
-    output?: Record<string, any>;
-    variables?: Record<string, any>;
-    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+type WorkflowSchedule = {
+    createTime?: number;
+    createdBy?: string;
+    cronExpression?: string;
+    description?: string;
+    name?: string;
+    paused?: boolean;
+    pausedReason?: string;
+    runCatchupScheduleInstances?: boolean;
+    scheduleEndTime?: number;
+    scheduleStartTime?: number;
+    startWorkflowRequest?: StartWorkflowRequest;
+    tags?: Array<Tag>;
+    updatedBy?: string;
+    updatedTime?: number;
+    zoneId?: string;
 };
-declare type TaskMock = {
+type WorkflowScheduleExecutionModel = {
+    executionId?: string;
     executionTime?: number;
-    output: Record<string, any>;
-    queueWaitTime?: number;
-    status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED";
+    orgId?: string;
+    queueMsgId?: string;
+    reason?: string;
+    scheduleName?: string;
+    scheduledTime?: number;
+    stackTrace?: string;
+    startWorkflowRequest?: StartWorkflowRequest;
+    state?: 'POLLED' | 'FAILED' | 'EXECUTED';
+    workflowId?: string;
+    workflowName?: string;
+    zoneId?: string;
 };
-declare type WorkflowTestRequest = {
-    correlationId?: string;
+type WorkflowScheduleModel = {
+    createTime?: number;
     createdBy?: string;
-    externalInputPayloadStoragePath?: string;
-    idempotencyKey?: string;
-    idempotencyStrategy?: "FAIL" | "RETURN_EXISTING";
-    input?: Record<string, Record<string, any>>;
-    name: string;
-    priority?: number;
-    subWorkflowTestRequest?: Record<string, WorkflowTestRequest>;
-    taskRefToMockOutput?: Record<string, Array<TaskMock>>;
-    taskToDomain?: Record<string, string>;
-    version?: number;
-    workflowDef?: WorkflowDef$1;
-};
-declare class WorkflowResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * Retrieve all the running workflows
-     * @param name
-     * @param version
-     * @param startTime
-     * @param endTime
-     * @returns string OK
-     * @throws ApiError
-     */
-    getRunningWorkflow(name: string, version?: number, startTime?: number, endTime?: number): CancelablePromise<Array<string>>;
-    /**
-     * Execute a workflow synchronously
-     * @param body
-     * @param name
-     * @param version
-     * @param requestId
-     * @param waitUntilTaskRef
-     * @param callback
-     * @returns workflowRun
-     * @throws ApiError
-     */
-    executeWorkflow(body: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string): CancelablePromise<WorkflowRun>;
-    /**
-     * Start a new workflow with StartWorkflowRequest, which allows task to be executed in a domain
-     * @param requestBody
-     * @returns string OK
-     * @throws ApiError
-     */
-    startWorkflow(requestBody: StartWorkflowRequest): CancelablePromise<string>;
-    /**
-     * Starts the decision task for a workflow
-     * @param workflowId
-     * @returns any OK
-     * @throws ApiError
-     */
-    decide(workflowId: string): CancelablePromise<any>;
-    /**
-     * Reruns the workflow from a specific task
-     * @param workflowId
-     * @param requestBody
-     * @returns string OK
-     * @throws ApiError
-     */
-    rerun(workflowId: string, requestBody: RerunWorkflowRequest): CancelablePromise<string>;
-    /**
-     * Search for workflows based on payload and other parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultWorkflow OK
-     * @throws ApiError
-     */
-    searchV21(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflow>;
-    /**
-     * Pauses the workflow
-     * @param workflowId
-     * @returns any OK
-     * @throws ApiError
-     */
-    pauseWorkflow(workflowId: string): CancelablePromise<any>;
-    /**
-     * Skips a given task from a current running workflow
-     * @param workflowId
-     * @param taskReferenceName
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    skipTaskFromWorkflow(workflowId: string, taskReferenceName: string, requestBody?: SkipTaskRequest): CancelablePromise<any>;
-    /**
-     * Lists workflows for the given correlation id list
-     * @param name
-     * @param requestBody
-     * @param includeClosed
-     * @param includeTasks
-     * @returns Workflow OK
-     * @throws ApiError
-     */
-    getWorkflows(name: string, requestBody: Array<string>, includeClosed?: boolean, includeTasks?: boolean): CancelablePromise<Record<string, Array<Workflow>>>;
-    /**
-     * Gets the workflow by workflow id
-     * @param workflowId
-     * @param includeOutput
-     * @param includeVariables
-     * @returns WorkflowStatus OK
-     * @throws ApiError
-     */
-    getWorkflowStatusSummary(workflowId: string, includeOutput?: boolean, includeVariables?: boolean): CancelablePromise<WorkflowStatus>;
+    cronExpression?: string;
+    description?: string;
+    name?: string;
+    orgId?: string;
+    paused?: boolean;
+    pausedReason?: string;
+    queueMsgId?: string;
+    runCatchupScheduleInstances?: boolean;
+    scheduleEndTime?: number;
+    scheduleStartTime?: number;
+    startWorkflowRequest?: StartWorkflowRequest;
+    tags?: Array<Tag>;
+    updatedBy?: string;
+    updatedTime?: number;
+    zoneId?: string;
+};
+type WorkflowStatus = {
+    correlationId?: string;
+    output?: {
+        [key: string]: unknown;
+    };
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    variables?: {
+        [key: string]: unknown;
+    };
+    workflowId?: string;
+};
+type WorkflowSummary = {
+    correlationId?: string;
+    createdBy?: string;
+    endTime?: string;
+    event?: string;
+    executionTime?: number;
+    externalInputPayloadStoragePath?: string;
+    externalOutputPayloadStoragePath?: string;
+    failedReferenceTaskNames?: string;
+    failedTaskNames?: Array<string>;
+    idempotencyKey?: string;
+    input?: string;
+    inputSize?: number;
+    output?: string;
+    outputSize?: number;
+    priority?: number;
+    reasonForIncompletion?: string;
+    startTime?: string;
+    status?: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    taskToDomain?: {
+        [key: string]: string;
+    };
+    updateTime?: string;
+    version?: number;
+    workflowId?: string;
+    workflowType?: string;
+};
+type WorkflowTask = {
+    asyncComplete?: boolean;
+    cacheConfig?: CacheConfig;
     /**
-     * Lists workflows for the given correlation id
-     * @param name
-     * @param correlationId
-     * @param includeClosed
-     * @param includeTasks
-     * @returns Workflow OK
-     * @throws ApiError
+     * @deprecated
      */
-    getWorkflows1(name: string, correlationId: string, includeClosed?: boolean, includeTasks?: boolean): CancelablePromise<Array<Workflow>>;
+    caseExpression?: string;
     /**
-     * Retries the last failed task
-     * @param workflowId
-     * @param resumeSubworkflowTasks
-     * @returns void
-     * @throws ApiError
+     * @deprecated
      */
-    retry1(workflowId: string, resumeSubworkflowTasks?: boolean): CancelablePromise<void>;
+    caseValueParam?: string;
+    decisionCases?: {
+        [key: string]: Array<WorkflowTask>;
+    };
+    defaultCase?: Array<WorkflowTask>;
+    defaultExclusiveJoinTask?: Array<string>;
+    description?: string;
     /**
-     * Gets the workflow by workflow id
-     * @param workflowId
-     * @param includeTasks
-     * @returns Workflow OK
-     * @throws ApiError
+     * @deprecated
      */
-    getExecutionStatus(workflowId: string, includeTasks?: boolean): CancelablePromise<Workflow>;
+    dynamicForkJoinTasksParam?: string;
+    dynamicForkTasksInputParamName?: string;
+    dynamicForkTasksParam?: string;
+    dynamicTaskNameParam?: string;
+    evaluatorType?: string;
+    expression?: string;
+    forkTasks?: Array<Array<WorkflowTask>>;
+    inputParameters?: {
+        [key: string]: unknown;
+    };
+    joinOn?: Array<string>;
+    joinStatus?: string;
+    loopCondition?: string;
+    loopOver?: Array<WorkflowTask>;
+    name: string;
+    onStateChange?: {
+        [key: string]: Array<StateChangeEvent>;
+    };
+    optional?: boolean;
+    permissive?: boolean;
+    rateLimited?: boolean;
+    retryCount?: number;
+    scriptExpression?: string;
+    sink?: string;
+    startDelay?: number;
+    subWorkflowParam?: SubWorkflowParams;
+    taskDefinition?: TaskDef;
+    taskReferenceName: string;
+    type?: string;
+};
+type AuthToken = string | undefined;
+interface Auth {
     /**
-     * Terminate workflow execution
-     * @param workflowId
-     * @param reason
-     * @returns any OK
-     * @throws ApiError
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
      */
-    terminate1(workflowId: string, reason?: string): CancelablePromise<any>;
+    in?: 'header' | 'query' | 'cookie';
     /**
-     * Resumes the workflow
-     * @param workflowId
-     * @returns any OK
-     * @throws ApiError
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
      */
-    resumeWorkflow(workflowId: string): CancelablePromise<any>;
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+interface SerializerOptions<T> {
     /**
-     * Removes the workflow from the system
-     * @param workflowId
-     * @param archiveWorkflow
-     * @returns any OK
-     * @throws ApiError
+     * @default true
      */
-    delete(workflowId: string, archiveWorkflow?: boolean): CancelablePromise<any>;
+    explode: boolean;
+    style: T;
+}
+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 {
     /**
-     * Search for workflows based on task parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultWorkflowSummary OK
-     * @throws ApiError
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
      */
-    searchWorkflowsByTasks(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflowSummary>;
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
     /**
-     * Get the uri and path of the external storage where the workflow payload is to be stored
-     * @param path
-     * @param operation
-     * @param payloadType
-     * @returns ExternalStorageLocation OK
-     * @throws ApiError
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
      */
-    getExternalStorageLocation(path: string, operation: string, payloadType: string): CancelablePromise<ExternalStorageLocation>;
+    bodySerializer?: BodySerializer | null;
     /**
-     * Start a new workflow. Returns the ID of the workflow instance that can be later used for tracking
-     * @param name
-     * @param requestBody
-     * @param version
-     * @param correlationId
-     * @param priority
-     * @returns string OK
-     * @throws ApiError
+     * 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}
      */
-    startWorkflow1(name: string, requestBody: Record<string, any>, version?: number, correlationId?: string, priority?: number): CancelablePromise<string>;
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
     /**
-     * Restarts a completed workflow
-     * @param workflowId
-     * @param useLatestDefinitions
-     * @returns void
-     * @throws ApiError
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
      */
-    restart1(workflowId: string, useLatestDefinitions?: boolean): CancelablePromise<void>;
+    method?: Uppercase<HttpMethod>;
     /**
-     * Search for workflows based on payload and other parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
-     * @param queryId
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @param skipCache
-     * @returns ScrollableSearchResultWorkflowSummary OK
-     * @throws ApiError
+     * 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}
      */
-    search1(queryId?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean): CancelablePromise<ScrollableSearchResultWorkflowSummary>;
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
     /**
-     * Search for workflows based on task parameters
-     * use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
-     * @param start
-     * @param size
-     * @param sort
-     * @param freeText
-     * @param query
-     * @returns SearchResultWorkflow OK
-     * @throws ApiError
+     * 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.
      */
-    searchWorkflowsByTasksV2(start?: number, size?: number, sort?: string, freeText?: string, query?: string): CancelablePromise<SearchResultWorkflow>;
+    requestValidator?: (data: unknown) => Promise<unknown>;
     /**
-     * Resets callback times of all non-terminal SIMPLE tasks to 0
-     * @param workflowId
-     * @returns void
-     * @throws ApiError
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g. converting ISO strings into Date objects.
      */
-    resetWorkflow(workflowId: string): CancelablePromise<void>;
+    responseTransformer?: (data: unknown) => Promise<unknown>;
     /**
-     * Test workflow execution using mock data
-     * @param requestBody
-     * @returns Workflow OK
-     * @throws ApiError
+     * 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.
      */
-    testWorkflow(requestBody: WorkflowTestRequest): CancelablePromise<Workflow>;
+    responseValidator?: (data: unknown) => Promise<unknown>;
 }
-/**
- * Request method
- * @param config The OpenAPI configuration object
- * @param options The request options from the service
- * @returns CancelablePromise<T>
- * @throws ApiError
- */
-declare const request$1: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
-/**
- * A handler to modify requests made by ConductorClient. Useful for metrics/option transformation/etc.
- *
- * @remarks
- * Example: Customizing the request URL
- * ```
- *
- * const requestCustomizer = (request, config, options) =>  {
- *  const url = options.url.replace(/^\/api/, '')
- *  return request(config, {...options, url });
- * }
- * const config = { BASE: "https://my-api.com"}
- * const client = new ConductorClient(config, requestCustomizer)
- * ```
- *
- * @param request the underlying node-fetch powered function
- * @param config @see OpenAPIConfig
- * @param options {see ApiRequestOptions}
- */
-declare type RequestType = typeof request$1;
-declare type ConductorHttpRequest = <T>(request: RequestType, config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
-declare type HumanTaskUser = {
-    user?: string;
-    userType?: 'EXTERNAL_USER' | 'EXTERNAL_GROUP' | 'CONDUCTOR_USER' | 'CONDUCTOR_GROUP';
-};
-declare type HumanTaskAssignment = {
-    assignee?: HumanTaskUser;
-    slaMinutes?: number;
-};
-declare type HumanTaskTrigger = {
-    startWorkflowRequest?: StartWorkflowRequest;
-    triggerType?: 'ASSIGNEE_CHANGED' | 'PENDING' | 'IN_PROGRESS' | 'ASSIGNED' | 'COMPLETED' | 'TIMED_OUT';
-};
-declare type UserFormTemplate = {
-    name?: string;
-    version?: number;
-};
-declare type HumanTaskDefinition = {
-    assignmentCompletionStrategy?: 'LEAVE_OPEN' | 'TERMINATE';
-    assignments?: Array<HumanTaskAssignment>;
-    taskTriggers?: Array<HumanTaskTrigger>;
-    userFormTemplate?: UserFormTemplate;
-};
-declare type HumanTaskEntry = {
-    assignee?: HumanTaskUser;
-    claimant?: HumanTaskUser;
-    createdBy?: string;
-    createdOn?: number;
-    definitionName?: string;
-    displayName?: string;
-    humanTaskDef?: HumanTaskDefinition;
-    input?: Record<string, any>;
-    output?: Record<string, any>;
-    state?: 'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT' | 'DELETED';
-    taskId?: string;
-    taskRefName?: string;
-    updatedBy?: string;
-    updatedOn?: number;
-    workflowId?: string;
-    workflowName?: string;
-};
-declare type HumanTaskSearch = {
-    assignees?: Array<HumanTaskUser>;
-    claimants?: Array<HumanTaskUser>;
-    definitionNames?: Array<string>;
-    taskOutputQuery?: string;
-    taskInputQuery?: string;
-    searchType?: 'ADMIN' | 'INBOX';
-    size?: number;
-    start?: number;
-    states?: Array<'PENDING' | 'ASSIGNED' | 'IN_PROGRESS' | 'COMPLETED' | 'TIMED_OUT' | 'DELETED'>;
-    taskRefNames?: Array<string>;
-    workflowNames?: Array<string>;
-};
-declare type HumanTaskSearchResult = {
-    results?: Array<HumanTaskEntry>;
-    totalHits?: number;
-};
-declare type HumanTaskTemplate = {
-    createdBy?: string;
-    createdOn?: number;
-    jsonSchema: Record<string, any>;
-    name: string;
-    templateUI: Record<string, any>;
-    updatedBy?: string;
-    updatedOn?: number;
-    version: number;
-};
-declare class HumanTaskService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
-    /**
-     * If the workflow is disconnected from tasks, this API can be used to clean up (in bulk)
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
-     */
-    deleteTaskFromHumanTaskRecords(requestBody: Array<string>): CancelablePromise<any>;
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
     /**
-     * If the workflow is disconnected from tasks, this API can be used to clean up
-     * @param taskId
-     * @returns any OK
-     * @throws ApiError
-     */
-    deleteTaskFromHumanTaskRecords1(taskId: string): CancelablePromise<any>;
-    /**
-     * Search human tasks
-     * @param requestBody
-     * @returns HumanTaskSearchResult OK
-     * @throws ApiError
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
      */
-    search(requestBody: HumanTaskSearch): CancelablePromise<HumanTaskSearchResult>;
+    fetch?: typeof fetch;
     /**
-     * Update task output, optionally complete
-     * @param workflowId
-     * @param taskRefName
-     * @param requestBody
-     * @param complete
-     * @param iteration Populate this value if your task is in a loop and you want to update a specific iteration. If its not in a loop OR if you want to just update the latest iteration, leave this as empty
-     * @returns any OK
-     * @throws ApiError
+     * Implementing clients can call request interceptors inside this hook.
      */
-    updateTaskOutputByRef(workflowId: string, taskRefName: string, requestBody: Record<string, any>, complete?: boolean, iteration?: Array<number>): CancelablePromise<any>;
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
     /**
-     * Get a task
-     * @param taskId
-     * @returns HumanTaskEntry OK
-     * @throws ApiError
+     * 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.
      */
-    getTask1(taskId: string): CancelablePromise<HumanTaskEntry>;
+    onSseError?: (error: unknown) => void;
     /**
-     * Claim a task by authenticated Conductor user
-     * @param taskId
-     * @param overrideAssignment
-     * @returns any OK
-     * @throws ApiError
+     * 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).
      */
-    claimTask(taskId: string, overrideAssignment?: boolean, withTemplate?: boolean): CancelablePromise<HumanTaskEntry>;
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
     /**
-     * Claim a task to an external user
-     * @param taskId
-     * @param userId
-     * @param overrideAssignment
-     * @returns any OK
-     * @throws ApiError
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
      */
-    assignAndClaim(taskId: string, userId: string, overrideAssignment?: boolean, withTemplate?: boolean): CancelablePromise<HumanTaskEntry>;
+    sseDefaultRetryDelay?: number;
     /**
-     * Release a task without completing it
-     * @param taskId
-     * @param requestBody
-     * @returns any OK
-     * @throws ApiError
+     * Maximum number of retry attempts before giving up.
      */
-    reassignTask(taskId: string, requestBody: Array<HumanTaskAssignment>): CancelablePromise<any>;
+    sseMaxRetryAttempts?: number;
     /**
-     * Release a task without completing it
-     * @param taskId
-     * @returns any OK
-     * @throws ApiError
+     * 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
      */
-    releaseTask(taskId: string): CancelablePromise<any>;
+    sseMaxRetryDelay?: number;
     /**
-     * If a task is assigned to a user, this API can be used to skip that assignment and move to the next assignee
-     * @param taskId
-     * @param reason
-     * @returns any OK
-     * @throws ApiError
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
      */
-    skipTask(taskId: string, reason?: string): CancelablePromise<any>;
+    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 {
     /**
-     * Update task output, optionally complete
-     * @param taskId
-     * @param requestBody
-     * @param complete
-     * @returns any OK
-     * @throws ApiError
+     * Base URL for all requests made by this client.
      */
-    updateTaskOutput(taskId: string, requestBody: Record<string, any>, complete?: boolean): CancelablePromise<any>;
+    baseUrl?: T['baseUrl'];
     /**
-     * List all user form templates or get templates by name, or a template by name and version
-     * @param name
-     * @param version
-     * @returns HumanTaskTemplate OK
-     * @throws ApiError
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
      */
-    getAllTemplates(name?: string, version?: number): CancelablePromise<Array<HumanTaskTemplate>>;
+    fetch?: typeof fetch;
     /**
-     * Save user form template
-     * @param requestBody
-     * @param newVersion
-     * @returns HumanTaskTemplate OK
-     * @throws ApiError
+     * 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.
      */
-    saveTemplate(requestBody: HumanTaskTemplate, newVersion?: boolean): CancelablePromise<HumanTaskTemplate>;
+    next?: never;
     /**
-     * Save user form template
-     * @param requestBody
-     * @param newVersion
-     * @returns HumanTaskTemplate OK
-     * @throws ApiError
+     * 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'
      */
-    saveTemplates(requestBody: Array<HumanTaskTemplate>, newVersion?: boolean): CancelablePromise<Array<HumanTaskTemplate>>;
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
     /**
-     * Delete all versions of user form template by name
-     * @param name
-     * @returns any OK
-     * @throws ApiError
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
      */
-    deleteTemplateByName(name: string): CancelablePromise<any>;
+    responseStyle?: ResponseStyle;
     /**
-     * Delete a version of form template by name
-     * @param name
-     * @param version
-     * @returns any OK
-     * @throws ApiError
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
      */
-    deleteTemplatesByNameAndVersion(name: string, version: number): CancelablePromise<any>;
+    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'> {
     /**
-     * Get user form template by name and version
-     * @param name
-     * @param version
-     * @returns HumanTaskTemplate OK
-     * @throws ApiError
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
      */
-    getTemplateByNameAndVersion(name: string, version: number): CancelablePromise<HumanTaskTemplate>;
-}
-declare class HumanTaskResourceService {
-    readonly httpRequest: BaseHttpRequest;
-    constructor(httpRequest: BaseHttpRequest);
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
     /**
-     * Get Conductor task by id (for human tasks only)
-     * @param taskId
-     * @returns Task OK
-     * @throws ApiError
+     * Security mechanism(s) to use for the request.
      */
-    getConductorTaskById(taskId: string): CancelablePromise<Task>;
-}
-interface ConductorClientAPIConfig extends Omit<OpenAPIConfig, "BASE"> {
-    serverUrl: string;
-    useEnvVars: boolean;
-}
-declare class ConductorClient {
-    readonly eventResource: EventResourceService;
-    readonly healthCheckResource: HealthCheckResourceService;
-    readonly metadataResource: MetadataResourceService;
-    readonly schedulerResource: SchedulerResourceService;
-    readonly taskResource: TaskResourceService;
-    readonly tokenResource: TokenResourceService;
-    readonly workflowBulkResource: WorkflowBulkResourceService;
-    readonly workflowResource: WorkflowResourceService;
-    readonly humanTask: HumanTaskService;
-    readonly humanTaskResource: HumanTaskResourceService;
-    readonly request: BaseHttpRequest;
-    token?: string | Resolver<string>;
-    constructor(config?: Partial<ConductorClientAPIConfig>, requestHandler?: ConductorHttpRequest);
-    stop(): void;
-}
-declare type ApiResult = {
-    readonly url: string;
-    readonly ok: boolean;
-    readonly status: number;
-    readonly statusText: string;
-    readonly body: any;
-};
-declare class ApiError extends Error {
-    readonly url: string;
-    readonly status: number;
-    readonly statusText: string;
-    readonly body: any;
-    readonly request: ApiRequestOptions;
-    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
-}
-declare type HTScrollableSearchResultHumanTaskEntry = {
-    queryId?: string;
-    results?: Array<HumanTaskEntry>;
-};
-declare type TimeoutPolicy = {
-    type: string;
-};
-declare type Terminate = (TimeoutPolicy & {
-    timeoutSeconds?: number;
-});
-/**
- * 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;
+    security?: ReadonlyArray<Auth>;
+    url: Url;
 }
-interface ConductorLogger {
-    info(...args: any): void;
-    error(...args: any): void;
-    debug(...args: any): void;
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
 }
-declare type ConductorLogLevel = keyof typeof LOG_LEVELS;
-interface DefaultLoggerConfig {
-    level?: ConductorLogLevel;
-    tags?: Object[];
+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;
 }
-declare const LOG_LEVELS: {
-    readonly DEBUG: 10;
-    readonly INFO: 30;
-    readonly ERROR: 60;
+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>;
 };
-declare class DefaultLogger implements ConductorLogger {
-    private readonly tags;
-    private readonly level;
-    constructor(config?: DefaultLoggerConfig);
-    private log;
-    info: (...args: any) => void;
-    debug: (...args: any) => void;
-    error: (...args: any) => void;
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
 }
-declare const noopLogger: ConductorLogger;
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
 interface CommonTaskDef {
     name: string;
     taskReferenceName: string;
 }
+declare enum Consistency {
+    SYNCHRONOUS = "SYNCHRONOUS",
+    DURABLE = "DURABLE",
+    REGION_DURABLE = "REGION_DURABLE"
+}
+declare enum ReturnStrategy {
+    TARGET_WORKFLOW = "TARGET_WORKFLOW",
+    BLOCKING_WORKFLOW = "BLOCKING_WORKFLOW",
+    BLOCKING_TASK = "BLOCKING_TASK",
+    BLOCKING_TASK_INPUT = "BLOCKING_TASK_INPUT"
+}
+declare enum TaskResultStatusEnum {
+    IN_PROGRESS = "IN_PROGRESS",
+    FAILED = "FAILED",
+    FAILED_WITH_TERMINAL_ERROR = "FAILED_WITH_TERMINAL_ERROR",
+    COMPLETED = "COMPLETED"
+}
 declare enum TaskType {
     START = "START",
     SIMPLE = "SIMPLE",
@@ -1560,7 +2547,12 @@ declare enum TaskType {
     JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
     SET_VARIABLE = "SET_VARIABLE"
 }
-declare type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
+declare enum ServiceType {
+    HTTP = "HTTP",
+    MCP_REMOTE = "MCP_REMOTE",
+    gRPC = "gRPC"
+}
+type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
 interface DoWhileTaskDef extends CommonTaskDef {
     inputParameters: Record<string, unknown>;
     type: TaskType.DO_WHILE;
@@ -1574,11 +2566,12 @@ interface EventTaskDef extends CommonTaskDef {
     type: TaskType.EVENT;
     sink: string;
     asyncComplete?: boolean;
+    optional?: boolean;
 }
 interface ForkJoinTaskDef extends CommonTaskDef {
     type: TaskType.FORK_JOIN;
     inputParameters?: Record<string, string>;
-    forkTasks: Array<Array<TaskDefTypes>>;
+    forkTasks: TaskDefTypes[][];
 }
 interface JoinTaskDef extends CommonTaskDef {
     type: TaskType.JOIN;
@@ -1589,8 +2582,8 @@ interface JoinTaskDef extends CommonTaskDef {
 }
 interface ForkJoinDynamicDef extends CommonTaskDef {
     inputParameters: {
-        dynamicTasks: any;
-        dynamicTasksInput: any;
+        dynamicTasks: TaskDefTypes[] | string;
+        dynamicTasksInput: Record<string, unknown> | string;
     };
     type: TaskType.FORK_JOIN_DYNAMIC;
     dynamicForkTasksParam: string;
@@ -1615,6 +2608,8 @@ interface HttpTaskDef extends CommonTaskDef {
         http_request: HttpInputParameters;
     };
     type: TaskType.HTTP;
+    asyncComplete?: boolean;
+    optional?: boolean;
 }
 interface InlineTaskInputParameters {
     evaluatorType: "javascript" | "graaljs";
@@ -1624,6 +2619,7 @@ interface InlineTaskInputParameters {
 interface InlineTaskDef extends CommonTaskDef {
     type: TaskType.INLINE;
     inputParameters: InlineTaskInputParameters;
+    optional?: boolean;
 }
 interface ContainingQueryExpression {
     queryExpression: string;
@@ -1632,6 +2628,7 @@ interface ContainingQueryExpression {
 interface JsonJQTransformTaskDef extends CommonTaskDef {
     type: TaskType.JSON_JQ_TRANSFORM;
     inputParameters: ContainingQueryExpression;
+    optional?: boolean;
 }
 interface KafkaPublishInputParameters {
     topic: string;
@@ -1646,14 +2643,17 @@ interface KafkaPublishTaskDef extends CommonTaskDef {
         kafka_request: KafkaPublishInputParameters;
     };
     type: TaskType.KAFKA_PUBLISH;
+    optional?: boolean;
 }
 interface SetVariableTaskDef extends CommonTaskDef {
     type: TaskType.SET_VARIABLE;
     inputParameters: Record<string, unknown>;
+    optional?: boolean;
 }
 interface SimpleTaskDef extends CommonTaskDef {
     type: TaskType.SIMPLE;
     inputParameters?: Record<string, unknown>;
+    optional?: boolean;
 }
 interface SubWorkflowTaskDef extends CommonTaskDef {
     type: TaskType.SUB_WORKFLOW;
@@ -1663,6 +2663,7 @@ interface SubWorkflowTaskDef extends CommonTaskDef {
         version?: number;
         taskToDomain?: Record<string, string>;
     };
+    optional?: boolean;
 }
 interface SwitchTaskDef extends CommonTaskDef {
     inputParameters: Record<string, unknown>;
@@ -1671,6 +2672,7 @@ interface SwitchTaskDef extends CommonTaskDef {
     defaultCase: TaskDefTypes[];
     evaluatorType: "value-param" | "javascript";
     expression: string;
+    optional?: boolean;
 }
 interface TerminateTaskDef extends CommonTaskDef {
     inputParameters: {
@@ -1680,7 +2682,6 @@ interface TerminateTaskDef extends CommonTaskDef {
     };
     type: TaskType.TERMINATE;
     startDelay?: number;
-    optional?: boolean;
 }
 interface WaitTaskDef extends CommonTaskDef {
     type: TaskType.WAIT;
@@ -1688,14 +2689,138 @@ interface WaitTaskDef extends CommonTaskDef {
         duration?: string;
         until?: string;
     };
+    optional?: boolean;
 }
-interface WorkflowDef extends Omit<WorkflowDef$1, "tasks" | "version" | "inputParameters"> {
-    inputParameters: string[];
-    version: number;
-    tasks: TaskDefTypes[];
+interface ExtendedTaskDef extends Omit<ExtendedTaskDef$1, "timeoutSeconds" | "totalTimeoutSeconds"> {
+    totalTimeoutSeconds?: number;
+    timeoutSeconds?: number;
+}
+interface SignalResponse extends SignalResponse$1 {
+    priority?: number;
+    variables?: Record<string, unknown>;
+    tasks?: Task[];
+    createdBy?: string;
+    createTime?: number;
+    status?: string;
+    updateTime?: number;
+    taskType?: string;
+    taskId?: string;
+    referenceTaskName?: string;
+    retryCount?: number;
+    taskDefName?: string;
+    workflowType?: string;
+}
+type TimeoutPolicy = {
+    type: string;
+};
+type Terminate = TimeoutPolicy & {
+    timeoutSeconds?: number;
+};
+type HTScrollableSearchResultHumanTaskEntry = {
+    queryId?: string;
+    results?: HumanTaskEntry[];
+};
+type StartWorkflow = {
+    name?: string;
+    version?: number;
+    correlationId?: string;
+    input?: Record<string, any>;
+    taskToDomain?: Record<string, string>;
+};
+type SearchResultWorkflowSummary = ScrollableSearchResultWorkflowSummary;
+type SearchResultWorkflow = {
+    totalHits?: number;
+    results?: Array<Workflow>;
+};
+type SearchResultTask = TaskListSearchResultSummary;
+type ExternalStorageLocation = {
+    uri?: string;
+    path?: string;
+};
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+type ApiRequestOptions = {
+    readonly method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD" | "PATCH";
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: "include" | "omit" | "same-origin";
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+type ConductorClient = Client;
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
 }
-declare type TaskErrorHandler = (error: Error, task?: Task) => void;
+/**
+ * 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;
@@ -1705,7 +2830,7 @@ interface TaskRunnerOptions {
 }
 interface RunnerArgs {
     worker: ConductorWorker;
-    taskResource: TaskResourceService;
+    client: Client;
     options: TaskRunnerOptions;
     logger?: ConductorLogger;
     onError?: TaskErrorHandler;
@@ -1725,14 +2850,14 @@ declare const noopErrorHandler: TaskErrorHandler;
  *
  */
 declare class TaskRunner {
-    taskResource: TaskResourceService;
+    _client: Client;
     worker: ConductorWorker;
     private logger;
     private options;
     errorHandler: TaskErrorHandler;
     private poller;
     private maxRetries;
-    constructor({ worker, taskResource, options, logger, onError: errorHandler, maxRetries, }: RunnerArgs);
+    constructor({ worker, client, options, logger, onError: errorHandler, maxRetries, }: RunnerArgs);
     get isPolling(): boolean;
     /**
      * Starts polling for work
@@ -1750,7 +2875,7 @@ declare class TaskRunner {
     handleUnknownError: (unknownError: unknown) => void;
 }
-declare type TaskManagerOptions = TaskRunnerOptions;
+type TaskManagerOptions = TaskRunnerOptions;
 interface TaskManagerConfig {
     logger?: ConductorLogger;
     options?: Partial<TaskManagerOptions>;
@@ -1769,7 +2894,7 @@ declare class TaskManager {
     readonly options: Required<TaskManagerOptions>;
     private polling;
     private maxRetries;
-    constructor(client: ConductorClient, workers: Array<ConductorWorker>, config?: TaskManagerConfig);
+    constructor(client: Client, workers: ConductorWorker[], config?: TaskManagerConfig);
     private workerManagerWorkerOptions;
     get isPolling(): boolean;
     updatePollingOptionForWorker: (workerTaskDefName: string, options: Partial<TaskManagerOptions>) => void;
@@ -1789,25 +2914,46 @@ declare class TaskManager {
     stopPolling: () => Promise<void>;
 }
-declare class ConductorError extends Error {
+declare class ConductorSdkError extends Error {
     private _trace;
     private __proto__;
     constructor(message?: string, innerError?: Error);
 }
-declare type TaskResultStatus = NonNullable<TaskResult['status']>;
+type TaskResultStatus = NonNullable<TaskResult["status"]>;
+type TaskResultOutputData = NonNullable<TaskResult["outputData"]>;
+interface EnhancedSignalResponse extends SignalResponse {
+    isTargetWorkflow(): boolean;
+    isBlockingWorkflow(): boolean;
+    isBlockingTask(): boolean;
+    isBlockingTaskInput(): boolean;
+    getWorkflow(): Workflow;
+    getBlockingTask(): Task;
+    getTaskInput(): Record<string, unknown>;
+    getWorkflowId(): string;
+    getTargetWorkflowId(): string;
+    hasWorkflowData(): boolean;
+    hasTaskData(): boolean;
+    getResponseType(): string;
+    isTerminal(): boolean;
+    isRunning(): boolean;
+    isPaused(): boolean;
+    getSummary(): string;
+    toDebugJSON(): Record<string, unknown>;
+    toString(): string;
+}
-declare type TaskFinderPredicate = (task: Task) => boolean;
+type TaskFinderPredicate = (task: Task) => boolean;
 declare const completedTaskMatchingType: (taskType: string) => TaskFinderPredicate;
 declare class WorkflowExecutor {
-    readonly _client: ConductorClient;
-    constructor(client: ConductorClient);
+    readonly _client: Client;
+    constructor(client: Client);
     /**
      * Will persist a workflow in conductor
      * @param override If true will override the existing workflow with the definition
      * @param workflow Complete workflow definition
      * @returns null
      */
-    registerWorkflow(override: boolean, workflow: WorkflowDef): Promise<void>;
+    registerWorkflow(override: boolean, workflow: WorkflowDef$1): Promise<void>;
     /**
      * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
      * @param workflowRequest
@@ -1815,11 +2961,13 @@ declare class WorkflowExecutor {
      */
     startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
     /**
-     * Execute a workflow synchronously. returns a Promise<WorkflowRun> with details of the running workflow
-     * @param workflowRequest
-     * @returns
+     * Execute a workflow synchronously (original method - backward compatible)
      */
     executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
+    /**
+     * Execute a workflow with return strategy support (new method)
+     */
+    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string, waitForSeconds: number, consistency: Consistency, returnStrategy: ReturnStrategy): Promise<EnhancedSignalResponse>;
     startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise<string>[];
     goBackToTask(workflowInstanceId: string, taskFinderPredicate: TaskFinderPredicate, rerunWorkflowRequestOverrides?: Partial<RerunWorkflowRequest>): Promise<void>;
     goBackToFirstTaskMatchingType(workflowInstanceId: string, taskType: string): Promise<void>;
@@ -1925,7 +3073,7 @@ declare class WorkflowExecutor {
      * @param taskOutput
      * @returns
      */
-    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: Record<string, any>): Promise<string>;
+    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: TaskResultOutputData): Promise<string>;
     /**
      * Updates a task by reference Name
      * @param taskReferenceName
@@ -1934,22 +3082,49 @@ declare class WorkflowExecutor {
      * @param taskOutput
      * @returns
      */
-    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: Record<string, any>): Promise<string>;
+    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>;
 }
-declare type PollIntervalOptions = {
+interface PollIntervalOptions {
     pollInterval: number;
     maxPollTimes: number;
-};
+}
 declare class HumanExecutor {
-    readonly _client: ConductorClient;
-    constructor(client: ConductorClient);
+    readonly _client: Client;
+    constructor(client: Client);
     /**
      * @deprecated use search instead
      * Takes a set of filter parameters. return matches of human tasks for that set of parameters
@@ -2031,53 +3206,53 @@ declare class HumanExecutor {
      * @param taskId
      * @param requestBody
      */
-    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, any>>): Promise<void>;
+    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, unknown>>): Promise<void>;
     /**
      * Takes a taskId and an optional partial body. will complete the task with the given body
      * @param taskId
      * @param requestBody
      */
-    completeTask(taskId: string, requestBody?: Record<string, Record<string, any>>): Promise<void>;
+    completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
 }
-declare const doWhileTask: (taskRefName: string, terminationCondition: string, tasks: TaskDefTypes[]) => DoWhileTaskDef;
-declare const newLoopTask: (taskRefName: string, iterations: number, tasks: TaskDefTypes[]) => DoWhileTaskDef;
+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) => ForkJoinDynamicDef;
+declare const dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string, optional?: boolean) => ForkJoinDynamicDef;
-declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string) => EventTaskDef;
-declare const sqsEventTask: (taskReferenceName: string, queueName: string) => EventTaskDef;
-declare const conductorEventTask: (taskReferenceName: string, eventName: string) => EventTaskDef;
+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[]) => [ForkJoinTaskDef, JoinTaskDef];
+declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[], optional?: boolean) => [ForkJoinTaskDef, JoinTaskDef];
-declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters) => HttpTaskDef;
+declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters, asyncComplete?: boolean, optional?: boolean) => HttpTaskDef;
-declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs") => InlineTaskDef;
+declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs", optional?: boolean) => InlineTaskDef;
-declare const joinTask: (taskReferenceName: string, joinOn: string[]) => JoinTaskDef;
+declare const joinTask: (taskReferenceName: string, joinOn: string[], optional?: boolean) => JoinTaskDef;
-declare const jsonJqTask: (taskReferenceName: string, script: string) => JsonJQTransformTaskDef;
+declare const jsonJqTask: (taskReferenceName: string, script: string, optional?: boolean) => JsonJQTransformTaskDef;
-declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters) => KafkaPublishTaskDef;
+declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters, optional?: boolean) => KafkaPublishTaskDef;
-declare const setVariableTask: (taskReferenceName: string, inputParameters: Record<string, unknown>) => SetVariableTaskDef;
+declare const setVariableTask: (taskReferenceName: string, inputParameters: Record<string, unknown>, optional?: boolean) => SetVariableTaskDef;
-declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>) => SimpleTaskDef;
+declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>, optional?: boolean) => SimpleTaskDef;
-declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number | undefined) => SubWorkflowTaskDef;
+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[]) => SwitchTaskDef;
+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, }: TaskDef) => TaskDef;
+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 | undefined) => TerminateTaskDef;
+declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string) => TerminateTaskDef;
-declare const waitTaskDuration: (taskReferenceName: string, duration: string) => WaitTaskDef;
-declare const waitTaskUntil: (taskReferenceName: string, until: string) => WaitTaskDef;
+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 workflow: (name: string, tasks: TaskDefTypes[]) => WorkflowDef$1;
 /**
  * Takes an optional partial SimpleTaskDef
@@ -2097,29 +3272,27 @@ declare const generateSimpleTask: (overrides?: Partial<SimpleTaskDef>) => Simple
  */
 declare const generateEventTask: (overrides?: Partial<EventTaskDef>) => EventTaskDef;
-declare type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
-interface WorkflowDefGen extends Omit<WorkflowDef, "tasks"> {
+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>[];
 }
-declare type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
-    forkTasks: Array<Array<Partial<TaskDefTypesGen>>>;
+type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
+    forkTasks: Partial<TaskDefTypesGen>[][];
 };
-declare type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
+type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
     decisionCases: Record<string, Partial<TaskDefTypesGen>[]>;
     defaultCase: Partial<TaskDefTypesGen>[];
 };
-declare type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
+type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
     loopOver: Partial<TaskDefTypesGen>[];
 };
 interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "expression"> {
-    expression: string | Function;
+    expression: string | ((...args: never[]) => unknown);
 }
 interface InlineTaskDefGen extends Omit<InlineTaskDef, "inputParameters"> {
     inputParameters: InlineTaskInputParametersGen;
 }
-declare type NestedTaskMapper = {
-    (tasks: Partial<TaskDefTypesGen>[]): TaskDefTypes[];
-};
+type NestedTaskMapper = (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
 declare const generateJoinTask: (overrides?: Partial<JoinTaskDef>) => JoinTaskDef;
@@ -2237,8 +3410,8 @@ declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nest
 declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
 declare class SchedulerClient {
-    readonly _client: ConductorClient;
-    constructor(client: ConductorClient);
+    readonly _client: Client;
+    constructor(client: Client);
     /**
      * Create or update a schedule for a specified workflow with a corresponding start workflow request
      * @param requestBody
@@ -2255,13 +3428,13 @@ declare class SchedulerClient {
      * @param query
      * @returns SearchResultWorkflowScheduleExecutionModel
      */
-    search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise<SearchResultWorkflowScheduleExecutionModel>;
+    search(start: number, size?: number, sort?: string, freeText?: string, query?: string): Promise<SearchResultWorkflowScheduleExecutionModel>;
     /**
      * Get an existing schedule by name
      * @param name
-     * @returns SaveScheduleRequest
+     * @returns WorkflowSchedule
      */
-    getSchedule(name: string): Promise<SaveScheduleRequest>;
+    getSchedule(name: string): Promise<WorkflowSchedule>;
     /**
      * Pauses an existing schedule by name
      * @param name
@@ -2285,9 +3458,9 @@ declare class SchedulerClient {
     /**
      * Get all existing workflow schedules and optionally filter by workflow name
      * @param workflowName
-     * @returns Array<WorkflowSchedule>
+     * @returns Array<WorkflowScheduleModel>
      */
-    getAllSchedules(workflowName?: string): Promise<Array<WorkflowSchedule>>;
+    getAllSchedules(workflowName?: string): Promise<WorkflowScheduleModel[]>;
     /**
      * Get list of the next x (default 3, max 5) execution times for a scheduler
      * @param cronExpression
@@ -2297,7 +3470,7 @@ declare class SchedulerClient {
      * @returns number OK
      * @throws ApiError
      */
-    getNextFewSchedules(cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): Promise<Array<number[]>>;
+    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
@@ -2319,8 +3492,8 @@ declare class SchedulerClient {
 }
 declare class TaskClient {
-    readonly _client: ConductorClient;
-    constructor(client: ConductorClient);
+    readonly _client: Client;
+    constructor(client: Client);
     /**
      * Searches for existing scheduler execution based on below parameters
      *
@@ -2331,7 +3504,7 @@ declare class TaskClient {
      * @param query
      * @returns SearchResultWorkflowScheduleExecutionModel
      */
-    search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise<SearchResultTask>;
+    search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise<SearchResultTaskSummary>;
     /**
      * Get an existing schedule by Id
      * @param taskId
@@ -2348,12 +3521,12 @@ declare class TaskClient {
      * @param workerId
      * @returns
      */
-    updateTaskResult(workflowId: string, taskReferenceName: string, status: TaskResultStatus, outputData: Record<string, unknown>): Promise<TaskResult>;
+    updateTaskResult(workflowId: string, taskRefName: string, status: TaskResultStatus, outputData: Record<string, unknown>): Promise<string>;
 }
 declare class TemplateClient {
-    readonly _client: ConductorClient;
-    constructor(client: ConductorClient);
+    readonly _client: Client;
+    constructor(client: Client);
     /**
      * Register a new human task template
      *
@@ -2364,8 +3537,8 @@ declare class TemplateClient {
 }
 declare class MetadataClient {
-    readonly _client: ConductorClient;
-    constructor(client: ConductorClient);
+    readonly _client: Client;
+    constructor(client: Client);
     /**
      * Unregisters an existing task definition by name
      *
@@ -2379,14 +3552,36 @@ declare class MetadataClient {
      * @param taskDef
      * @returns
      */
-    registerTask(taskDef: TaskDef): Promise<void>;
+    registerTask(taskDef: ExtendedTaskDef): Promise<void>;
+    /**
+     * Registers multiple task definitions (array)
+     *
+     * @param taskDefs
+     * @returns
+     */
+    registerTasks(taskDefs: ExtendedTaskDef[]): Promise<void>;
     /**
      * Update an existing task definition
      *
      * @param taskDef
      * @returns
      */
-    updateTask(taskDef: TaskDef): Promise<void>;
+    updateTask(taskDef: ExtendedTaskDef): Promise<void>;
+    /**
+     * Get an existing task definition
+     *
+     * @param taskName
+     * @returns
+     */
+    getTask(taskName: string): Promise<TaskDef>;
+    /**
+     * Creates or updates (overwrite: true) a workflow definition
+     *
+     * @param workflowDef
+     * @param overwrite
+     * @returns
+     */
+    registerWorkflowDef(workflowDef: ExtendedWorkflowDef, overwrite?: boolean): Promise<void>;
     /**
      * Creates or updates (overwrite: true) a workflow definition
      *
@@ -2394,42 +3589,34 @@ declare class MetadataClient {
      * @param overwrite
      * @returns
      */
-    registerWorkflowDef(workflowDef: WorkflowDef$1, overwrite?: boolean): any;
+    getWorkflowDef(name: string, version?: number, metadata?: boolean): Promise<WorkflowDef$1>;
+    /**
+     * Unregister (overwrite: true) a workflow definition
+     *
+     * @param workflowDef
+     * @param overwrite
+     * @returns
+     */
+    unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
 }
-declare type FetchFn<T = RequestInit, R extends {
-    json: () => Promise<any>;
-} = Response> = (input: RequestInfo, init?: T) => Promise<R>;
-declare type OrkesApiConfig = ConductorClientAPIConfig & GenerateTokenRequest;
+interface OrkesApiConfig {
+    serverUrl?: string;
+    keyId?: string;
+    keySecret?: string;
+    refreshTokenInterval?: number;
+    useEnvVars?: boolean;
+    maxHttp2Connections?: number;
+}
 /**
- * Takes a config with keyId and keySecret returns a promise with an instance of ConductorClient
+ * Takes a config with keyId and keySecret returns a promise with an instance of Client
  *
- * @param config ConductorClientConfig with keyId and keySecret
- * @param requestHandler (optional) ConductorHttpRequest handler
+ * @param config (optional) OrkesApiConfig with keyId and keySecret
+ * @param customFetch (optional) custom fetch function
+ * @param requestHandler DEPRECATED! (optional) ConductorHttpRequest handler, replaced with customFetch
  * @returns
  */
-declare const orkesConductorClient: (config?: Partial<OrkesApiConfig> | undefined, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
-declare class AuthConductorClient extends ConductorClient {
-    intervalId?: NodeJS.Timeout;
-    constructor(config?: Partial<ConductorClientAPIConfig>, requestHandler?: ConductorHttpRequest);
-    /**
-     * Stops the interval that refreshes the token
-     */
-    stop(): void;
-}
-declare const baseOrkesConductorClient: <T = RequestInit, R extends {
-    json: () => Promise<any>;
-} = Response>(fetchFn: FetchFn<T, R>, baseRequestHandler?: ConductorHttpRequest) => (config?: Partial<OrkesApiConfig> | undefined, requestHandler?: ConductorHttpRequest) => Promise<ConductorClient>;
-/**
- * Request method
- * @param config The OpenAPI configuration object
- * @param options The request options from the service
- * @returns CancelablePromise<T>
- * @throws ApiError
- */
-declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions, fetchFn?: FetchFn) => CancelablePromise<T>;
+declare const orkesConductorClient: (config?: OrkesApiConfig, customFetch?: typeof fetch) => Promise<Client>;
-export { Action, ApiError, ApiRequestOptions, ApiResult, AuthConductorClient, BaseHttpRequest, CancelError, CancelablePromise, CommonTaskDef, ConductorClient, ConductorClientAPIConfig, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, EventHandler, EventResourceService, EventTaskDef, ExternalStorageLocation, FetchFn, ForkJoinDynamicDef, ForkJoinTaskDef, GenerateTokenRequest, HTScrollableSearchResultHumanTaskEntry, HealthCheckResourceService, HttpInputParameters, HttpTaskDef, HumanExecutor, HumanTaskAssignment, HumanTaskDefinition, HumanTaskEntry, HumanTaskSearch, HumanTaskSearchResult, HumanTaskTemplate, HumanTaskTrigger, HumanTaskUser, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishInputParameters, KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, MetadataResourceService, OnCancel, OpenAPIConfig, OrkesApiConfig, PollData, RequestType, RerunWorkflowRequest, Response$1 as Response, RunnerArgs, SaveScheduleRequest, SchedulerClient, SchedulerResourceService, ScrollableSearchResultWorkflowSummary, SearchResultTask, SearchResultTaskSummary, SearchResultWorkflow, SearchResultWorkflowScheduleExecutionModel, SearchResultWorkflowSummary, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflow, StartWorkflowRequest, SubWorkflowParams, SubWorkflowTaskDef, SwitchTaskDef, Task, TaskClient, TaskDef, TaskDefTypes, TaskDetails, TaskErrorHandler, TaskExecLog, TaskFinderPredicate, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResourceService, TaskResult, TaskResultStatus, TaskRunner, TaskRunnerOptions, TaskSummary, TaskType, TemplateClient, Terminate, TerminateTaskDef, TimeoutPolicy, TokenResourceService, UserFormTemplate, WaitTaskDef, Workflow, WorkflowBulkResourceService, WorkflowDef, WorkflowExecutor, WorkflowResourceService, WorkflowSchedule, WorkflowScheduleExecutionModel, WorkflowStatus, WorkflowSummary, WorkflowTask, baseOrkesConductorClient, 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, request, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };
+export { type Action, ApiError, type ApiRequestOptions, type ApiResult, BaseHttpRequest, CancelError, CancelablePromise, type CircuitBreakerTransitionResponse, type Client, type CommonTaskDef, type ConductorClient, type ConductorLogLevel, type ConductorLogger, ConductorSdkError, type ConductorWorker, Consistency, DefaultLogger, type DefaultLoggerConfig, type DoWhileTaskDef, type EnhancedSignalResponse, type EventHandler, type EventTaskDef, type ExtendedTaskDef, type ExtendedWorkflowDef, type ExternalStorageLocation, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateTokenRequest, type HTScrollableSearchResultHumanTaskEntry, type HttpInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type JoinTaskDef, type JsonJQTransformTaskDef, type KafkaPublishInputParameters, type KafkaPublishTaskDef, MAX_RETRIES, MetadataClient, type OnCancel, type OpenAPIConfig, type OrkesApiConfig, type PollData, type ProtoRegistryEntry, type RerunWorkflowRequest, type Response$1 as Response, ReturnStrategy, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, type ScrollableSearchResultWorkflowSummary, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, type ServiceMethod, type ServiceRegistry, ServiceType, type SetVariableTaskDef, type SignalResponse, type SimpleTaskDef, type SkipTaskRequest, type StartWorkflow, type StartWorkflowRequest, type SubWorkflowParams, type SubWorkflowTaskDef, type SwitchTaskDef, type Task, TaskClient, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskFinderPredicate, type TaskListSearchResultSummary, TaskManager, type TaskManagerConfig, type TaskManagerOptions, type TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerOptions, type TaskSummary, TaskType, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type UserFormTemplate, type WaitTaskDef, type Workflow, type WorkflowDef$1 as WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, completedTaskMatchingType, conductorEventTask, doWhileTask, dynamicForkTask, eventTask, forkTask, forkTaskJoin, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, httpTask, inlineTask, joinTask, jsonJqTask, kafkaPublishTask, newLoopTask, noopErrorHandler, noopLogger, orkesConductorClient, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };