type AuthToken = string | undefined;
interface Auth {
    /**
     * Which part of the request do we use to send the auth?
     *
     * @default 'header'
     */
    in?: 'header' | 'query' | 'cookie';
    /**
     * Header or query parameter name.
     *
     * @default 'Authorization'
     */
    name?: string;
    scheme?: 'basic' | 'bearer';
    type: 'apiKey' | 'http';
}

interface SerializerOptions<T> {
    /**
     * @default true
     */
    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$2 {
    /**
     * Auth token or a function returning auth token. The resolved value will be
     * added to the request payload as defined by its `security` array.
     */
    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
    /**
     * A function for serializing request body parameter. By default,
     * {@link JSON.stringify()} will be used.
     */
    bodySerializer?: BodySerializer | null;
    /**
     * An object containing any HTTP headers that you want to pre-populate your
     * `Headers` object with.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
     */
    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
    /**
     * The request method.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
     */
    method?: Uppercase<HttpMethod>;
    /**
     * A function for serializing request query parameters. By default, arrays
     * will be exploded in form style, objects will be exploded in deepObject
     * style, and reserved characters are percent-encoded.
     *
     * This method will have no effect if the native `paramsSerializer()` Axios
     * API function is used.
     *
     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
     */
    querySerializer?: QuerySerializer | QuerySerializerOptions;
    /**
     * A function validating request data. This is useful if you want to ensure
     * the request conforms to the desired shape, so it can be safely sent to
     * the server.
     */
    requestValidator?: (data: unknown) => Promise<unknown>;
    /**
     * A function transforming response data before it's returned. This is useful
     * for post-processing data, e.g. converting ISO strings into Date objects.
     */
    responseTransformer?: (data: unknown) => Promise<unknown>;
    /**
     * A function validating response data. This is useful if you want to ensure
     * the response conforms to the desired shape, so it can be safely passed to
     * the transformers and returned to the user.
     */
    responseValidator?: (data: unknown) => Promise<unknown>;
}

type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$2, 'method' | 'responseTransformer' | 'responseValidator'> & {
    /**
     * Fetch API implementation. You can use this option to provide a custom
     * fetch instance.
     *
     * @default globalThis.fetch
     */
    fetch?: typeof fetch;
    /**
     * Implementing clients can call request interceptors inside this hook.
     */
    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
    /**
     * Callback invoked when a network or parsing error occurs during streaming.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @param error The error that occurred.
     */
    onSseError?: (error: unknown) => void;
    /**
     * Callback invoked when an event is streamed from the server.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @param event Event streamed from the server.
     * @returns Nothing (void).
     */
    onSseEvent?: (event: StreamEvent<TData>) => void;
    serializedBody?: RequestInit['body'];
    /**
     * Default retry delay in milliseconds.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @default 3000
     */
    sseDefaultRetryDelay?: number;
    /**
     * Maximum number of retry attempts before giving up.
     */
    sseMaxRetryAttempts?: number;
    /**
     * Maximum retry delay in milliseconds.
     *
     * Applies only when exponential backoff is used.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @default 30000
     */
    sseMaxRetryDelay?: number;
    /**
     * Optional sleep function for retry backoff.
     *
     * Defaults to using `setTimeout`.
     */
    sseSleepFn?: (ms: number) => Promise<void>;
    url: string;
};
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$1<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$2 {
    /**
     * Base URL for all requests made by this client.
     */
    baseUrl?: T['baseUrl'];
    /**
     * Fetch API implementation. You can use this option to provide a custom
     * fetch instance.
     *
     * @default globalThis.fetch
     */
    fetch?: typeof fetch;
    /**
     * Please don't use the Fetch client for Next.js applications. The `next`
     * options won't have any effect.
     *
     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
     */
    next?: never;
    /**
     * Return the response data parsed in a specified format. By default, `auto`
     * will infer the appropriate method from the `Content-Type` response header.
     * You can override this behavior with any of the {@link Body} methods.
     * Select `stream` if you don't want to parse response data at all.
     *
     * @default 'auto'
     */
    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
    /**
     * Should we return only data or multiple fields (data, error, response, etc.)?
     *
     * @default 'fields'
     */
    responseStyle?: ResponseStyle;
    /**
     * Throw an error instead of returning it in the response?
     *
     * @default false
     */
    throwOnError?: T['throwOnError'];
}
interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$1<{
    responseStyle: TResponseStyle;
    throwOnError: ThrowOnError;
}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
    /**
     * Any body that you want to add to your request.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
     */
    body?: unknown;
    path?: Record<string, unknown>;
    query?: Record<string, unknown>;
    /**
     * Security mechanism(s) to use for the request.
     */
    security?: ReadonlyArray<Auth>;
    url: Url;
}
interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
    serializedBody?: string;
}
type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
    request: Request;
    response: Response;
}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
    error: undefined;
} | {
    data: undefined;
    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
}) & {
    request: Request;
    response: Response;
}>;
interface ClientOptions {
    baseUrl?: string;
    responseStyle?: ResponseStyle;
    throwOnError?: boolean;
}
type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type BuildUrlFn = <TData extends {
    body?: unknown;
    path?: Record<string, unknown>;
    query?: Record<string, unknown>;
    url: string;
}>(options: Pick<TData, 'url'> & Options<TData>) => string;
type Client = Client$1<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
};
interface TDataShape {
    body?: unknown;
    headers?: unknown;
    path?: unknown;
    query?: unknown;
    url: string;
}
type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;

type Action = {
    action?: 'start_workflow' | 'complete_task' | 'fail_task' | 'terminate_workflow' | 'update_workflow_variables';
    complete_task?: TaskDetails;
    expandInlineJSON?: boolean;
    fail_task?: TaskDetails;
    start_workflow?: StartWorkflowRequest;
    terminate_workflow?: TerminateWorkflow;
    update_workflow_variables?: UpdateWorkflowVariables;
};
type Any = {
    allFields?: {
        [key: string]: unknown;
    };
    defaultInstanceForType?: Any;
    descriptorForType?: Descriptor;
    initializationErrorString?: string;
    initialized?: boolean;
    parserForType?: ParserAny;
    serializedSize?: number;
    typeUrl?: string;
    typeUrlBytes?: ByteString;
    unknownFields?: UnknownFieldSet;
    value?: ByteString;
};
type AuthorizationRequest = {
    /**
     * The set of access which is granted or removed
     */
    access: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
    subject: SubjectRef;
    target: TargetRef;
};
type BulkResponse = {
    bulkErrorResults?: {
        [key: string]: string;
    };
    bulkSuccessfulResults?: Array<{
        [key: string]: unknown;
    }>;
};
type ByteString = {
    empty?: boolean;
    validUtf8?: boolean;
};
type CacheConfig = {
    key?: string;
    ttlInSecond?: number;
};
type CircuitBreakerTransitionResponse = {
    currentState?: string;
    message?: string;
    previousState?: string;
    service?: string;
    transitionTimestamp?: number;
};
type ConductorUser = {
    applicationUser?: boolean;
    encryptedId?: boolean;
    encryptedIdDisplayValue?: string;
    groups?: Array<Group>;
    id?: string;
    name?: string;
    orkesWorkersApp?: boolean;
    roles?: Array<Role$1>;
    uuid?: string;
};
type Config = {
    circuitBreakerConfig?: OrkesCircuitBreakerConfig;
};
type ConnectivityTestInput = {
    input?: {
        [key: string]: unknown;
    };
    sink: string;
};
type ConnectivityTestResult = {
    reason?: string;
    successful?: boolean;
    workflowId?: string;
};
type CorrelationIdsSearchRequest = {
    correlationIds: Array<string>;
    workflowNames: Array<string>;
};
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$1>;
    fields?: Array<FieldDescriptor$1>;
    file?: FileDescriptor;
    fullName?: string;
    index?: number;
    name?: string;
    nestedTypes?: Array<Descriptor>;
    oneofs?: Array<OneofDescriptor>;
    options?: MessageOptions;
    proto?: DescriptorProto;
    realOneofs?: Array<OneofDescriptor>;
};
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;
};
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;
};
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;
};
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;
    /**
     * @deprecated
     */
    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;
    /**
     * @deprecated
     */
    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 EventMessage = {
    createdAt?: number;
    eventExecutions?: Array<ExtendedEventExecution>;
    eventTarget?: string;
    eventType?: 'WEBHOOK' | 'MESSAGE';
    fullPayload?: {
        [key: string]: unknown;
    };
    id?: string;
    orgId?: string;
    payload?: string;
    status?: 'RECEIVED' | 'HANDLED' | 'REJECTED';
    statusDescription?: string;
};
type ExtendedConductorApplication$1 = {
    createTime?: number;
    createdBy?: string;
    id?: string;
    name?: string;
    tags?: Array<Tag>;
    updateTime?: number;
    updatedBy?: string;
};
type ExtendedEventExecution = {
    action?: 'start_workflow' | 'complete_task' | 'fail_task' | 'terminate_workflow' | 'update_workflow_variables';
    created?: number;
    event?: string;
    eventHandler?: EventHandler;
    fullMessagePayload?: {
        [key: string]: unknown;
    };
    id?: string;
    messageId?: string;
    name?: string;
    orgId?: string;
    output?: {
        [key: string]: unknown;
    };
    payload?: {
        [key: string]: unknown;
    };
    status?: 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'SKIPPED';
    statusDescription?: string;
};
type ExtendedTaskDef$1 = {
    backoffScaleFactor?: number;
    baseType?: string;
    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;
    overwriteTags?: boolean;
    ownerApp?: string;
    ownerEmail?: string;
    pollTimeoutSeconds?: number;
    rateLimitFrequencyInSeconds?: number;
    rateLimitPerFrequency?: number;
    responseTimeoutSeconds?: number;
    retryCount?: number;
    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;
};
type ExtendedWorkflowDef = {
    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;
    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;
    updateTime?: number;
    updatedBy?: string;
    variables?: {
        [key: string]: unknown;
    };
    version?: number;
    workflowStatusListenerEnabled?: boolean;
    workflowStatusListenerSink?: string;
};
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$1 = {
    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$1>;
    file?: FileDescriptor;
    fullName?: string;
    messageTypes?: Array<Descriptor>;
    name?: string;
    options?: FileOptions;
    package?: string;
    proto?: FileDescriptorProto;
    publicDependencies?: Array<FileDescriptor>;
    services?: Array<ServiceDescriptor>;
    /**
     * @deprecated
     */
    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;
    /**
     * @deprecated
     */
    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;
    /**
     * @deprecated
     */
    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;
};
type GenerateTokenRequest = {
    expiration?: number;
    keyId: string;
    keySecret: string;
};
type GrantedAccess = {
    access?: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
    tag?: string;
    target?: TargetRef;
};
type GrantedAccessResponse = {
    grantedAccess?: Array<GrantedAccess>;
};
type Group = {
    defaultAccess?: {
        [key: string]: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
    };
    description?: string;
    id?: string;
    roles?: Array<Role$1>;
};
type HandledEventResponse = {
    active?: boolean;
    event?: string;
    name?: string;
    numberOfActions?: number;
    numberOfMessages?: number;
};
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;
    updatedOn?: number;
    workflowId?: string;
    workflowName?: string;
};
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;
};
type HumanTaskTemplate = {
    createTime?: number;
    createdBy?: string;
    jsonSchema: {
        [key: string]: unknown;
    };
    name: string;
    ownerApp?: string;
    tags?: Array<Tag>;
    templateUI: {
        [key: string]: unknown;
    };
    updateTime?: number;
    updatedBy?: string;
    version: number;
};
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 Integration = {
    apis?: Array<IntegrationApi>;
    category?: 'API' | 'AI_MODEL' | 'VECTOR_DB' | 'RELATIONAL_DB' | 'MESSAGE_BROKER' | 'GIT' | 'EMAIL' | 'MCP';
    configuration?: {
        [key: string]: unknown;
    };
    createTime?: number;
    createdBy?: string;
    description?: string;
    enabled?: boolean;
    modelsCount?: number;
    name?: string;
    ownerApp?: string;
    tags?: Array<Tag>;
    type?: string;
    updateTime?: number;
    updatedBy?: string;
};
type IntegrationApi = {
    api?: string;
    configuration?: {
        [key: string]: unknown;
    };
    createTime?: number;
    createdBy?: string;
    description?: string;
    enabled?: boolean;
    integrationName?: string;
    ownerApp?: string;
    tags?: Array<Tag>;
    updateTime?: number;
    updatedBy?: string;
};
type IntegrationApiUpdate = {
    configuration?: {
        [key: string]: unknown;
    };
    description?: string;
    enabled?: boolean;
};
type IntegrationDef = {
    apis?: Array<IntegrationDefApi>;
    category?: 'API' | 'AI_MODEL' | 'VECTOR_DB' | 'RELATIONAL_DB' | 'MESSAGE_BROKER' | 'GIT' | 'EMAIL' | 'MCP';
    categoryLabel?: string;
    configuration?: Array<IntegrationDefFormField>;
    description?: string;
    enabled?: boolean;
    iconName?: string;
    name?: string;
    tags?: Array<string>;
    type?: string;
};
type IntegrationDefApi = {
    api?: string;
    description?: string;
    inputSchema?: SchemaDef;
    integrationType?: string;
    outputSchema?: SchemaDef;
};
type IntegrationDefFormField = {
    defaultValue?: string;
    description?: string;
    fieldName?: 'api_key' | 'user' | 'endpoint' | 'authUrl' | 'environment' | 'projectName' | 'indexName' | 'publisher' | 'password' | 'namespace' | 'batchSize' | 'batchWaitTime' | 'visibilityTimeout' | 'connectionType' | 'connectionPoolSize' | 'consumer' | 'stream' | 'batchPollConsumersCount' | 'consumer_type' | 'region' | 'awsAccountId' | 'externalId' | 'roleArn' | 'protocol' | 'mechanism' | 'port' | 'schemaRegistryUrl' | 'schemaRegistryApiKey' | 'schemaRegistryApiSecret' | 'authenticationType' | 'truststoreAuthenticationType' | 'tls' | 'cipherSuite' | 'pubSubMethod' | 'keyStorePassword' | 'keyStoreLocation' | 'schemaRegistryAuthType' | 'valueSubjectNameStrategy' | 'datasourceURL' | 'jdbcDriver' | 'subscription' | 'serviceAccountCredentials' | 'file' | 'tlsFile' | 'queueManager' | 'groupId' | 'channel' | 'dimensions' | 'distance_metric' | 'indexing_method' | 'inverted_list_count' | 'pullPeriod' | 'pullBatchWaitMillis' | 'completionsPath' | 'betaVersion' | 'version';
    fieldType?: 'DROPDOWN' | 'TEXT' | 'PASSWORD' | 'FILE';
    label?: string;
    optional?: boolean;
    value?: string;
    valueOptions?: Array<Option>;
};
type IntegrationUpdate = {
    category?: 'API' | 'AI_MODEL' | 'VECTOR_DB' | 'RELATIONAL_DB' | 'MESSAGE_BROKER' | 'GIT' | 'EMAIL' | 'MCP';
    configuration?: {
        [key: string]: unknown;
    };
    description?: string;
    enabled?: boolean;
    type?: string;
};
type Location = {
    allFields?: {
        [key: string]: unknown;
    };
    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;
    /**
     * @deprecated
     */
    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;
    /**
     * @deprecated
     */
    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 MessageTemplate = {
    createTime?: number;
    createdBy?: string;
    description?: string;
    integrations?: Array<string>;
    name?: string;
    ownerApp?: string;
    tags?: Array<Tag>;
    template?: string;
    updateTime?: number;
    updatedBy?: string;
    variables?: Array<string>;
    version?: number;
};
type MethodDescriptor = {
    clientStreaming?: boolean;
    file?: FileDescriptor;
    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;
    /**
     * @deprecated
     */
    synthetic?: boolean;
};
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 Option = {
    label?: string;
    value?: string;
};
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 Permission = {
    name?: string;
};
type PollData = {
    domain?: string;
    lastPollTime?: number;
    queueName?: string;
    workerId?: string;
};
type PromptTemplateTestRequest = {
    llmProvider?: string;
    model?: string;
    prompt?: string;
    promptVariables?: {
        [key: string]: unknown;
    };
    stopWords?: Array<string>;
    temperature?: number;
    topP?: number;
};
type ProtoRegistryEntry = {
    data?: string;
    filename?: string;
    serviceName?: string;
};
type RateLimitConfig = {
    concurrentExecLimit?: number;
    rateLimitKey?: string;
};
type RequestParam = {
    name?: string;
    required?: boolean;
    schema?: Schema;
    type?: string;
};
type RerunWorkflowRequest = {
    correlationId?: string;
    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 Role$1 = {
    name?: string;
    permissions?: Array<Permission>;
};
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;
    updatedBy?: string;
    version: number;
};
type ScrollableSearchResultWorkflowSummary = {
    queryId?: string;
    results?: Array<WorkflowSummary>;
    totalHits?: number;
};
type SearchResultHandledEventResponse = {
    results?: Array<HandledEventResponse>;
    totalHits?: number;
};
type SearchResultTaskSummary = {
    results?: Array<TaskSummary>;
    totalHits?: number;
};
type SearchResultWorkflowScheduleExecutionModel = {
    results?: Array<WorkflowScheduleExecutionModel>;
    totalHits?: number;
};
type ServiceDescriptor = {
    file?: FileDescriptor;
    fullName?: string;
    index?: number;
    methods?: Array<MethodDescriptor>;
    name?: string;
    options?: ServiceOptions;
    proto?: ServiceDescriptorProto;
};
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;
};
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;
};
type ServiceMethod = {
    exampleInput?: {
        [key: string]: unknown;
    };
    id?: number;
    inputType?: string;
    methodName?: string;
    methodType?: string;
    operationName?: string;
    outputType?: string;
    requestParams?: Array<RequestParam>;
};
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;
    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;
};
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;
    };
};
/**
 * User, group or role which is granted/removed access
 */
type SubjectRef = {
    id: string;
    /**
     * User, role or group
     */
    type?: 'USER' | 'ROLE' | 'GROUP';
};
type Tag = {
    key?: string;
    /**
     * @deprecated
     */
    type?: string;
    value?: string;
};
/**
 * The object over which access is being granted or removed
 */
type TargetRef = {
    id: "Identifier of the target e.g. `name` in case it's a WORKFLOW_DEF";
    type: 'WORKFLOW' | 'WORKFLOW_DEF' | 'WORKFLOW_SCHEDULE' | 'EVENT_HANDLER' | 'TASK_DEF' | 'TASK_REF_NAME' | 'TASK_ID' | 'APPLICATION' | 'USER' | 'SECRET_NAME' | 'ENV_VARIABLE' | 'TAG' | 'DOMAIN' | 'INTEGRATION_PROVIDER' | 'INTEGRATION' | 'PROMPT' | 'USER_FORM_TEMPLATE' | 'SCHEMA' | 'CLUSTER_CONFIG' | 'WEBHOOK';
};
type Task = {
    callbackAfterSeconds?: number;
    callbackFromWorker?: boolean;
    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;
};
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 TaskMock = {
    executionTime?: number;
    output?: {
        [key: string]: unknown;
    };
    queueWaitTime?: number;
    status?: 'IN_PROGRESS' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED';
};
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;
    endTime?: string;
    executionTime?: number;
    externalInputPayloadStoragePath?: string;
    externalOutputPayloadStoragePath?: string;
    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;
};
type TerminateWorkflow = {
    terminationReason?: string;
    workflowId?: 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 UpsertGroupRequest = {
    /**
     * a default Map<TargetType, Set<Access> to share permissions, allowed target types: WORKFLOW_DEF, TASK_DEF, WORKFLOW_SCHEDULE
     */
    defaultAccess?: {
        [key: string]: Array<'CREATE' | 'READ' | 'EXECUTE' | 'UPDATE' | 'DELETE'>;
    };
    /**
     * A general description of the group
     */
    description: string;
    roles?: 'ADMIN' | 'USER' | 'WORKER' | 'METADATA_MANAGER' | 'WORKFLOW_MANAGER';
};
type UpsertUserRequest = {
    /**
     * Ids of the groups this user belongs to
     */
    groups?: Array<string>;
    /**
     * User's full name
     */
    name: string;
    roles?: 'ADMIN' | 'USER' | 'WORKER' | 'METADATA_MANAGER' | 'WORKFLOW_MANAGER';
};
type UserFormTemplate = {
    name?: string;
    version?: number;
};
type Workflow = {
    correlationId?: string;
    createTime?: number;
    createdBy?: string;
    endTime?: number;
    event?: string;
    externalInputPayloadStoragePath?: string;
    externalOutputPayloadStoragePath?: string;
    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;
    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;
    workflowId?: string;
    workflowName?: string;
    workflowVersion?: number;
};
type WorkflowDef = {
    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;
};
type WorkflowRun = {
    correlationId?: string;
    createTime?: number;
    createdBy?: string;
    input?: {
        [key: string]: unknown;
    };
    output?: {
        [key: string]: unknown;
    };
    priority?: number;
    requestId?: 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;
};
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;
};
type WorkflowScheduleExecutionModel = {
    executionId?: string;
    executionTime?: number;
    orgId?: string;
    queueMsgId?: string;
    reason?: string;
    scheduleName?: string;
    scheduledTime?: number;
    stackTrace?: string;
    startWorkflowRequest?: StartWorkflowRequest;
    state?: 'POLLED' | 'FAILED' | 'EXECUTED';
    workflowId?: string;
    workflowName?: string;
    zoneId?: string;
};
type WorkflowScheduleModel = {
    createTime?: number;
    createdBy?: string;
    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 WorkflowStateUpdate = {
    taskReferenceName?: string;
    taskResult?: TaskResult;
    variables?: {
        [key: string]: unknown;
    };
};
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;
    /**
     * @deprecated
     */
    caseExpression?: string;
    /**
     * @deprecated
     */
    caseValueParam?: string;
    decisionCases?: {
        [key: string]: Array<WorkflowTask>;
    };
    defaultCase?: Array<WorkflowTask>;
    defaultExclusiveJoinTask?: Array<string>;
    description?: string;
    /**
     * @deprecated
     */
    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 WorkflowTestRequest = {
    correlationId?: string;
    createdBy?: string;
    externalInputPayloadStoragePath?: string;
    idempotencyKey?: string;
    idempotencyStrategy?: 'FAIL' | 'RETURN_EXISTING' | 'FAIL_ON_RUNNING';
    input?: {
        [key: string]: unknown;
    };
    name: string;
    priority?: number;
    subWorkflowTestRequest?: {
        [key: string]: WorkflowTestRequest;
    };
    taskRefToMockOutput?: {
        [key: string]: Array<TaskMock>;
    };
    taskToDomain?: {
        [key: string]: string;
    };
    version?: number;
    workflowDef?: WorkflowDef;
};

interface CommonTaskDef {
    name: string;
    taskReferenceName: string;
}
declare enum Consistency {
    SYNCHRONOUS = "SYNCHRONOUS",
    DURABLE = "DURABLE",
    REGION_DURABLE = "REGION_DURABLE"
}
declare enum ReturnStrategy {
    TARGET_WORKFLOW = "TARGET_WORKFLOW",
    BLOCKING_WORKFLOW = "BLOCKING_WORKFLOW",
    BLOCKING_TASK = "BLOCKING_TASK",
    BLOCKING_TASK_INPUT = "BLOCKING_TASK_INPUT"
}
declare enum TaskResultStatusEnum {
    IN_PROGRESS = "IN_PROGRESS",
    FAILED = "FAILED",
    FAILED_WITH_TERMINAL_ERROR = "FAILED_WITH_TERMINAL_ERROR",
    COMPLETED = "COMPLETED"
}
declare enum TaskType {
    START = "START",
    SIMPLE = "SIMPLE",
    DYNAMIC = "DYNAMIC",
    FORK_JOIN = "FORK_JOIN",
    FORK_JOIN_DYNAMIC = "FORK_JOIN_DYNAMIC",
    DECISION = "DECISION",
    SWITCH = "SWITCH",
    JOIN = "JOIN",
    DO_WHILE = "DO_WHILE",
    SUB_WORKFLOW = "SUB_WORKFLOW",
    START_WORKFLOW = "START_WORKFLOW",
    EVENT = "EVENT",
    WAIT = "WAIT",
    WAIT_FOR_WEBHOOK = "WAIT_FOR_WEBHOOK",
    USER_DEFINED = "USER_DEFINED",
    HTTP = "HTTP",
    HTTP_POLL = "HTTP_POLL",
    HUMAN = "HUMAN",
    LAMBDA = "LAMBDA",
    INLINE = "INLINE",
    EXCLUSIVE_JOIN = "EXCLUSIVE_JOIN",
    TERMINAL = "TERMINAL",
    TERMINATE = "TERMINATE",
    KAFKA_PUBLISH = "KAFKA_PUBLISH",
    JSON_JQ_TRANSFORM = "JSON_JQ_TRANSFORM",
    SET_VARIABLE = "SET_VARIABLE",
    GET_DOCUMENT = "GET_DOCUMENT",
    LLM_CHAT_COMPLETE = "LLM_CHAT_COMPLETE",
    LLM_TEXT_COMPLETE = "LLM_TEXT_COMPLETE",
    LLM_GENERATE_EMBEDDINGS = "LLM_GENERATE_EMBEDDINGS",
    LLM_INDEX_TEXT = "LLM_INDEX_TEXT",
    LLM_SEARCH_INDEX = "LLM_SEARCH_INDEX",
    LLM_SEARCH_EMBEDDINGS = "LLM_SEARCH_EMBEDDINGS",
    LLM_STORE_EMBEDDINGS = "LLM_STORE_EMBEDDINGS",
    LLM_GET_EMBEDDINGS = "LLM_GET_EMBEDDINGS",
    GENERATE_IMAGE = "GENERATE_IMAGE",
    GENERATE_AUDIO = "GENERATE_AUDIO",
    CALL_MCP_TOOL = "CALL_MCP_TOOL",
    LIST_MCP_TOOLS = "LIST_MCP_TOOLS"
}
declare enum ServiceType {
    HTTP = "HTTP",
    MCP_REMOTE = "MCP_REMOTE",
    gRPC = "gRPC"
}
type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
interface DoWhileTaskDef extends CommonTaskDef {
    inputParameters: Record<string, unknown>;
    type: TaskType.DO_WHILE;
    startDelay?: number;
    optional?: boolean;
    asyncComplete?: boolean;
    loopCondition: string;
    loopOver: TaskDefTypes[];
}
interface EventTaskDef extends CommonTaskDef {
    type: TaskType.EVENT;
    sink: string;
    asyncComplete?: boolean;
    optional?: boolean;
}
interface ForkJoinTaskDef extends CommonTaskDef {
    type: TaskType.FORK_JOIN;
    inputParameters?: Record<string, string>;
    forkTasks: TaskDefTypes[][];
}
interface JoinTaskDef extends CommonTaskDef {
    type: TaskType.JOIN;
    inputParameters?: Record<string, string>;
    joinOn: string[];
    optional?: boolean;
    asyncComplete?: boolean;
}
interface ForkJoinDynamicDef extends CommonTaskDef {
    inputParameters: {
        dynamicTasks: TaskDefTypes[] | string;
        dynamicTasksInput: Record<string, unknown> | string;
    };
    type: TaskType.FORK_JOIN_DYNAMIC;
    dynamicForkTasksParam: string;
    dynamicForkTasksInputParamName: string;
    startDelay?: number;
    optional?: boolean;
    asyncComplete?: boolean;
}
interface HttpInputParameters {
    uri: string;
    method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
    accept?: string;
    contentType?: string;
    headers?: Record<string, string>;
    body?: unknown;
    connectionTimeOut?: number;
    readTimeOut?: string;
}
interface HttpTaskDef extends CommonTaskDef {
    inputParameters: {
        [x: string]: unknown;
        http_request: HttpInputParameters;
    };
    type: TaskType.HTTP;
    asyncComplete?: boolean;
    optional?: boolean;
}
interface InlineTaskInputParameters {
    evaluatorType: "javascript" | "graaljs";
    expression: string;
    [x: string]: unknown;
}
interface InlineTaskDef extends CommonTaskDef {
    type: TaskType.INLINE;
    inputParameters: InlineTaskInputParameters;
    optional?: boolean;
}
interface ContainingQueryExpression {
    queryExpression: string;
    [x: string | number | symbol]: unknown;
}
interface JsonJQTransformTaskDef extends CommonTaskDef {
    type: TaskType.JSON_JQ_TRANSFORM;
    inputParameters: ContainingQueryExpression;
    optional?: boolean;
}
interface KafkaPublishInputParameters {
    topic: string;
    value: string;
    bootStrapServers: string;
    headers: Record<string, string>;
    key: string;
    keySerializer: string;
}
interface KafkaPublishTaskDef extends CommonTaskDef {
    inputParameters: {
        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;
    inputParameters?: Record<string, unknown>;
    subWorkflowParam: {
        name: string;
        version?: number;
        taskToDomain?: Record<string, string>;
    };
    optional?: boolean;
}
interface SwitchTaskDef extends CommonTaskDef {
    inputParameters: Record<string, unknown>;
    type: TaskType.SWITCH;
    decisionCases: Record<string, TaskDefTypes[]>;
    defaultCase: TaskDefTypes[];
    evaluatorType: "value-param" | "javascript";
    expression: string;
    optional?: boolean;
}
interface TerminateTaskDef extends CommonTaskDef {
    inputParameters: {
        terminationStatus: "COMPLETED" | "FAILED";
        workflowOutput?: Record<string, string>;
        terminationReason?: string;
    };
    type: TaskType.TERMINATE;
    startDelay?: number;
}
interface WaitTaskDef extends CommonTaskDef {
    type: TaskType.WAIT;
    inputParameters: {
        duration?: string;
        until?: string;
    };
    optional?: boolean;
}
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;
    retriedTaskId?: string;
    workflowType?: string;
    reasonForIncompletion?: string;
}
interface AccessKey {
    id: string;
    secret: string;
}
interface AccessKeyInfo {
    id: string;
    createdAt: number;
    status: "ACTIVE" | "INACTIVE";
}
type ApplicationRole = "ADMIN" | "UNRESTRICTED_WORKER" | "METADATA_MANAGER" | "WORKFLOW_MANAGER" | "APPLICATION_MANAGER" | "USER" | "USER_READ_ONLY" | "WORKER" | "APPLICATION_CREATOR" | "METADATA_API" | "PROMPT_MANAGER";
interface ExtendedConductorApplication extends Required<Omit<ExtendedConductorApplication$1, "tags">> {
    tags?: Tag[];
}
/** Extended ConductorUser with fields present in Python SDK but missing from OpenAPI spec */
interface ExtendedConductorUser extends ConductorUser {
    contactInformation?: Record<string, string>;
    namespace?: string;
}
/** Extended Group with fields present in Python SDK but missing from OpenAPI spec */
interface ExtendedGroup extends Group {
    contactInformation?: Record<string, string>;
}
/** Extended IntegrationApiUpdate with fields present in Python SDK but missing from OpenAPI spec */
interface ExtendedIntegrationApiUpdate extends IntegrationApiUpdate {
    maxTokens?: number;
    frequency?: string;
}
/** Extended RateLimitConfig with fields present in Python SDK but missing from OpenAPI spec */
interface ExtendedRateLimitConfig extends RateLimitConfig {
    tag?: string;
    concurrentExecutionLimit?: number;
}
/** Extended BulkResponse with fields present in Python SDK but missing from OpenAPI spec */
interface ExtendedBulkResponse extends BulkResponse {
    message?: string;
}
/** Extended TaskSummary with fields present in Python SDK but missing from OpenAPI spec */
interface ExtendedTaskSummary extends TaskSummary {
    domain?: string;
}

type TimeoutPolicy = {
    type: string;
};
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>;
}

interface ConductorLogger {
    info(...args: unknown[]): void;
    error(...args: unknown[]): void;
    debug(...args: unknown[]): void;
    warn?(...args: unknown[]): void;
}
type ConductorLogLevel = keyof typeof LOG_LEVELS;
interface DefaultLoggerConfig {
    level?: ConductorLogLevel;
    tags?: object[];
}
declare const LOG_LEVELS: {
    readonly DEBUG: 10;
    readonly INFO: 30;
    readonly WARN: 40;
    readonly ERROR: 60;
};
declare class DefaultLogger implements ConductorLogger {
    private readonly tags;
    private readonly level;
    constructor(config?: DefaultLoggerConfig);
    private log;
    info: (...args: unknown[]) => void;
    debug: (...args: unknown[]) => void;
    warn: (...args: unknown[]) => void;
    error: (...args: unknown[]) => void;
}
declare const noopLogger: ConductorLogger;

type TaskResultStatus = NonNullable<TaskResult["status"]>;
type TaskResultOutputData = NonNullable<TaskResult["outputData"]>;
interface OrkesApiConfig {
    serverUrl?: string;
    keyId?: string;
    keySecret?: string;
    refreshTokenInterval?: number;
    useEnvVars?: boolean;
    maxHttp2Connections?: number;
    logger?: ConductorLogger;
    requestTimeoutMs?: number;
    connectTimeoutMs?: number;
    tlsCertPath?: string;
    tlsKeyPath?: string;
    tlsCaPath?: string;
    proxyUrl?: string;
    tlsInsecure?: boolean;
    disableHttp2?: boolean;
}

/**
 * Creates a Conductor client with authentication and configuration
 *
 * @param config (optional) OrkesApiConfig with keyId and keySecret
 * @param customFetch (optional) custom fetch function
 * @returns Client
 */
declare const createConductorClient: (config?: OrkesApiConfig, customFetch?: typeof fetch) => Promise<{
    eventResource: {
        getQueueConfig: (queueType: string, queueName: string) => Promise<{
            [key: string]: unknown;
        }>;
        putQueueConfig: (queueType: string, queueName: string, body: string) => Promise<void>;
        deleteQueueConfig: (queueType: string, queueName: string) => Promise<void>;
        getEventHandlers: () => Promise<EventHandler[]>;
        updateEventHandler: (body: any) => Promise<void>;
        addEventHandler: (body: any) => Promise<void>;
        getQueueNames: () => Promise<{
            [key: string]: string;
        }>;
        removeEventHandlerStatus: (name: string) => Promise<void>;
        getEventHandlersForEvent: (event: string, activeOnly?: boolean) => Promise<EventHandler[]>;
        deleteTagForEventHandler: (name: string, body: any[]) => Promise<void>;
        getTagsForEventHandler: (name: string) => Promise<Tag[]>;
        putTagForEventHandler: (name: string, body: any[]) => Promise<void>;
    };
    healthCheckResource: {
        doCheck: () => Promise<{
            [key: string]: unknown;
        }>;
    };
    metadataResource: {
        getTaskDef: (tasktype: string, metadata?: boolean) => Promise<{
            [key: string]: unknown;
        }>;
        unregisterTaskDef: (tasktype: string) => Promise<void>;
        getAllWorkflows: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<WorkflowDef[]>;
        update: (requestBody: any[], overwrite?: boolean) => Promise<void>;
        create: (requestBody: any, overwrite?: boolean) => Promise<void>;
        getTaskDefs: (access?: string, metadata?: boolean, tagKey?: string, tagValue?: string) => Promise<TaskDef[]>;
        updateTaskDef: (requestBody: any) => Promise<void>;
        registerTaskDef: (requestBody: any[]) => Promise<void>;
        unregisterWorkflowDef: (name: string, version: number) => Promise<void>;
        get: (name: string, version?: number, metadata?: boolean) => Promise<WorkflowDef>;
    };
    schedulerResource: {
        getSchedule: (name: string) => Promise<WorkflowSchedule>;
        deleteSchedule: (name: string) => Promise<void>;
        getNextFewSchedules: (cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number) => Promise<number[]>;
        pauseSchedule: (name: string) => Promise<void>;
        pauseAllSchedules: () => Promise<{
            [key: string]: unknown;
        }>;
        resumeSchedule: (name: string) => Promise<void>;
        requeueAllExecutionRecords: () => Promise<{
            [key: string]: unknown;
        }>;
        resumeAllSchedules: () => Promise<{
            [key: string]: unknown;
        }>;
        getAllSchedules: (workflowName?: string) => Promise<WorkflowScheduleModel[]>;
        saveSchedule: (requestBody: any) => Promise<void>;
        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultWorkflowScheduleExecutionModel>;
        testTimeout: () => Promise<any>;
    };
    tokenResource: {
        generateToken: (requestBody: any) => Promise<Response$1>;
        getUserInfo: (claims?: boolean) => Promise<{
            [key: string]: unknown;
        }>;
    };
    workflowBulkResource: {
        retry: (requestBody: any[]) => Promise<BulkResponse>;
        restart: (requestBody: any[], useLatestDefinitions?: boolean) => Promise<BulkResponse>;
        terminate: (requestBody: any[], reason?: string) => Promise<BulkResponse>;
        resumeWorkflow: (requestBody: any[]) => Promise<BulkResponse>;
        pauseWorkflow1: (requestBody: any[]) => Promise<BulkResponse>;
    };
    workflowResource: {
        getRunningWorkflow: (name: string, version?: number, startTime?: number, endTime?: number) => Promise<string[]>;
        executeWorkflow: (body: any, name: string, version: number, requestId?: string, waitUntilTaskRef?: string, waitForSeconds?: number, consistency?: any, returnStrategy?: any) => Promise<SignalResponse$1>;
        startWorkflow: (requestBody: any) => Promise<string>;
        decide: (workflowId: string) => Promise<void>;
        rerun: (workflowId: string, requestBody: any) => Promise<string>;
        searchV21: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
        pauseWorkflow: (workflowId: string) => Promise<void>;
        skipTaskFromWorkflow: (workflowId: string, taskReferenceName: string, requestBody?: any) => Promise<void>;
        getWorkflows: (name: string, requestBody: any[], includeClosed?: boolean, includeTasks?: boolean) => Promise<{
            [key: string]: Workflow[];
        }>;
        getWorkflowStatusSummary: (workflowId: string, includeOutput?: boolean, includeVariables?: boolean) => Promise<WorkflowStatus>;
        getWorkflows1: (name: string, correlationId: string, includeClosed?: boolean, includeTasks?: boolean) => Promise<Workflow[]>;
        retry1: (workflowId: string, resumeSubworkflowTasks?: boolean) => Promise<void>;
        getExecutionStatus: (workflowId: string, includeTasks?: boolean) => Promise<Workflow>;
        terminate1: (workflowId: string, reason?: string) => Promise<void>;
        resumeWorkflow: (workflowId: string) => Promise<void>;
        delete: (workflowId: string, archiveWorkflow?: boolean) => Promise<void>;
        searchWorkflowsByTasks: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
        getExternalStorageLocation: (path: string, operation: string, payloadType: string) => Promise<any>;
        startWorkflow1: (name: string, requestBody: any, version?: number, correlationId?: string, priority?: number) => Promise<string>;
        restart1: (workflowId: string, useLatestDefinitions?: boolean) => Promise<void>;
        search1: (queryId?: string, start?: number, size?: number, sort?: string, freeText?: string, query?: string, skipCache?: boolean) => Promise<any>;
        searchWorkflowsByTasksV2: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
        resetWorkflow: (workflowId: string) => Promise<void>;
        testWorkflow: (requestBody: any) => Promise<Workflow>;
    };
    serviceRegistryResource: {
        getRegisteredServices: () => Promise<ServiceRegistry[]>;
        removeService: (name: string) => Promise<void>;
        getService: (name: string) => Promise<ServiceRegistry>;
        openCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
        closeCircuitBreaker: (name: string) => Promise<CircuitBreakerTransitionResponse>;
        getCircuitBreakerStatus: (name: string) => Promise<CircuitBreakerTransitionResponse>;
        addOrUpdateService: (serviceRegistry: any) => Promise<void>;
        addOrUpdateServiceMethod: (registryName: string, method: any) => Promise<void>;
        removeMethod: (registryName: string, serviceName: string, method: string, methodType: string) => Promise<void>;
        getProtoData: (registryName: string, filename: string) => Promise<string>;
        setProtoData: (registryName: string, filename: string, data: any) => Promise<void>;
        deleteProto: (registryName: string, filename: string) => Promise<void>;
        getAllProtos: (registryName: string) => Promise<ProtoRegistryEntry[]>;
        discover: (name: string, create?: boolean) => Promise<ServiceMethod[]>;
    };
    humanTaskResource: {
        getConductorTaskById: (taskId: string) => Promise<Task>;
    };
    humanTask: {
        deleteTaskFromHumanTaskRecords: (requestBody: any[]) => Promise<void>;
        deleteTaskFromHumanTaskRecords1: (taskId: string) => Promise<void>;
        search: (requestBody: any) => Promise<HumanTaskSearchResult>;
        updateTaskOutputByRef: (workflowId: string, taskRefName: string, requestBody: any, complete?: boolean, iteration?: any[]) => Promise<any>;
        getTask1: (taskId: string) => Promise<HumanTaskEntry>;
        claimTask: (taskId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
        assignAndClaim: (taskId: string, userId: string, overrideAssignment?: boolean, withTemplate?: boolean) => Promise<HumanTaskEntry>;
        reassignTask: (taskId: string, requestBody: any[]) => Promise<void>;
        releaseTask: (taskId: string) => Promise<void>;
        skipTask: (taskId: string, reason?: string) => Promise<void>;
        updateTaskOutput: (taskId: string, requestBody: any, complete?: boolean) => Promise<void>;
        getAllTemplates: (name?: string, version?: number) => Promise<HumanTaskTemplate[]>;
        saveTemplate: (requestBody: any, newVersion?: boolean) => Promise<HumanTaskTemplate>;
        saveTemplates: (requestBody: any[], newVersion?: boolean) => Promise<HumanTaskTemplate[]>;
        deleteTemplateByName: (name: string) => Promise<void>;
        deleteTemplatesByNameAndVersion: (name: string, version: number) => Promise<void>;
        getTemplateByNameAndVersion: (name: string, version: number) => Promise<HumanTaskTemplate>;
    };
    taskResource: {
        poll: (tasktype: string, workerid?: string, domain?: string) => Promise<Task>;
        allVerbose: () => Promise<{
            [key: string]: {
                [key: string]: {
                    [key: string]: number;
                };
            };
        }>;
        updateTask: (workflowId: string, taskRefName: string, status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED", requestBody: any) => Promise<string>;
        getTask: (taskId: string) => Promise<Task>;
        all: () => Promise<{
            [key: string]: number;
        }>;
        requeuePendingTask: (taskType: string) => Promise<string>;
        search: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<SearchResultTaskSummary>;
        searchV22: (start?: number, size?: number, sort?: string, freeText?: string, query?: string) => Promise<any>;
        getPollData: (taskType: string) => Promise<PollData[]>;
        getTaskLogs: (taskId: string) => Promise<TaskExecLog[]>;
        log: (taskId: string, requestBody: string) => Promise<void>;
        getAllPollData: () => Promise<{
            [key: string]: unknown;
        }>;
        batchPoll: (tasktype: string, workerid?: string, domain?: string, count?: number, timeout?: number) => Promise<Task[]>;
        updateTask1: (requestBody: any) => Promise<string>;
        size1: (taskType?: string[]) => Promise<{
            [key: string]: number;
        }>;
        getExternalStorageLocation1: (path: string, operation: string, payloadType: string) => Promise<any>;
        updateTaskSync: (workflowId: string, taskRefName: string, status: any, output: any, workerId?: string) => Promise<Workflow>;
        signal: (workflowId: string, status: any, output: any, returnStrategy?: any) => Promise<SignalResponse$1>;
        signalAsync: (workflowId: string, status: any, output: any) => Promise<SignalResponse>;
    };
    buildUrl: <TData extends {
        body?: unknown;
        path?: Record<string, unknown>;
        query?: Record<string, unknown>;
        url: string;
    }>(options: Pick<TData, "url"> & Options<TData>) => string;
    getConfig: () => Config$1<ClientOptions>;
    request: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    setConfig: (config: Config$1<ClientOptions>) => Config$1<ClientOptions>;
    connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
    sse: {
        connect: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        delete: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        get: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        head: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        options: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        patch: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        post: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        put: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
        trace: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
    };
    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
}>;

declare class ApplicationClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Get all applications
     * @returns {Promise<ExtendedConductorApplication[]>}
     * @throws {ConductorSdkError}
     */
    getAllApplications(): Promise<ExtendedConductorApplication[]>;
    /**
     * Create an application
     * @param {string} applicationName
     * @returns {Promise<ExtendedConductorApplication>}
     * @throws {ConductorSdkError}
     */
    createApplication(applicationName: string): Promise<ExtendedConductorApplication>;
    /**
     * Get application by access key id
     * @param {string} accessKeyId
     * @returns {Promise<ExtendedConductorApplication>}
     * @throws {ConductorSdkError}
     */
    getAppByAccessKeyId(accessKeyId: string): Promise<ExtendedConductorApplication>;
    /**
     * Delete an access key
     * @param {string} applicationId
     * @param {string} keyId
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteAccessKey(applicationId: string, keyId: string): Promise<void>;
    /**
     * Toggle the status of an access key
     * @param {string} applicationId
     * @param {string} keyId
     * @returns {Promise<AccessKeyInfo>}
     * @throws {ConductorSdkError}
     */
    toggleAccessKeyStatus(applicationId: string, keyId: string): Promise<AccessKeyInfo>;
    /**
     * Remove role from application user
     * @param {string} applicationId
     * @param {string} role
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    removeRoleFromApplicationUser(applicationId: string, role: string): Promise<void>;
    /**
     * Add role to application
     * @param {string} applicationId
     * @param {ApplicationRole} role
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    addApplicationRole(applicationId: string, role: ApplicationRole): Promise<void>;
    /**
     * Delete an application
     * @param {string} applicationId
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteApplication(applicationId: string): Promise<void>;
    /**
     * Get an application by id
     * @param {string} applicationId
     * @returns {Promise<ExtendedConductorApplication>}
     * @throws {ConductorSdkError}
     */
    getApplication(applicationId: string): Promise<ExtendedConductorApplication>;
    /**
     * Update an application
     * @param {string} applicationId
     * @param {string} newApplicationName
     * @returns {Promise<ExtendedConductorApplication>}
     * @throws {ConductorSdkError}
     */
    updateApplication(applicationId: string, newApplicationName: string): Promise<ExtendedConductorApplication>;
    /**
     * Get application's access keys
     * @param {string} applicationId
     * @returns {Promise<AccessKeyInfo[]>}
     * @throws {ConductorSdkError}
     */
    getAccessKeys(applicationId: string): Promise<AccessKeyInfo[]>;
    /**
     * Create an access key for an application
     * @param {string} applicationId
     * @returns {Promise<AccessKey>}
     * @throws {ConductorSdkError}
     */
    createAccessKey(applicationId: string): Promise<AccessKey>;
    /**
     * Delete application tags
     * @param {string} applicationId
     * @param {Tag[]} tags
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
    /**
     * Delete a single application tag
     * @param {string} applicationId
     * @param {Tag} tag
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteApplicationTag(applicationId: string, tag: Tag): Promise<void>;
    /**
     * Get application tags
     * @param {string} applicationId
     * @returns {Promise<Tag[]>}
     * @throws {ConductorSdkError}
     */
    getApplicationTags(applicationId: string): Promise<Tag[]>;
    /**
     * Add application tags
     * @param {string} applicationId
     * @param {Tag[]} tags
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    addApplicationTags(applicationId: string, tags: Tag[]): Promise<void>;
    /**
     * Add a single application tag
     * @param {string} applicationId
     * @param {Tag} tag
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    addApplicationTag(applicationId: string, tag: Tag): Promise<void>;
}

declare class AuthorizationClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Grant permissions to a subject for a target
     * @param request - The authorization request
     */
    grantPermissions(request: AuthorizationRequest): Promise<void>;
    /**
     * Get permissions for a resource
     * @param type - The resource type
     * @param id - The resource ID
     * @returns The permissions object
     */
    getPermissions(type: "WORKFLOW" | "WORKFLOW_DEF" | "WORKFLOW_SCHEDULE" | "EVENT_HANDLER" | "TASK_DEF" | "TASK_REF_NAME" | "TASK_ID" | "APPLICATION" | "USER" | "SECRET_NAME" | "ENV_VARIABLE" | "TAG" | "DOMAIN" | "INTEGRATION_PROVIDER" | "INTEGRATION" | "PROMPT" | "USER_FORM_TEMPLATE" | "SCHEMA" | "CLUSTER_CONFIG" | "WEBHOOK", id: string): Promise<Record<string, unknown>>;
    /**
     * Remove permissions from a subject for a target
     * @param request - The authorization request
     */
    removePermissions(request: AuthorizationRequest): Promise<void>;
    /**
     * Create or update a user
     * @param id - The user ID
     * @param request - The upsert user request
     * @returns The user object
     */
    upsertUser(id: string, request: UpsertUserRequest): Promise<ExtendedConductorUser>;
    /**
     * Get a user by ID
     * @param id - The user ID
     * @returns The user object
     */
    getUser(id: string): Promise<ExtendedConductorUser>;
    /**
     * List all users
     * @param apps - Whether to include application users
     * @returns Array of users
     */
    listUsers(apps?: boolean): Promise<ExtendedConductorUser[]>;
    /**
     * Delete a user
     * @param id - The user ID
     */
    deleteUser(id: string): Promise<void>;
    /**
     * Check permissions for a user
     * @param userId - The user ID
     * @param type - The resource type
     * @param id - The resource ID
     * @returns The permissions check result
     */
    checkPermissions(userId: string, type: string, id: string): Promise<Record<string, unknown>>;
    /**
     * Get granted permissions for a user
     * @param userId - The user ID
     * @returns The granted permissions
     */
    getGrantedPermissionsForUser(userId: string): Promise<GrantedAccessResponse>;
    /**
     * Create or update a group
     * @param id - The group ID
     * @param request - The upsert group request
     * @returns The group object
     */
    upsertGroup(id: string, request: UpsertGroupRequest): Promise<ExtendedGroup>;
    /**
     * Get a group by ID
     * @param id - The group ID
     * @returns The group object
     */
    getGroup(id: string): Promise<ExtendedGroup>;
    /**
     * List all groups
     * @returns Array of groups
     */
    listGroups(): Promise<ExtendedGroup[]>;
    /**
     * Delete a group
     * @param id - The group ID
     */
    deleteGroup(id: string): Promise<void>;
    /**
     * Add a user to a group
     * @param groupId - The group ID
     * @param userId - The user ID
     */
    addUserToGroup(groupId: string, userId: string): Promise<void>;
    /**
     * Add multiple users to a group
     * @param groupId - The group ID
     * @param userIds - Array of user IDs
     */
    addUsersToGroup(groupId: string, userIds: string[]): Promise<void>;
    /**
     * Get users in a group
     * @param id - The group ID
     * @returns The users in the group
     */
    getUsersInGroup(id: string): Promise<ExtendedConductorUser[]>;
    /**
     * Remove a user from a group
     * @param groupId - The group ID
     * @param userId - The user ID
     */
    removeUserFromGroup(groupId: string, userId: string): Promise<void>;
    /**
     * Remove multiple users from a group
     * @param groupId - The group ID
     * @param userIds - Array of user IDs
     */
    removeUsersFromGroup(groupId: string, userIds: string[]): Promise<void>;
    /**
     * Get granted permissions for a group
     * @param groupId - The group ID
     * @returns The granted access response
     */
    getGrantedPermissionsForGroup(groupId: string): Promise<GrantedAccessResponse>;
}

declare class EventClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Get all the event handlers
     * @returns {Promise<EventHandler[]>}
     * @throws {ConductorSdkError}
     */
    getAllEventHandlers(): Promise<EventHandler[]>;
    /**
     * Add event handlers
     * @param {EventHandler[]} eventHandlers
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    addEventHandlers(eventHandlers: EventHandler[]): Promise<void>;
    /**
     * Add an event handler
     * @param {EventHandler} eventHandler
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    addEventHandler(eventHandler: EventHandler): Promise<void>;
    /**
     * Update an event handler
     * @param {EventHandler} eventHandler
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    updateEventHandler(eventHandler: EventHandler): Promise<void>;
    /**
     * Handle an incoming event
     * @param {Record<string, string>} data
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    handleIncomingEvent(data: Record<string, string>): Promise<void>;
    /**
     * Get an event handler by name
     * @param {string} eventHandlerName
     * @returns {Promise<EventHandler>}
     * @throws {ConductorSdkError}
     */
    getEventHandlerByName(eventHandlerName: string): Promise<EventHandler>;
    /**
     * Get all queue configs
     * @returns {Promise<Record<string, string>>}
     * @throws {ConductorSdkError}
     */
    getAllQueueConfigs(): Promise<Record<string, string>>;
    /**
     * Delete queue config
     * @param {string} queueType
     * @param {string} queueName
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteQueueConfig(queueType: string, queueName: string): Promise<void>;
    /**
     * Get queue config
     * @param {string} queueType
     * @param {string} queueName
     * @returns {Promise<Record<string, unknown>>}
     * @throws {ConductorSdkError}
     */
    getQueueConfig(queueType: string, queueName: string): Promise<Record<string, unknown>>;
    /**
     * Get event handlers for a given event
     * @param {string} event
     * @param {boolean} [activeOnly=false] Only return active handlers.
     * @returns {Promise<EventHandler[]>}
     * @throws {ConductorSdkError}
     */
    getEventHandlersForEvent(event: string, activeOnly?: boolean): Promise<EventHandler[]>;
    /**
     * Remove an event handler by name
     * @param {string} name
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    removeEventHandler(name: string): Promise<void>;
    /**
     * Get tags for an event handler
     * @param {string} name
     * @returns {Promise<Tag[]>}
     * @throws {ConductorSdkError}
     */
    getTagsForEventHandler(name: string): Promise<Tag[]>;
    /**
     * Put tags for an event handler
     * @param {string} name
     * @param {Tag[]} tags
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    putTagForEventHandler(name: string, tags: Tag[]): Promise<void>;
    /**
     * Delete tags for an event handler
     * @param {string} name
     * @param {Tag[]} tags
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteTagsForEventHandler(name: string, tags: Tag[]): Promise<void>;
    /**
     * Delete a tag for an event handler
     * @param {string} name
     * @param {Tag} tag
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    deleteTagForEventHandler(name: string, tag: Tag): Promise<void>;
    /**
     * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
     * @param {ConnectivityTestInput} input
     * @returns {Promise<ConnectivityTestResult>}
     * @throws {ConductorSdkError}
     */
    testConnectivity(input: ConnectivityTestInput): Promise<ConnectivityTestResult>;
    /**
     * Create or update queue config by name
     * @deprecated Prefer server's newer endpoints if available
     * @param {string} queueType
     * @param {string} queueName
     * @param {string} config
     * @returns {Promise<void>}
     * @throws {ConductorSdkError}
     */
    putQueueConfig(queueType: string, queueName: string, config: string): Promise<void>;
    /**
     * Test endpoint (as exposed by API)
     * @returns {Promise<EventHandler>}
     * @throws {ConductorSdkError}
     */
    test(): Promise<EventHandler>;
    /**
     * Get all active event handlers (execution view)
     * @returns {Promise<SearchResultHandledEventResponse>}
     * @throws {ConductorSdkError}
     */
    getAllActiveEventHandlers(): Promise<SearchResultHandledEventResponse>;
    /**
     * Get event executions for a specific handler
     * @param {string} eventHandlerName
     * @param {number} [from] Pagination cursor
     * @returns {Promise<ExtendedEventExecution[]>}
     * @throws {ConductorSdkError}
     */
    getEventExecutions(eventHandlerName: string, from?: number): Promise<ExtendedEventExecution[]>;
    /**
     * Get all event handlers with statistics (messages view)
     * @param {number} [from] Pagination cursor
     * @returns {Promise<SearchResultHandledEventResponse>}
     * @throws {ConductorSdkError}
     */
    getEventHandlersWithStats(from?: number): Promise<SearchResultHandledEventResponse>;
    /**
     * Get event messages for a given event
     * @param {string} event
     * @param {number} [from] Pagination cursor
     * @returns {Promise<EventMessage[]>}
     * @throws {ConductorSdkError}
     */
    getEventMessages(event: string, from?: number): Promise<EventMessage[]>;
}

type UserType = "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP";
interface PollIntervalOptions {
    pollInterval: number;
    maxPollTimes: number;
}
interface ClaimTaskOptions {
    overrideAssignment?: boolean;
    withTemplate?: boolean;
}

declare class HumanExecutor {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * @deprecated use search instead
     * Takes a set of filter parameters. return matches of human tasks for that set of parameters
     * @param state
     * @param assignee
     * @param assigneeType
     * @param claimedBy
     * @param taskName
     * @param freeText
     * @param includeInputOutput
     * @returns
     */
    getTasksByFilter(state: "PENDING" | "ASSIGNED" | "IN_PROGRESS" | "COMPLETED" | "TIMED_OUT", assignee?: string, assigneeType?: "EXTERNAL_USER" | "EXTERNAL_GROUP" | "CONDUCTOR_USER" | "CONDUCTOR_GROUP", claimedBy?: string, taskName?: string, taskInputQuery?: string, taskOutputQuery?: string): Promise<HumanTaskEntry[]>;
    /**
     * Takes a set of filter parameters. return matches of human tasks for that set of parameters
     * @param state
     * @param assignee
     * @param assigneeType
     * @param claimedBy
     * @param taskName
     * @param freeText
     * @param includeInputOutput
     * @returns Promise<HumanTaskEntry[]>
     */
    search(searchParams: Partial<HumanTaskSearch>): Promise<HumanTaskEntry[]>;
    /**
     * Takes a set of filter parameters. An polling interval options. will poll until the task returns a result
     * @param state
     * @param assignee
     * @param assigneeType
     * @param claimedBy
     * @param taskName
     * @param freeText
     * @param includeInputOutput
     * @returns Promise<HumanTaskEntry[]>
     */
    pollSearch(searchParams: Partial<HumanTaskSearch>, { pollInterval, maxPollTimes, }?: PollIntervalOptions): Promise<HumanTaskEntry[]>;
    /**
     * Returns task for a given task id
     * @param taskId
     * @returns
     */
    getTaskById(taskId: string): Promise<HumanTaskEntry>;
    /**
     * Assigns taskId to assignee. If the task is already assigned to another user, this will fail.
     * @param taskId
     * @param assignee
     * @returns
     */
    claimTaskAsExternalUser(taskId: string, assignee: string, options?: ClaimTaskOptions): Promise<HumanTaskEntry>;
    /**
     * Claim task as conductor user
     * @param taskId
     * @returns
     */
    claimTaskAsConductorUser(taskId: string, options?: ClaimTaskOptions): Promise<HumanTaskEntry>;
    /**
     * Claim task as conductor user
     * @param taskId
     * @param assignee
     * @returns
     */
    releaseTask(taskId: string): Promise<void>;
    /**
     * Returns a HumanTaskTemplateEntry for a given name and version
     * @param templateId
     * @returns
     */
    getTemplateByNameVersion(name: string, version: number): Promise<HumanTaskTemplate>;
    /**
     * @deprecated use getTemplate instead. name will be used as id here with version 1
     * Returns a HumanTaskTemplateEntry for a given templateId
     * @param templateId
     * @returns
     */
    getTemplateById(templateNameVersionOne: string): Promise<HumanTaskTemplate>;
    /**
     * Takes a taskId and a partial body. will update with given body
     * @param taskId
     * @param requestBody
     */
    updateTaskOutput(taskId: string, requestBody: Record<string, Record<string, unknown>>): Promise<void>;
    /**
     * Takes a taskId and an optional partial body. will complete the task with the given body
     * @param taskId
     * @param requestBody
     */
    completeTask(taskId: string, requestBody?: Record<string, Record<string, unknown>>): Promise<void>;
}

declare class IntegrationClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Save (create or update) an integration provider
     * @param name - The provider name
     * @param integration - The integration configuration
     */
    saveIntegrationProvider(name: string, integration: IntegrationUpdate): Promise<void>;
    /**
     * Get an integration provider by name
     * @param name - The provider name
     * @returns The integration provider
     */
    getIntegrationProvider(name: string): Promise<Integration>;
    /**
     * Get all integration providers
     * @returns Array of integrations representing providers
     */
    getIntegrationProviders(): Promise<Integration[]>;
    /**
     * Delete an integration provider
     * @param name - The provider name
     */
    deleteIntegrationProvider(name: string): Promise<void>;
    /**
     * Save (create or update) an integration API
     * @param providerName - The provider name
     * @param integrationName - The integration name
     * @param api - The integration API configuration
     */
    saveIntegrationApi(providerName: string, integrationName: string, api: ExtendedIntegrationApiUpdate): Promise<void>;
    /**
     * Get an integration API
     * @param providerName - The provider name
     * @param integrationName - The integration name
     * @returns The integration API
     */
    getIntegrationApi(providerName: string, integrationName: string): Promise<IntegrationApi>;
    /**
     * Get all integration APIs for a provider
     * @param providerName - The provider name
     * @returns Array of integration APIs
     */
    getIntegrationApis(providerName: string): Promise<IntegrationApi[]>;
    /**
     * Delete an integration API
     * @param providerName - The provider name
     * @param integrationName - The integration name
     */
    deleteIntegrationApi(providerName: string, integrationName: string): Promise<void>;
    /**
     * Get all integrations
     * @param category - Optional category filter
     * @param activeOnly - Whether to return only active integrations
     * @returns Array of integrations
     */
    getIntegrations(category?: string, activeOnly?: boolean): Promise<Integration[]>;
    /**
     * Get integration provider definitions
     * @returns Array of integration definitions
     */
    getIntegrationProviderDefs(): Promise<IntegrationDef[]>;
    /**
     * Get providers and integrations
     * @param type - Optional type filter
     * @param activeOnly - Whether to return only active
     * @returns Array of provider and integration info
     */
    getProvidersAndIntegrations(type?: string, activeOnly?: boolean): Promise<string[]>;
    /**
     * Get available APIs for a provider
     * @param providerName - The provider name
     * @returns Array of available APIs
     */
    getIntegrationAvailableApis(providerName: string): Promise<string[]>;
    /**
     * Associate a prompt with an integration
     * @param providerName - The integration provider name
     * @param integrationName - The integration name
     * @param promptName - The prompt template name
     */
    associatePromptWithIntegration(providerName: string, integrationName: string, promptName: string): Promise<void>;
    /**
     * Get prompts associated with an integration
     * @param providerName - The integration provider name
     * @param integrationName - The integration name
     * @returns Array of associated prompt templates
     */
    getPromptsWithIntegration(providerName: string, integrationName: string): Promise<MessageTemplate[]>;
    /**
     * Set tags for an integration
     * @param providerName - The provider name
     * @param integrationName - The integration name
     * @param tags - The tags to set
     */
    setIntegrationTags(providerName: string, integrationName: string, tags: Tag[]): Promise<void>;
    /**
     * Get tags for an integration
     * @param providerName - The provider name
     * @param integrationName - The integration name
     * @returns Array of tags
     */
    getIntegrationTags(providerName: string, integrationName: string): Promise<Tag[]>;
    /**
     * Delete tags from an integration
     * @param providerName - The provider name
     * @param integrationName - The integration name
     * @param tags - The tags to delete
     */
    deleteIntegrationTags(providerName: string, integrationName: string, tags: Tag[]): Promise<void>;
    /**
     * Set tags for an integration provider
     * @param providerName - The provider name
     * @param tags - The tags to set
     */
    setProviderTags(providerName: string, tags: Tag[]): Promise<void>;
    /**
     * Get tags for an integration provider
     * @param providerName - The provider name
     * @returns Array of tags
     */
    getProviderTags(providerName: string): Promise<Tag[]>;
    /**
     * Delete tags from an integration provider
     * @param providerName - The provider name
     * @param tags - The tags to delete
     */
    deleteProviderTags(providerName: string, tags: Tag[]): Promise<void>;
}

declare class MetadataClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Unregisters an existing task definition by name
     *
     * @param name
     * @returns
     */
    unregisterTask(name: string): Promise<void>;
    /**
     * Registers a new task definition
     *
     * @param taskDef
     * @returns
     */
    registerTask(taskDef: ExtendedTaskDef): Promise<void>;
    /**
     * Registers multiple task definitions (array)
     *
     * @param taskDefs
     * @returns
     */
    registerTasks(taskDefs: ExtendedTaskDef[]): Promise<void>;
    /**
     * Update an existing task definition
     *
     * @param taskDef
     * @returns
     */
    updateTask(taskDef: ExtendedTaskDef): Promise<void>;
    /**
     * Get an existing task definition
     *
     * @param taskName
     * @returns
     */
    getTask(taskName: string): Promise<TaskDef>;
    /**
     * Creates or updates (overwrite: true) a workflow definition
     *
     * @param workflowDef
     * @param overwrite
     * @returns
     */
    registerWorkflowDef(workflowDef: ExtendedWorkflowDef, overwrite?: boolean): Promise<void>;
    /**
     * Creates or updates (overwrite: true) a workflow definition
     *
     * @param workflowDef
     * @param overwrite
     * @returns
     */
    getWorkflowDef(name: string, version?: number, metadata?: boolean): Promise<WorkflowDef>;
    /**
     * Unregister (overwrite: true) a workflow definition
     *
     * @param workflowDef
     * @param overwrite
     * @returns
     */
    unregisterWorkflow(workflowName: string, version?: number): Promise<void>;
    /**
     * Get all task definitions
     * @returns Array of all task definitions
     */
    getAllTaskDefs(): Promise<TaskDef[]>;
    /**
     * Get all workflow definitions
     * @returns Array of all workflow definitions
     */
    getAllWorkflowDefs(): Promise<WorkflowDef[]>;
    /**
     * Add a tag to a workflow definition
     * @param tag - The tag to add
     * @param name - The workflow definition name
     */
    addWorkflowTag(tag: Tag, name: string): Promise<void>;
    /**
     * Delete a tag from a workflow definition
     * @param tag - The tag to delete
     * @param name - The workflow definition name
     */
    deleteWorkflowTag(tag: Tag, name: string): Promise<void>;
    /**
     * Get all tags for a workflow definition
     * @param name - The workflow definition name
     * @returns Array of tags
     */
    getWorkflowTags(name: string): Promise<Tag[]>;
    /**
     * Set (replace all existing) tags for a workflow definition
     * @param tags - The tags to set
     * @param name - The workflow definition name
     */
    setWorkflowTags(tags: Tag[], name: string): Promise<void>;
    /**
     * Add a tag to a task definition
     * @param tag - The tag to add
     * @param taskName - The task definition name
     */
    addTaskTag(tag: Tag, taskName: string): Promise<void>;
    /**
     * Delete a tag from a task definition
     * @param tag - The tag to delete
     * @param taskName - The task definition name
     */
    deleteTaskTag(tag: Tag, taskName: string): Promise<void>;
    /**
     * Get all tags for a task definition
     * @param taskName - The task definition name
     * @returns Array of tags
     */
    getTaskTags(taskName: string): Promise<Tag[]>;
    /**
     * Set (replace all existing) tags for a task definition
     * @param tags - The tags to set
     * @param taskName - The task definition name
     */
    setTaskTags(tags: Tag[], taskName: string): Promise<void>;
    /**
     * Set the rate limit configuration for a workflow
     * @param rateLimitConfig - Rate limit configuration
     * @param name - Workflow definition name
     */
    setWorkflowRateLimit(rateLimitConfig: RateLimitConfig | ExtendedRateLimitConfig, name: string): Promise<void>;
    /**
     * Get the rate limit configuration for a workflow
     * @param name - Workflow definition name
     * @returns Rate limit configuration or undefined if not set
     */
    getWorkflowRateLimit(name: string): Promise<RateLimitConfig | ExtendedRateLimitConfig | undefined>;
    /**
     * Remove the rate limit configuration for a workflow
     * @param name - Workflow definition name
     */
    removeWorkflowRateLimit(name: string): Promise<void>;
}

declare class PromptClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Save a prompt template
     * @param name - The prompt name
     * @param description - Description of the prompt
     * @param template - The prompt template text
     * @param models - Optional array of model names
     */
    savePrompt(name: string, description: string, template: string, models?: string[]): Promise<void>;
    /**
     * Update a prompt template
     * @param name - The prompt name
     * @param description - Description of the prompt
     * @param template - The prompt template text
     * @param models - Optional array of model names
     */
    updatePrompt(name: string, description: string, template: string, models?: string[]): Promise<void>;
    /**
     * Get a prompt template by name
     * @param name - The prompt name
     * @returns The message template
     */
    getPrompt(name: string): Promise<MessageTemplate>;
    /**
     * Get all prompt templates
     * @returns Array of message templates
     */
    getPrompts(): Promise<MessageTemplate[]>;
    /**
     * Delete a prompt template
     * @param name - The prompt name
     */
    deletePrompt(name: string): Promise<void>;
    /**
     * Test a prompt template against an LLM
     * @param testRequest - The test request containing prompt text, variables, model info, etc.
     * @returns The LLM response string
     */
    testPrompt(testRequest: PromptTemplateTestRequest): Promise<string>;
    /**
     * Get tags for a prompt template
     * @param name - The prompt name
     * @returns Array of tags
     */
    getPromptTags(name: string): Promise<Tag[]>;
    /**
     * Set tags for a prompt template
     * @param name - The prompt name
     * @param tags - The tags to set
     */
    setPromptTags(name: string, tags: Tag[]): Promise<void>;
    /**
     * Delete tags from a prompt template
     * @param name - The prompt name
     * @param tags - The tags to delete
     */
    deletePromptTags(name: string, tags: Tag[]): Promise<void>;
}

declare class SchedulerClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Create or update a schedule for a specified workflow with a corresponding start workflow request
     * @param requestBody
     * @returns
     */
    saveSchedule(param: SaveScheduleRequest): Promise<void>;
    /**
     * Searches for existing scheduler execution based on below parameters
     *
     * @param start
     * @param size
     * @param sort
     * @param freeText
     * @param query
     * @returns SearchResultWorkflowScheduleExecutionModel
     */
    search(start: number, size?: number, sort?: string, freeText?: string, query?: string): Promise<SearchResultWorkflowScheduleExecutionModel>;
    /**
     * Get an existing schedule by name
     * @param name
     * @returns WorkflowSchedule
     */
    getSchedule(name: string): Promise<WorkflowSchedule>;
    /**
     * Pauses an existing schedule by name
     * @param name
     * @returns
     */
    pauseSchedule(name: string): Promise<void>;
    /**
     * Resume a paused schedule by name
     *
     * @param name
     * @returns
     */
    resumeSchedule(name: string): Promise<void>;
    /**
     * Deletes an existing scheduler execution by name
     *
     * @param name
     * @returns
     */
    deleteSchedule(name: string): Promise<void>;
    /**
     * Get all existing workflow schedules and optionally filter by workflow name
     * @param workflowName
     * @returns Array<WorkflowScheduleModel>
     */
    getAllSchedules(workflowName?: string): Promise<WorkflowScheduleModel[]>;
    /**
     * Get list of the next x (default 3, max 5) execution times for a scheduler
     * @param cronExpression
     * @param scheduleStartTime
     * @param scheduleEndTime
     * @param limit
     * @returns number OK
     * @throws ApiError
     */
    getNextFewSchedules(cronExpression: string, scheduleStartTime?: number, scheduleEndTime?: number, limit?: number): Promise<number[]>;
    /**
     * Pause all scheduling in a single conductor server instance (for debugging only)
     * @returns any OK
     * @throws ApiError
     */
    pauseAllSchedules(): Promise<void>;
    /**
     * Requeue all execution records
     * @returns any OK
     * @throws ApiError
     */
    requeueAllExecutionRecords(): Promise<void>;
    /**
     * Resume all scheduling
     * @returns any OK
     * @throws ApiError
     */
    resumeAllSchedules(): Promise<void>;
    /**
     * Set tags for a schedule
     * @param tags - The tags to set
     * @param name - The schedule name
     */
    setSchedulerTags(tags: Tag[], name: string): Promise<void>;
    /**
     * Get tags for a schedule
     * @param name - The schedule name
     * @returns Array of tags
     */
    getSchedulerTags(name: string): Promise<Tag[]>;
    /**
     * Delete tags from a schedule
     * @param tags - The tags to delete
     * @param name - The schedule name
     */
    deleteSchedulerTags(tags: Tag[], name: string): Promise<void>;
}

declare class SchemaClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Register (create or update) schemas
     * @param schemas - Array of schema definitions to register
     * @param newVersion - Whether to create a new version
     */
    registerSchema(schemas: SchemaDef[], newVersion?: boolean): Promise<void>;
    /**
     * Get a schema by name and version
     * @param name - The schema name
     * @param version - The schema version
     * @returns The schema definition
     */
    getSchema(name: string, version: number): Promise<SchemaDef>;
    /**
     * Get the latest version of a schema by name
     * @param name - The schema name
     * @returns The schema definition
     */
    getSchemaByName(name: string): Promise<SchemaDef>;
    /**
     * Get all schemas
     * @returns Array of all schema definitions
     */
    getAllSchemas(): Promise<SchemaDef[]>;
    /**
     * Delete a specific version of a schema
     * @param name - The schema name
     * @param version - The schema version
     */
    deleteSchema(name: string, version: number): Promise<void>;
    /**
     * Delete all versions of a schema by name
     * @param name - The schema name
     */
    deleteSchemaByName(name: string): Promise<void>;
}

declare class SecretClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Store a secret value
     * @param key - The secret key
     * @param value - The secret value
     */
    putSecret(key: string, value: string): Promise<void>;
    /**
     * Get a secret value
     * @param key - The secret key
     * @returns The secret value
     */
    getSecret(key: string): Promise<string>;
    /**
     * Delete a secret
     * @param key - The secret key
     */
    deleteSecret(key: string): Promise<void>;
    /**
     * List all secret names
     * @returns Array of secret names
     */
    listAllSecretNames(): Promise<string[]>;
    /**
     * List secrets that the user can grant access to
     * @returns Array of secret names
     */
    listSecretsThatUserCanGrantAccessTo(): Promise<string[]>;
    /**
     * Check if a secret exists
     * @param key - The secret key
     * @returns Whether the secret exists
     */
    secretExists(key: string): Promise<boolean>;
    /**
     * Set tags for a secret
     * @param tags - The tags to set
     * @param key - The secret key
     */
    setSecretTags(tags: Tag[], key: string): Promise<void>;
    /**
     * Get tags for a secret
     * @param key - The secret key
     * @returns Array of tags
     */
    getSecretTags(key: string): Promise<Tag[]>;
    /**
     * Delete tags from a secret
     * @param tags - The tags to delete
     * @param key - The secret key
     */
    deleteSecretTags(tags: Tag[], key: string): Promise<void>;
}

/**
 * Client for interacting with the Service Registry API
 */
declare class ServiceRegistryClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Retrieve all registered services
     * @returns Array of all registered services
     */
    getRegisteredServices(): Promise<ServiceRegistry[]>;
    /**
     * Remove a service by name
     * @param name The name of the service to remove
     * @returns Promise that resolves when service is removed
     */
    removeService(name: string): Promise<void>;
    /**
     * Get a service by name
     * @param name The name of the service to retrieve
     * @returns The requested service registry
     */
    getService(name: string): Promise<ServiceRegistry | undefined>;
    /**
     * Open the circuit breaker for a service
     * @param name The name of the service
     * @returns Response with circuit breaker status
     */
    openCircuitBreaker(name: string): Promise<CircuitBreakerTransitionResponse>;
    /**
     * Close the circuit breaker for a service
     * @param name The name of the service
     * @returns Response with circuit breaker status
     */
    closeCircuitBreaker(name: string): Promise<CircuitBreakerTransitionResponse>;
    /**
     * Get circuit breaker status for a service
     * @param name The name of the service
     * @returns Response with circuit breaker status
     */
    getCircuitBreakerStatus(name: string): Promise<CircuitBreakerTransitionResponse>;
    /**
     * Add or update a service registry
     * @param serviceRegistry The service registry to add or update
     * @returns Promise that resolves when service is added or updated
     */
    addOrUpdateService(serviceRegistry: ServiceRegistry): Promise<void>;
    /**
     * Add or update a service method
     * @param registryName The name of the registry
     * @param method The service method to add or update
     * @returns Promise that resolves when method is added or updated
     */
    addOrUpdateServiceMethod(registryName: string, method: ServiceMethod): Promise<void>;
    /**
     * Remove a service method
     * @param registryName The name of the registry
     * @param serviceName The name of the service
     * @param method The name of the method
     * @param methodType The type of the method
     * @returns Promise that resolves when method is removed
     */
    removeMethod(registryName: string, serviceName: string, method: string, methodType: string): Promise<void>;
    /**
     * Get proto data
     * @param registryName The name of the registry
     * @param filename The name of the proto file
     * @returns The proto file data as a Blob
     */
    getProtoData(registryName: string, filename: string): Promise<Blob>;
    /**
     * Set proto data
     * @param registryName The name of the registry
     * @param filename The name of the proto file
     * @param data The proto file data
     * @returns Promise that resolves when proto data is set
     */
    setProtoData(registryName: string, filename: string, data: Blob): Promise<void>;
    /**
     * Delete a proto file
     * @param registryName The name of the registry
     * @param filename The name of the proto file
     * @returns Promise that resolves when proto file is deleted
     */
    deleteProto(registryName: string, filename: string): Promise<void>;
    /**
     * Get all proto files for a registry
     * @param registryName The name of the registry
     * @returns List of proto registry entries
     */
    getAllProtos(registryName: string): Promise<ProtoRegistryEntry[]>;
    /**
     * Discover service methods
     * @param name The name of the service
     * @param create Whether to create the discovered methods (defaults to false)
     * @returns The discovered service methods
     */
    discover(name: string, create?: boolean): Promise<ServiceMethod[]>;
}

declare class TaskClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Searches for existing scheduler execution based on below parameters
     *
     * @param start
     * @param size
     * @param sort
     * @param freeText
     * @param query
     * @returns SearchResultWorkflowScheduleExecutionModel
     */
    search(start: number, size: number, sort: string | undefined, freeText: string, query: string): Promise<SearchResultTaskSummary>;
    /**
     * Get an existing schedule by Id
     * @param taskId
     * @returns Task
     */
    getTask(taskId: string): Promise<Task>;
    /**
     * Update task result status
     *
     * @param workflowId
     * @param taskReferenceName
     * @param status
     * @param outputData
     * @param workerId
     * @returns
     */
    updateTaskResult(workflowId: string, taskRefName: string, status: TaskResultStatus, outputData: Record<string, unknown>): Promise<string>;
    /**
     * Add a log entry to a task
     * @param taskId - The task ID
     * @param message - The log message
     */
    addTaskLog(taskId: string, message: string): Promise<void>;
    /**
     * Get logs for a task
     * @param taskId - The task ID
     * @returns Array of task execution logs
     */
    getTaskLogs(taskId: string): Promise<TaskExecLog[]>;
    /**
     * Get queue sizes for task types
     * @param taskType - Optional array of task types to filter by
     * @returns Map of task type to queue size
     */
    getQueueSizeForTask(taskType?: string[]): Promise<Record<string, number>>;
    /**
     * Get poll data for a task type
     * @param taskType - The task type
     * @returns Array of poll data
     */
    getTaskPollData(taskType: string): Promise<PollData[]>;
    /**
     * Updates a task by reference name synchronously and returns the complete workflow
     * @param workflowId - The workflow instance ID
     * @param taskRefName - The task reference name
     * @param status - The task status
     * @param output - The task output data
     * @param workerId - Optional worker ID
     * @returns The updated workflow
     */
    updateTaskSync(workflowId: string, taskRefName: string, status: "IN_PROGRESS" | "FAILED" | "FAILED_WITH_TERMINAL_ERROR" | "COMPLETED", output: Record<string, unknown>, workerId?: string): Promise<Workflow>;
}

declare class TemplateClient {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * Register a new human task template
     *
     * @param template
     * @returns
     */
    registerTemplate(template: HumanTaskTemplate, asNewVersion?: boolean): Promise<HumanTaskTemplate>;
}

interface EnhancedSignalResponse extends SignalResponse {
    isTargetWorkflow(): boolean;
    isBlockingWorkflow(): boolean;
    isBlockingTask(): boolean;
    isBlockingTaskInput(): boolean;
    getWorkflow(): Workflow;
    getBlockingTask(): Task;
    getTaskInput(): Record<string, unknown>;
    getWorkflowId(): string;
    getTargetWorkflowId(): string;
    hasWorkflowData(): boolean;
    hasTaskData(): boolean;
    getResponseType(): string;
    isTerminal(): boolean;
    isRunning(): boolean;
    isPaused(): boolean;
    getSummary(): string;
    toDebugJSON(): Record<string, unknown>;
    toString(): string;
}
type TaskFinderPredicate = (task: Task) => boolean;

declare class WorkflowExecutor {
    readonly _client: Client;
    constructor(client: Client);
    /**
     * 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>;
    /**
     * Takes a StartWorkflowRequest. returns a Promise<string> with the workflowInstanceId of the running workflow
     * @param workflowRequest
     * @returns
     */
    startWorkflow(workflowRequest: StartWorkflowRequest): Promise<string>;
    /**
     * Execute a workflow synchronously (original method - backward compatible)
     */
    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef?: string): Promise<WorkflowRun>;
    /**
     * Execute a workflow with return strategy support (new method)
     */
    executeWorkflow(workflowRequest: StartWorkflowRequest, name: string, version: number, requestId: string, waitUntilTaskRef: string, waitForSeconds: number, consistency: Consistency, returnStrategy: ReturnStrategy): Promise<EnhancedSignalResponse>;
    startWorkflows(workflowsRequest: StartWorkflowRequest[]): Promise<string>[];
    goBackToTask(workflowInstanceId: string, taskFinderPredicate: TaskFinderPredicate, rerunWorkflowRequestOverrides?: Partial<RerunWorkflowRequest>): Promise<void>;
    goBackToFirstTaskMatchingType(workflowInstanceId: string, taskType: string): Promise<void>;
    /**
     * Takes an workflowInstanceId and an includeTasks and an optional retry parameter returns the whole execution status.
     * If includeTasks flag is provided. Details of tasks execution will be returned as well,
     * retry specifies the amount of retrys before throwing an error.
     *
     * @param workflowInstanceId
     * @param includeTasks
     * @param retry
     * @returns
     */
    getWorkflow(workflowInstanceId: string, includeTasks: boolean, retry?: number): Promise<Workflow>;
    /**
     *  Returns a summary of the current workflow status.
     *
     * @param workflowInstanceId current running workflow
     * @param includeOutput flag to include output
     * @param includeVariables flag to include variable
     * @returns Promise<WorkflowStatus>
     */
    getWorkflowStatus(workflowInstanceId: string, includeOutput: boolean, includeVariables: boolean): Promise<WorkflowStatus>;
    /**
     *  Returns a summary of the current workflow status.
     *
     * @param workflowInstanceId current running workflow
     * @param includeOutput flag to include output
     * @param includeVariables flag to include variable
     * @returns Promise<WorkflowStatus>
     */
    getExecution(workflowInstanceId: string, includeTasks?: boolean): Promise<Workflow>;
    /**
     * Pauses a running workflow
     * @param workflowInstanceId current workflow execution
     * @returns
     */
    pause(workflowInstanceId: string): Promise<void>;
    /**
     * Reruns workflowInstanceId workflow. with new parameters
     *
     * @param workflowInstanceId current workflow execution
     * @param rerunWorkflowRequest Rerun Workflow Execution Request
     * @returns
     */
    reRun(workflowInstanceId: string, rerunWorkflowRequest?: Partial<RerunWorkflowRequest>): Promise<string>;
    /**
     * Restarts workflow with workflowInstanceId, if useLatestDefinition uses last defintion
     * @param workflowInstanceId
     * @param useLatestDefinitions
     * @returns
     */
    restart(workflowInstanceId: string, useLatestDefinitions: boolean): Promise<void>;
    /**
     * Resumes a previously paused execution
     *
     * @param workflowInstanceId Running workflow workflowInstanceId
     * @returns
     */
    resume(workflowInstanceId: string): Promise<void>;
    /**
     * Retrys workflow from last failing task
     * if resumeSubworkflowTasks is true will resume tasks in spawned subworkflows
     *
     * @param workflowInstanceId
     * @param resumeSubworkflowTasks
     * @returns
     */
    retry(workflowInstanceId: string, resumeSubworkflowTasks: boolean): Promise<void>;
    /**
     * Searches for existing workflows given the following querys
     *
     * @param start
     * @param size
     * @param query
     * @param freeText
     * @param sort
     * @param skipCache
     * @returns
     */
    search(start: number, size: number, query: string, freeText: string, sort?: string, skipCache?: boolean): Promise<ScrollableSearchResultWorkflowSummary>;
    /**
     * Skips a task of a running workflow.
     * by providing a skipTaskRequest you can set the input and the output of the skipped tasks
     * @param workflowInstanceId
     * @param taskReferenceName
     * @param skipTaskRequest
     * @returns
     */
    skipTasksFromWorkflow(workflowInstanceId: string, taskReferenceName: string, skipTaskRequest: Partial<SkipTaskRequest>): Promise<void>;
    /**
     * Takes an workflowInstanceId, and terminates a running workflow
     * @param workflowInstanceId
     * @param reason
     * @returns
     */
    terminate(workflowInstanceId: string, reason: string): Promise<void>;
    /**
     * Takes a taskId and a workflowInstanceId. Will update the task for the corresponding taskId
     * @param taskId
     * @param workflowInstanceId
     * @param taskStatus
     * @param taskOutput
     * @returns
     */
    updateTask(taskId: string, workflowInstanceId: string, taskStatus: TaskResultStatus, outputData: TaskResultOutputData): Promise<string>;
    /**
     * Updates a task by reference Name
     * @param taskReferenceName
     * @param workflowInstanceId
     * @param status
     * @param taskOutput
     * @returns
     */
    updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatus, taskOutput: TaskResultOutputData): Promise<string>;
    /**
     *
     * @param taskId
     * @returns
     */
    getTask(taskId: string): Promise<Task>;
    /**
     * Updates a task by reference name synchronously and returns the complete workflow
     * @param taskReferenceName
     * @param workflowInstanceId
     * @param status
     * @param taskOutput
     * @param workerId - Optional
     * @returns Promise<Workflow>
     */
    updateTaskSync(taskReferenceName: string, workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, workerId?: string): Promise<Workflow>;
    /**
     * Signals a workflow task and returns data based on the specified return strategy
     * @param workflowInstanceId - Workflow instance ID to signal
     * @param status - Task status to set
     * @param taskOutput - Output data for the task
     * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
     * @returns Promise<SignalResponse> with data based on the return strategy
     */
    signal(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData, returnStrategy?: ReturnStrategy): Promise<EnhancedSignalResponse>;
    /**
     * Signals a workflow task asynchronously (fire-and-forget)
     * @param workflowInstanceId - Workflow instance ID to signal
     * @param status - Task status to set
     * @param taskOutput - Output data for the task
     * @returns Promise<void>
     */
    signalAsync(workflowInstanceId: string, status: TaskResultStatusEnum, taskOutput: TaskResultOutputData): Promise<void>;
    /**
     * Deletes a workflow execution
     * @param workflowId - The workflow instance ID to delete
     * @param archiveWorkflow - Whether to archive the workflow before deletion
     */
    deleteWorkflow(workflowId: string, archiveWorkflow?: boolean): Promise<void>;
    /**
     * Gets workflows by correlation IDs
     * @param request - Correlation IDs search request containing workflow names and correlation IDs
     * @param includeClosed - Whether to include closed workflows
     * @param includeTasks - Whether to include task details
     * @returns Map of correlation ID to array of matching workflows
     */
    getByCorrelationIds(request: CorrelationIdsSearchRequest, includeClosed?: boolean, includeTasks?: boolean): Promise<Record<string, Workflow[]>>;
    /**
     * Tests a workflow execution with mock data
     * @param testRequest - The workflow test request containing workflow definition and mock task outputs
     * @returns The simulated workflow execution result
     */
    testWorkflow(testRequest: WorkflowTestRequest): Promise<Workflow>;
    /**
     * Updates workflow variables
     * @param workflowId - The workflow instance ID
     * @param variables - The variables to update
     * @returns The updated workflow
     */
    updateVariables(workflowId: string, variables: Record<string, unknown>): Promise<Workflow>;
    /**
     * Updates the workflow state (task result + variables) and optionally waits for further execution
     * @param workflowId - The workflow instance ID
     * @param updateRequest - The state update request containing task result and/or variables
     * @param requestId - A unique request ID for idempotency
     * @param waitUntilTaskRef - Optional task reference name to wait until
     * @param waitForSeconds - Optional number of seconds to wait
     * @returns The workflow run status after the update
     */
    updateState(workflowId: string, updateRequest: WorkflowStateUpdate, requestId: string, waitUntilTaskRef?: string, waitForSeconds?: number): Promise<WorkflowRun>;
    /**
     * Starts a workflow by name with input directly (without a StartWorkflowRequest object)
     * @param name - The workflow name
     * @param input - The workflow input data
     * @param version - Optional workflow version
     * @param correlationId - Optional correlation ID
     * @param priority - Optional priority
     * @returns The workflow instance ID
     */
    startWorkflowByName(name: string, input: Record<string, unknown>, version?: number, correlationId?: string, priority?: number): Promise<string>;
}

/**
 * Factory class that provides access to all Conductor client instances.
 * Equivalent to Python SDK's `OrkesClients`.
 *
 * Usage:
 * ```typescript
 * const clients = await OrkesClients.from({ serverUrl, keyId, keySecret });
 * const workflowClient = clients.getWorkflowClient();
 * const metadataClient = clients.getMetadataClient();
 * ```
 */
declare class OrkesClients {
    private readonly _client;
    constructor(client: Client);
    /**
     * Creates an OrkesClients instance from configuration.
     * Handles authentication and connection setup.
     */
    static from(config?: OrkesApiConfig): Promise<OrkesClients>;
    /** Returns the underlying HTTP client */
    getClient(): Client;
    getWorkflowClient(): WorkflowExecutor;
    getMetadataClient(): MetadataClient;
    getTaskClient(): TaskClient;
    getSchedulerClient(): SchedulerClient;
    getSecretClient(): SecretClient;
    getSchemaClient(): SchemaClient;
    getAuthorizationClient(): AuthorizationClient;
    getIntegrationClient(): IntegrationClient;
    getPromptClient(): PromptClient;
    getApplicationClient(): ApplicationClient;
    getEventClient(): EventClient;
    getHumanClient(): HumanExecutor;
    getTemplateClient(): TemplateClient;
    getServiceRegistryClient(): ServiceRegistryClient;
}

/**
 * Event types for task runner lifecycle events.
 *
 * These events provide observability into the worker polling and execution lifecycle,
 * matching the Python SDK's event system architecture.
 */
/**
 * Base interface for all task runner events.
 */
interface TaskRunnerEvent {
    /** The task definition name */
    taskType: string;
    /** UTC timestamp when the event was created */
    timestamp: Date;
}
/**
 * Event published when task polling begins.
 */
interface PollStarted extends TaskRunnerEvent {
    /** Identifier of the worker polling for tasks */
    workerId: string;
    /** Number of tasks requested in this poll */
    pollCount: number;
}
/**
 * Event published when task polling completes successfully.
 */
interface PollCompleted extends TaskRunnerEvent {
    /** Time taken for the poll operation in milliseconds */
    durationMs: number;
    /** Number of tasks received from the poll */
    tasksReceived: number;
}
/**
 * Event published when task polling fails.
 */
interface PollFailure extends TaskRunnerEvent {
    /** Time taken before the poll failed in milliseconds */
    durationMs: number;
    /** The error that caused the failure */
    cause: Error;
}
/**
 * Event published when task execution begins.
 */
interface TaskExecutionStarted extends TaskRunnerEvent {
    /** Unique identifier of the task instance */
    taskId: string;
    /** Identifier of the worker executing the task */
    workerId: string;
    /** ID of the workflow instance this task belongs to */
    workflowInstanceId?: string;
}
/**
 * Event published when task execution completes successfully.
 */
interface TaskExecutionCompleted extends TaskRunnerEvent {
    /** Unique identifier of the task instance */
    taskId: string;
    /** Identifier of the worker that executed the task */
    workerId: string;
    /** ID of the workflow instance this task belongs to */
    workflowInstanceId?: string;
    /** Time taken for task execution in milliseconds */
    durationMs: number;
    /** Size of the task output in bytes (if available) */
    outputSizeBytes?: number;
}
/**
 * Event published when task execution fails.
 */
interface TaskExecutionFailure extends TaskRunnerEvent {
    /** Unique identifier of the task instance */
    taskId: string;
    /** Identifier of the worker that attempted execution */
    workerId: string;
    /** ID of the workflow instance this task belongs to */
    workflowInstanceId?: string;
    /** The error that caused the failure */
    cause: Error;
    /** Time taken before failure in milliseconds */
    durationMs: number;
}
/**
 * Event published when task update fails after all retry attempts.
 *
 * This is a CRITICAL event indicating that the worker successfully executed a task
 * but failed to communicate the result back to Conductor after multiple retries.
 *
 * The task result is lost from Conductor's perspective, and external intervention
 * may be required to reconcile the state.
 *
 * Use Cases:
 * - Alert operations team of critical update failures
 * - Log failed task results to external storage for recovery
 * - Implement custom retry logic with different backoff strategies
 * - Track update reliability metrics
 * - Trigger incident response workflows
 */
interface TaskUpdateFailure extends TaskRunnerEvent {
    /** Unique identifier of the task instance */
    taskId: string;
    /** Identifier of the worker that executed the task */
    workerId: string;
    /** ID of the workflow instance this task belongs to */
    workflowInstanceId?: string;
    /** The error that caused the final update failure */
    cause: Error;
    /** Number of retry attempts made */
    retryCount: number;
    /** The TaskResult object that failed to update (for recovery/logging) */
    taskResult: unknown;
}
/**
 * Event published when task update completes successfully.
 */
interface TaskUpdateCompleted extends TaskRunnerEvent {
    /** Unique identifier of the task instance */
    taskId: string;
    /** Identifier of the worker that executed the task */
    workerId: string;
    /** ID of the workflow instance this task belongs to */
    workflowInstanceId?: string;
    /** Time taken for the update API call in milliseconds */
    durationMs: number;
}
/**
 * Union type of all task runner events.
 */
type TaskRunnerEventType = PollStarted | PollCompleted | PollFailure | TaskExecutionStarted | TaskExecutionCompleted | TaskExecutionFailure | TaskUpdateCompleted | TaskUpdateFailure;

/**
 * Interface for task runner event listeners.
 *
 * All methods are optional - implement only the events you need to handle.
 * Listener failures are isolated and will not affect task execution.
 */
interface TaskRunnerEventsListener {
    /**
     * Called when task polling begins.
     */
    onPollStarted?(event: PollStarted): void | Promise<void>;
    /**
     * Called when task polling completes successfully.
     */
    onPollCompleted?(event: PollCompleted): void | Promise<void>;
    /**
     * Called when task polling fails.
     */
    onPollFailure?(event: PollFailure): void | Promise<void>;
    /**
     * Called when task execution begins.
     */
    onTaskExecutionStarted?(event: TaskExecutionStarted): void | Promise<void>;
    /**
     * Called when task execution completes successfully.
     */
    onTaskExecutionCompleted?(event: TaskExecutionCompleted): void | Promise<void>;
    /**
     * Called when task execution fails.
     */
    onTaskExecutionFailure?(event: TaskExecutionFailure): void | Promise<void>;
    /**
     * Called when task update completes successfully.
     */
    onTaskUpdateCompleted?(event: TaskUpdateCompleted): void | Promise<void>;
    /**
     * Called when task update fails after all retry attempts.
     * This is a CRITICAL event that may require operational intervention.
     */
    onTaskUpdateFailure?(event: TaskUpdateFailure): void | Promise<void>;
}
/**
 * Event dispatcher for task runner events.
 *
 * Provides a decoupled event system for observability and metrics collection.
 * Events are published asynchronously and listener failures are isolated.
 */
declare class EventDispatcher {
    private listeners;
    private logger?;
    constructor(logger?: ConductorLogger);
    /**
     * Register an event listener.
     *
     * @param listener - The listener to register
     */
    register(listener: TaskRunnerEventsListener): void;
    /**
     * Unregister an event listener.
     *
     * @param listener - The listener to unregister
     */
    unregister(listener: TaskRunnerEventsListener): void;
    /**
     * Publish a PollStarted event.
     */
    publishPollStarted(event: PollStarted): Promise<void>;
    /**
     * Publish a PollCompleted event.
     */
    publishPollCompleted(event: PollCompleted): Promise<void>;
    /**
     * Publish a PollFailure event.
     */
    publishPollFailure(event: PollFailure): Promise<void>;
    /**
     * Publish a TaskExecutionStarted event.
     */
    publishTaskExecutionStarted(event: TaskExecutionStarted): Promise<void>;
    /**
     * Publish a TaskExecutionCompleted event.
     */
    publishTaskExecutionCompleted(event: TaskExecutionCompleted): Promise<void>;
    /**
     * Publish a TaskExecutionFailure event.
     */
    publishTaskExecutionFailure(event: TaskExecutionFailure): Promise<void>;
    /**
     * Publish a TaskUpdateCompleted event.
     */
    publishTaskUpdateCompleted(event: TaskUpdateCompleted): Promise<void>;
    /**
     * Publish a TaskUpdateFailure event.
     */
    publishTaskUpdateFailure(event: TaskUpdateFailure): Promise<void>;
    /**
     * Internal method to publish events to all registered listeners.
     * Listener failures are caught and logged to prevent affecting task execution.
     */
    private publishEvent;
}

type TaskErrorHandler = (error: Error, task?: Task) => void;
/**
 * Return type for long-running tasks.
 *
 * When a worker returns this, the task is sent to Conductor with IN_PROGRESS status
 * and Conductor will re-queue the task after `callbackAfterSeconds`.
 *
 * @example
 * ```typescript
 * @worker({ taskDefName: "long_running_task" })
 * async function longTask(task: Task): Promise<TaskInProgressResult | TaskResult> {
 *   if (!isReady()) {
 *     return { status: "IN_PROGRESS", callbackAfterSeconds: 30, outputData: { progress: 50 } };
 *   }
 *   return { status: "COMPLETED", outputData: { result: "done" } };
 * }
 * ```
 */
interface TaskInProgressResult {
    status: "IN_PROGRESS";
    callbackAfterSeconds: number;
    outputData?: Record<string, unknown>;
}
/**
 * Type guard for TaskInProgressResult.
 */
declare function isTaskInProgress(result: unknown): result is TaskInProgressResult;
interface ConductorWorker {
    taskDefName: string;
    execute: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId"> | TaskInProgressResult>;
    domain?: string;
    /** Number of polling instances to run concurrently */
    concurrency?: number;
    pollInterval?: number;
}
interface TaskRunnerOptions {
    workerID: string;
    domain: string | undefined;
    pollInterval?: number;
    concurrency?: number;
    batchPollingTimeout?: number;
}
interface RunnerArgs {
    worker: ConductorWorker;
    client: Client;
    options: TaskRunnerOptions;
    logger?: ConductorLogger;
    onError?: TaskErrorHandler;
    concurrency?: number;
    maxRetries?: number;
    eventListeners?: TaskRunnerEventsListener[];
}
interface PollerOptions {
    pollInterval?: number;
    concurrency: number;
    warnAtO?: number;
    /** Enable adaptive backoff for empty polls (default: true) */
    adaptiveBackoff?: boolean;
    /** Whether this poller is paused (default: false) */
    paused?: boolean;
}
/**
 * Configuration for health monitoring of worker processes.
 */
interface HealthMonitorConfig {
    /** Interval between health checks in ms (default: 5000) */
    healthCheckIntervalMs?: number;
    /** Maximum restart attempts, 0 = unlimited (default: 0) */
    maxRestartAttempts?: number;
    /** Whether health monitoring is enabled (default: true) */
    enabled?: boolean;
}
type TaskManagerOptions = TaskRunnerOptions;
interface TaskManagerConfig {
    logger?: ConductorLogger;
    options?: Partial<TaskManagerOptions>;
    onError?: TaskErrorHandler;
    maxRetries?: number;
    eventListeners?: TaskRunnerEventsListener[];
}

/**
 * Responsible for initializing and managing the runners that poll and work different task queues.
 */
declare class TaskManager {
    private workerRunners;
    private readonly client;
    private readonly logger;
    private readonly errorHandler;
    private workers;
    readonly options: Required<TaskManagerOptions>;
    private polling;
    private maxRetries;
    private eventListeners;
    constructor(client: Client, workers: ConductorWorker[], config?: TaskManagerConfig);
    private workerManagerWorkerOptions;
    get isPolling(): boolean;
    updatePollingOptionForWorker: (workerTaskDefName: string, options: Partial<TaskManagerOptions>) => void;
    /**
     * new options will get merged to existing options
     * @param options new options to update polling options
     */
    updatePollingOptions: (options: Partial<TaskManagerOptions>) => void;
    sanityCheck: () => void;
    /**
     * Start polling for tasks
     */
    startPolling: () => void;
    /**
     * Stops polling for tasks
     */
    stopPolling: () => Promise<void>;
}

/**
 * Responsible for polling and executing tasks from a queue.
 *
 * Because a `poll` in conductor "pops" a task off of a conductor queue,
 * each runner participates in the poll -> work -> update loop.
 * We could potentially split this work into a separate "poller" and "worker" pools
 * but that could lead to picking up more work than the pool of workers are actually able to handle.
 *
 */
declare class TaskRunner {
    _client: Client;
    worker: ConductorWorker;
    private logger;
    private options;
    errorHandler: TaskErrorHandler;
    private poller;
    private maxRetries;
    private eventDispatcher;
    constructor({ worker, client, options, logger, onError: errorHandler, maxRetries, eventListeners, }: RunnerArgs);
    get isPolling(): boolean;
    /**
     * Starts polling for work
     */
    startPolling: () => void;
    /**
     * Stops Polling for work
     */
    stopPolling: () => Promise<void>;
    updateOptions(options: Partial<TaskRunnerOptions>): void;
    /** Pause or unpause the worker's polling */
    setPaused(paused: boolean): void;
    get isPaused(): boolean;
    get getOptions(): TaskRunnerOptions;
    private batchPoll;
    /**
     * Probed once per process. null = unknown, true = v2 endpoint available,
     * false = legacy server (no /api/tasks/update-v2 endpoint).
     */
    private static updateV2Available;
    updateTaskWithRetry: (task: Task, taskResult: TaskResult) => Promise<Task | undefined>;
    private isValidTask;
    /**
     * Entry point for task execution with V2 chaining.
     *
     * When updateTaskV2 returns a next task in its response, we immediately
     * execute it without going back through the poll cycle. This eliminates
     * one HTTP round-trip + sleep per task when there is a backlog.
     */
    private executeTask;
    /**
     * Execute a single task and return the next task from V2 response (if any).
     */
    private executeOneTask;
    handleUnknownError: (unknownError: unknown) => void;
}

declare class Poller<T> {
    private timeoutHandler?;
    private pollFunction;
    private performWorkFunction;
    private polling;
    private _tasksInProcess;
    private _counterAtO;
    private _pollerId;
    private _consecutiveEmptyPolls;
    private _lastPollTime;
    private _authFailures;
    private _lastAuthFailureAt;
    options: PollerOptions;
    logger: ConductorLogger;
    constructor(pollerId: string, pollFunction: (count: number) => Promise<T[] | undefined>, performWorkFunction: (work: T) => Promise<void>, pollerOptions?: Partial<PollerOptions>, logger?: ConductorLogger);
    get isPolling(): boolean;
    get tasksInProcess(): number;
    get consecutiveEmptyPolls(): number;
    get authFailures(): number;
    /**
     * Starts polling for work
     */
    startPolling: () => void;
    /**
     * Stops Polling for work
     */
    stopPolling: () => Promise<void>;
    private performWork;
    updateOptions(options: Partial<PollerOptions>): void;
    /**
     * Detect if an error is an authentication/authorization failure.
     */
    private isAuthError;
    /**
     * Calculate adaptive backoff delay for empty polls.
     *
     * Matches Python SDK: min(BASE_MS * 2^min(count, MAX_EXPONENT), pollInterval)
     * Sequence: 1ms, 2ms, 4ms, 8ms, 16ms, ... 1024ms, then capped at pollInterval
     */
    private calculateAdaptiveDelay;
    /**
     * Calculate auth failure backoff delay in milliseconds.
     *
     * Matches Python SDK: min(2^failures, 60) seconds
     */
    private calculateAuthBackoffMs;
    /** Promise-based sleep that resolves immediately if polling has stopped */
    private sleep;
    private poll;
}

/**
 * Custom exception types for worker error handling.
 */
/**
 * Exception indicating a non-retryable task failure.
 *
 * When thrown from a worker's execute function, the task will be marked as
 * FAILED_WITH_TERMINAL_ERROR and will NOT be retried, regardless of the
 * task definition's retry_count setting.
 *
 * Use this for permanent failures where retry would produce the same result:
 * - Business validation failures (invalid data format)
 * - Authorization failures (user lacks permission)
 * - Resource not found (entity doesn't exist)
 * - Configuration errors (missing required config)
 * - Data integrity violations (constraint violations)
 * - Unsupported operations (feature not available)
 *
 * @example
 * ```typescript
 * async function validateOrder(task: Task) {
 *   const order = await getOrder(task.inputData.orderId);
 *
 *   if (!order) {
 *     // Order doesn't exist - retry won't help
 *     throw new NonRetryableException(`Order ${task.inputData.orderId} not found`);
 *   }
 *
 *   if (order.status === 'CANCELLED') {
 *     // Business rule - retry won't help
 *     throw new NonRetryableException('Cannot process cancelled order');
 *   }
 *
 *   return { status: 'COMPLETED', outputData: { validated: true } };
 * }
 * ```
 */
declare class NonRetryableException extends Error {
    constructor(message: string);
}

declare const doWhileTask: (taskRefName: string, terminationCondition: string, tasks: TaskDefTypes[], optional?: boolean) => DoWhileTaskDef;
declare const newLoopTask: (taskRefName: string, iterations: number, tasks: TaskDefTypes[], optional?: boolean) => DoWhileTaskDef;

declare const dynamicTask: (taskReferenceName: string, dynamicTaskName: string, dynamicTaskParam?: string, optional?: boolean) => WorkflowTask;

declare const dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string, optional?: boolean) => ForkJoinDynamicDef;

declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string, optional?: boolean) => EventTaskDef;
declare const sqsEventTask: (taskReferenceName: string, queueName: string, optional?: boolean) => EventTaskDef;
declare const conductorEventTask: (taskReferenceName: string, eventName: string, optional?: boolean) => EventTaskDef;

declare const forkTask: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => ForkJoinTaskDef;
declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[], optional?: boolean) => [ForkJoinTaskDef, JoinTaskDef];

interface GetDocumentOptions {
    /** Media type of the document (e.g. "application/pdf") */
    mediaType?: string;
    optional?: boolean;
}
declare const getDocumentTask: (taskReferenceName: string, url: string, options?: GetDocumentOptions) => WorkflowTask;

declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters, asyncComplete?: boolean, optional?: boolean) => HttpTaskDef;

interface HttpPollInputParameters {
    http_request: HttpInputParameters;
    /** Polling interval in seconds */
    pollingInterval?: number;
    /** Polling strategy: FIXED or LINEAR_BACKOFF */
    pollingStrategy?: "FIXED" | "LINEAR_BACKOFF";
    /** Condition expression to terminate polling (e.g. "$.status === 'COMPLETED'") */
    terminationCondition?: string;
}
declare const httpPollTask: (taskReferenceName: string, inputParameters: HttpPollInputParameters, optional?: boolean) => WorkflowTask;

type AssignmentCompletionStrategy = "LEAVE_OPEN" | "TERMINATE";
interface HumanTaskOptions {
    displayName?: string;
    formTemplate?: string;
    formVersion?: number;
    assignmentCompletionStrategy?: AssignmentCompletionStrategy;
    assignee?: {
        userType: "EXTERNAL_USER" | "EXTERNAL_GROUP";
        user: string;
    };
    optional?: boolean;
}
declare const humanTask: (taskReferenceName: string, options?: HumanTaskOptions) => WorkflowTask;

declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs", optional?: boolean) => InlineTaskDef;

declare const joinTask: (taskReferenceName: string, joinOn: string[], optional?: boolean) => JoinTaskDef;

declare const jsonJqTask: (taskReferenceName: string, script: string, optional?: boolean) => JsonJQTransformTaskDef;

declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters, optional?: boolean) => KafkaPublishTaskDef;

declare const setVariableTask: (taskReferenceName: string, inputParameters: Record<string, unknown>, optional?: boolean) => SetVariableTaskDef;

declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>, optional?: boolean) => SimpleTaskDef;

declare const startWorkflowTask: (taskReferenceName: string, workflowName: string, input?: Record<string, unknown>, version?: number, correlationId?: string, optional?: boolean) => WorkflowTask;

declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number, optional?: boolean) => SubWorkflowTaskDef;

declare const switchTask: (taskReferenceName: string, expression: string, decisionCases?: Record<string, TaskDefTypes[]>, defaultCase?: TaskDefTypes[], optional?: boolean) => SwitchTaskDef;

declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string) => TerminateTaskDef;

declare const waitTaskDuration: (taskReferenceName: string, duration: string, optional?: boolean) => WaitTaskDef;
declare const waitTaskUntil: (taskReferenceName: string, until: string, optional?: boolean) => WaitTaskDef;

interface WaitForWebhookOptions {
    /** Match conditions for incoming webhook (key-value pairs) */
    matches?: Record<string, unknown>;
    optional?: boolean;
}
declare const waitForWebhookTask: (taskReferenceName: string, options?: WaitForWebhookOptions) => WorkflowTask;

declare enum Role {
    USER = "user",
    ASSISTANT = "assistant",
    SYSTEM = "system",
    TOOL_CALL = "tool_call",
    TOOL = "tool"
}
/** LLM provider identifiers matching the Python SDK's LLMProvider enum. */
declare enum LLMProvider {
    OPEN_AI = "openai",
    AZURE_OPEN_AI = "azure_openai",
    VERTEX_AI = "vertex_ai",
    HUGGING_FACE = "huggingface",
    ANTHROPIC = "anthropic",
    BEDROCK = "bedrock",
    COHERE = "cohere",
    GROK = "Grok",
    MISTRAL = "mistral",
    OLLAMA = "ollama",
    PERPLEXITY = "perplexity"
}
/** Vector database identifiers matching the Python SDK's VectorDB enum. */
declare enum VectorDB {
    PINECONE_DB = "pineconedb",
    WEAVIATE_DB = "weaviatedb",
    POSTGRES_VECTOR_DB = "pgvectordb",
    MONGO_VECTOR_DB = "mongovectordb"
}
interface ToolCall {
    name: string;
    taskReferenceName?: string;
    type?: string;
    inputParameters?: Record<string, unknown>;
    output?: Record<string, unknown>;
}
interface ChatMessage {
    role: Role;
    message: string;
    media?: string[];
    mimeType?: string;
    toolCalls?: ToolCall[];
}
interface ToolSpec {
    name: string;
    type?: string;
    description?: string;
    inputSchema?: Record<string, unknown>;
    outputSchema?: Record<string, unknown>;
}
interface EmbeddingModel {
    provider: string;
    model: string;
}
interface LlmCompletionParams {
    temperature?: number;
    topP?: number;
    topK?: number;
    maxTokens?: number;
    frequencyPenalty?: number;
    presencePenalty?: number;
    stopWords?: string[];
    maxResults?: number;
}
/** Base configuration for AI integrations. */
interface IntegrationConfig {
    provider: string;
    description?: string;
    [key: string]: unknown;
}
/** OpenAI integration configuration. */
interface OpenAIConfig extends IntegrationConfig {
    provider: "openai";
    apiKey: string;
    organizationId?: string;
}
/** Azure OpenAI integration configuration. */
interface AzureOpenAIConfig extends IntegrationConfig {
    provider: "azure_openai";
    apiKey: string;
    endpoint: string;
    deploymentName?: string;
}
/** Weaviate vector database configuration. */
interface WeaviateConfig extends IntegrationConfig {
    provider: "weaviatedb";
    apiKey: string;
    endpoint: string;
}
/** Pinecone vector database configuration. */
interface PineconeConfig extends IntegrationConfig {
    provider: "pineconedb";
    apiKey: string;
    environment?: string;
    projectName?: string;
}

interface LlmChatCompleteOptions extends LlmCompletionParams {
    messages?: ChatMessage[];
    instructionsTemplate?: string;
    promptVariables?: Record<string, unknown>;
    promptVersion?: number;
    userInput?: string;
    tools?: ToolSpec[];
    jsonOutput?: boolean;
    outputSchema?: Record<string, unknown>;
    outputMimeType?: string;
    outputLocation?: string;
    googleSearchRetrieval?: boolean;
    inputSchema?: Record<string, unknown>;
    thinkingTokenLimit?: number;
    reasoningEffort?: string;
    voice?: string;
    participants?: string[];
}
declare const llmChatCompleteTask: (taskReferenceName: string, provider: string, model: string, options?: LlmChatCompleteOptions) => WorkflowTask;

interface LlmTextCompleteOptions extends LlmCompletionParams {
    promptVariables?: Record<string, unknown>;
    promptVersion?: number;
    jsonOutput?: boolean;
}
declare const llmTextCompleteTask: (taskReferenceName: string, provider: string, model: string, promptName: string, options?: LlmTextCompleteOptions) => WorkflowTask;

interface LlmGenerateEmbeddingsOptions {
    instructions?: string;
    dimensions?: number;
}
declare const llmGenerateEmbeddingsTask: (taskReferenceName: string, provider: string, model: string, text: string, options?: LlmGenerateEmbeddingsOptions) => WorkflowTask;

interface LlmIndexTextOptions {
    namespace?: string;
    metadata?: Record<string, unknown>;
    url?: string;
    chunkSize?: number;
    chunkOverlap?: number;
    dimensions?: number;
}
declare const llmIndexTextTask: (taskReferenceName: string, vectorDb: string, index: string, embeddingModel: EmbeddingModel, text: string, docId: string, options?: LlmIndexTextOptions) => WorkflowTask;

interface LlmIndexDocumentOptions {
    namespace?: string;
    chunkSize?: number;
    chunkOverlap?: number;
    docId?: string;
    metadata?: Record<string, unknown>;
    dimensions?: number;
}
declare const llmIndexDocumentTask: (taskReferenceName: string, vectorDb: string, index: string, embeddingModel: EmbeddingModel, url: string, mediaType: string, options?: LlmIndexDocumentOptions) => WorkflowTask;

interface LlmSearchIndexOptions {
    namespace?: string;
    maxResults?: number;
    dimensions?: number;
}
declare const llmSearchIndexTask: (taskReferenceName: string, vectorDb: string, index: string, embeddingModel: EmbeddingModel, query: string, options?: LlmSearchIndexOptions) => WorkflowTask;

interface LlmSearchEmbeddingsOptions {
    namespace?: string;
    maxResults?: number;
}
declare const llmSearchEmbeddingsTask: (taskReferenceName: string, vectorDb: string, index: string, embeddings: number[], options?: LlmSearchEmbeddingsOptions) => WorkflowTask;

interface LlmStoreEmbeddingsOptions {
    namespace?: string;
    docId?: string;
    metadata?: Record<string, unknown>;
}
declare const llmStoreEmbeddingsTask: (taskReferenceName: string, vectorDb: string, index: string, embeddings: number[], options?: LlmStoreEmbeddingsOptions) => WorkflowTask;

interface LlmQueryEmbeddingsOptions {
    namespace?: string;
}
declare const llmQueryEmbeddingsTask: (taskReferenceName: string, vectorDb: string, index: string, embeddings: number[], options?: LlmQueryEmbeddingsOptions) => WorkflowTask;

interface GenerateImageOptions {
    imageCount?: number;
    width?: number;
    height?: number;
}
declare const generateImageTask: (taskReferenceName: string, provider: string, model: string, prompt: string, options?: GenerateImageOptions) => WorkflowTask;

interface GenerateAudioOptions {
    text?: string;
    voice?: string;
    speed?: number;
}
declare const generateAudioTask: (taskReferenceName: string, provider: string, model: string, options?: GenerateAudioOptions) => WorkflowTask;

interface CallMcpToolOptions {
    inputParameters?: Record<string, unknown>;
}
declare const callMcpToolTask: (taskReferenceName: string, mcpServer: string, method: string, options?: CallMcpToolOptions) => WorkflowTask;

interface ListMcpToolsOptions {
    filter?: string;
}
declare const listMcpToolsTask: (taskReferenceName: string, mcpServer: string, options?: ListMcpToolsOptions) => WorkflowTask;

/**
 * Set a single prompt variable on an LLM task.
 * Returns a new task with the variable applied to inputParameters.promptVariables.
 *
 * @example
 * ```typescript
 * const task = withPromptVariable(
 *   llmChatCompleteTask("ref", "openai", "gpt-4"),
 *   "context",
 *   "${workflow.input.context}"
 * );
 * ```
 */
declare const withPromptVariable: (task: WorkflowTask, variable: string, value: unknown) => WorkflowTask;
/**
 * Set multiple prompt variables on an LLM task at once.
 * Returns a new task with all variables merged into inputParameters.promptVariables.
 *
 * @example
 * ```typescript
 * const task = withPromptVariables(
 *   llmTextCompleteTask("ref", "openai", "gpt-4", "my_prompt"),
 *   {
 *     context: "${workflow.input.context}",
 *     query: "${workflow.input.query}",
 *   }
 * );
 * ```
 */
declare const withPromptVariables: (task: WorkflowTask, variables: Record<string, unknown>) => WorkflowTask;

declare const workflow: (name: string, tasks: TaskDefTypes[]) => WorkflowDef;

declare const taskDefinition: ({ name, ownerApp, description, retryCount, timeoutSeconds, inputKeys, outputKeys, timeoutPolicy, retryLogic, retryDelaySeconds, responseTimeoutSeconds, concurrentExecLimit, inputTemplate, rateLimitPerFrequency, rateLimitFrequencyInSeconds, ownerEmail, pollTimeoutSeconds, backoffScaleFactor, }: ExtendedTaskDef) => TaskDef;

/**
 * Fluent workflow builder matching the Python SDK's ConductorWorkflow pattern.
 *
 * Provides method chaining for building, configuring, registering, and
 * executing workflows.
 *
 * @example
 * ```typescript
 * const wf = new ConductorWorkflow(executor, "order_flow")
 *   .add(simpleTask("validate_ref", "validate_order", {}))
 *   .add(simpleTask("charge_ref", "charge_payment", {}))
 *   .add(simpleTask("confirm_ref", "send_confirmation", {}))
 *   .timeoutSeconds(3600)
 *   .outputParameters({ orderId: "${workflow.input.orderId}" });
 *
 * await wf.register(true);
 * const run = await wf.execute({ orderId: "123" });
 * ```
 */
declare class ConductorWorkflow {
    private readonly _executor;
    private readonly _name;
    private _version;
    private _description?;
    private _tasks;
    private _timeoutPolicy?;
    private _timeoutSeconds;
    private _ownerEmail?;
    private _failureWorkflow;
    private _restartable;
    private _inputParameters;
    private _inputTemplate;
    private _outputParameters;
    private _variables;
    private _workflowStatusListenerEnabled;
    private _workflowStatusListenerSink?;
    private _forkCounter;
    constructor(executor: WorkflowExecutor, name: string, version?: number, description?: string);
    /** Get the workflow name */
    getName(): string;
    /** Get the workflow version */
    getVersion(): number;
    /** Append one or more tasks sequentially */
    add(task: WorkflowTask | WorkflowTask[]): this;
    /** Add parallel fork branches with an auto-generated join */
    fork(branches: WorkflowTask[][]): this;
    /**
     * Convert this workflow into a SUB_WORKFLOW task with the full definition
     * embedded inline, matching Python SDK's `InlineSubWorkflowTask`.
     *
     * This allows composing workflows without pre-registering the child workflow.
     *
     * @param taskReferenceName - Reference name for the sub-workflow task
     */
    toSubWorkflowTask(taskReferenceName: string): WorkflowTask;
    description(desc: string): this;
    version(v: number): this;
    timeoutPolicy(policy: "TIME_OUT_WF" | "ALERT_ONLY"): this;
    timeoutSeconds(n: number): this;
    ownerEmail(email: string): this;
    failureWorkflow(name: string): this;
    restartable(val: boolean): this;
    /** Set the list of input parameter names */
    inputParameters(params: string[]): this;
    /** Set the input template (default values/expressions for inputs) */
    inputTemplate(template: Record<string, unknown>): this;
    /** Alias for inputTemplate — set workflow input defaults */
    workflowInput(input: Record<string, unknown>): this;
    /** Set all output parameters at once */
    outputParameters(params: Record<string, unknown>): this;
    /** Set a single output parameter */
    outputParameter(key: string, value: unknown): this;
    /** Set workflow variables */
    variables(vars: Record<string, unknown>): this;
    /** Enable workflow status listener with a sink name */
    enableStatusListener(sinkName: string): this;
    /** Disable workflow status listener */
    disableStatusListener(): this;
    /** Returns a workflow input reference expression */
    input(jsonPath: string): string;
    /** Returns a workflow output reference expression */
    output(jsonPath?: string): string;
    /** Convert to a WorkflowDef object */
    toWorkflowDef(): WorkflowDef;
    /** Register this workflow with the Conductor server */
    register(overwrite?: boolean): Promise<void>;
    /** Execute the workflow synchronously and wait for result */
    execute(input?: Record<string, unknown>, waitUntilTaskRef?: string, requestId?: string, idempotencyKey?: string, idempotencyStrategy?: "FAIL" | "RETURN_EXISTING" | "FAIL_ON_RUNNING", taskToDomain?: Record<string, string>): Promise<WorkflowRun>;
    /** Start the workflow asynchronously (returns workflow ID) */
    startWorkflow(input?: Record<string, unknown>, correlationId?: string, priority?: number, idempotencyKey?: string, idempotencyStrategy?: "FAIL" | "RETURN_EXISTING" | "FAIL_ON_RUNNING", taskToDomain?: Record<string, string>): Promise<string>;
}

/**
 * Takes an optional partial SimpleTaskDef
 * generates a task replacing default values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateSimpleTask: (overrides?: Partial<SimpleTaskDef>) => SimpleTaskDef;

/**
 * Takes an optional partial EventTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateEventTask: (overrides?: Partial<EventTaskDef>) => EventTaskDef;

type TaskDefTypesGen = SimpleTaskDef | DoWhileTaskDefGen | EventTaskDef | ForkJoinTaskDefGen | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDefGen | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDefGen | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
interface WorkflowDefGen extends Omit<WorkflowDef, "tasks"> {
    tasks: Partial<TaskDefTypesGen>[];
}
type ForkJoinTaskDefGen = Omit<ForkJoinTaskDef, "forkTasks"> & {
    forkTasks: Partial<TaskDefTypesGen>[][];
};
type SwitchTaskDefGen = Omit<SwitchTaskDef, "decisionCases" | "defaultCase"> & {
    decisionCases: Record<string, Partial<TaskDefTypesGen>[]>;
    defaultCase: Partial<TaskDefTypesGen>[];
};
type DoWhileTaskDefGen = Omit<DoWhileTaskDef, "loopOver"> & {
    loopOver: Partial<TaskDefTypesGen>[];
};
interface InlineTaskInputParametersGen extends Omit<InlineTaskInputParameters, "expression"> {
    expression: string | ((...args: never[]) => unknown);
}
interface InlineTaskDefGen extends Omit<InlineTaskDef, "inputParameters"> {
    inputParameters: InlineTaskInputParametersGen;
}
type NestedTaskMapper = (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];

declare const generateJoinTask: (overrides?: Partial<JoinTaskDef>) => JoinTaskDef;

/**
 * Takes an optional partial HttpTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateHTTPTask: (overrides?: Partial<HttpTaskDef>) => HttpTaskDef;

/**
 * Takes an optional partial InlineTaskDefGen
 * generates a task replacing default/fake values with provided overrides
 *
 * <b>note</b> that the inputParameters.expression can be either a string containing javascript
 * or a function thar returns an ES5 function
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateInlineTask: (override?: Partial<InlineTaskDefGen>) => InlineTaskDef;

/**
 * Takes an optional partial JsonJQTransformTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateJQTransformTask: (overrides?: Partial<JsonJQTransformTaskDef>) => JsonJQTransformTaskDef;

/**
 * Takes an optional partial KafkaPublishTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateKafkaPublishTask: (overrides?: Partial<KafkaPublishTaskDef>) => KafkaPublishTaskDef;

/**
 * Takes an optional partial SubWorkflowTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateSubWorkflowTask: (overrides?: Partial<SubWorkflowTaskDef>) => SubWorkflowTaskDef;

/**
 * Takes an optional partial SetVariableTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateSetVariableTask: (overrides?: Partial<SetVariableTaskDef>) => SetVariableTaskDef;

/**
 * Takes an optional partial TerminateTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateTerminateTask: (overrides?: Partial<TerminateTaskDef>) => TerminateTaskDef;

/**
 * Takes an optional partial WaitTaskDef
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generateWaitTask: (overrides?: Partial<WaitTaskDef>) => WaitTaskDef;

declare const taskGenMapper: (tasks: Partial<TaskDefTypesGen>[]) => TaskDefTypes[];
/**
 * Takes an optional partial WorkflowDefGen
 * generates a workflow replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @returns a fully defined task
 */
declare const generate: (overrides: Partial<WorkflowDefGen>) => WorkflowDef;

/**
 * Takes an optional partial SwitchTaskDefGen and an optional nestedMapper
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @param nestedTasksMapper function to run on array of nested tasks
 * @returns a fully defined task
 */
declare const generateSwitchTask: (overrides?: Partial<SwitchTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => SwitchTaskDef;
/**
 * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @param nestedTasksMapper function to run on array of nested tasks
 * @returns a fully defined task
 */
declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nestedTasksMapper?: NestedTaskMapper) => DoWhileTaskDef;
/**
 * Takes an optional partial DoWhileTaskDefGen and an optional nestedMapper
 * generates a task replacing default/fake values with provided overrides
 *
 * @param overrides overrides for defaults
 * @param nestedTasksMapper function to run on array of nested tasks
 * @returns a fully defined task
 */
declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;

/**
 * Configuration for TaskHandler.
 */
interface TaskHandlerConfig {
    /**
     * Conductor client instance.
     * Required for communicating with Conductor server.
     */
    client: Client;
    /**
     * Additional workers to register manually.
     * These will be added alongside auto-discovered decorated workers.
     * Default: []
     */
    workers?: ConductorWorker[];
    /**
     * Whether to scan for @worker decorated functions.
     * When true, automatically discovers all workers registered via @worker decorator.
     * Default: true
     */
    scanForDecorated?: boolean;
    /**
     * Modules to import for side-effect registration.
     * Importing these modules will trigger @worker decorator execution.
     * Useful when workers are defined in separate files.
     *
     * Example: ['./workers/orderWorkers', './workers/paymentWorkers']
     * Default: []
     */
    importModules?: string[];
    /**
     * Event listeners for worker lifecycle events.
     * Default: []
     */
    eventListeners?: TaskRunnerEventsListener[];
    /**
     * Logger instance for TaskHandler.
     * Default: DefaultLogger
     */
    logger?: ConductorLogger;
    /**
     * Health monitoring configuration.
     * Monitors worker polling loops and auto-restarts on failure.
     * Default: { enabled: true }
     */
    healthMonitor?: HealthMonitorConfig;
}
/**
 * TaskHandler orchestrates worker lifecycle and auto-discovery.
 *
 * This is the main entry point for the SDK-style worker framework,
 * matching the Python SDK's TaskHandler architecture.
 *
 * Features:
 * - Auto-discovers workers decorated with @worker
 * - Manages worker lifecycle (start/stop)
 * - Supports both decorated and manual worker registration
 * - Module import for side-effect registration
 * - Event listener support
 * - Health monitoring with auto-restart
 * - Automatic task definition registration
 * - Environment variable configuration override
 *
 * @example
 * Basic usage with auto-discovery:
 * ```typescript
 * const handler = new TaskHandler({
 *   client: conductorClient,
 *   scanForDecorated: true,
 * });
 *
 * await handler.startWorkers();
 *
 * // Later...
 * await handler.stopWorkers();
 * ```
 *
 * @example
 * With event listeners and health monitoring:
 * ```typescript
 * const handler = new TaskHandler({
 *   client: conductorClient,
 *   eventListeners: [metricsCollector],
 *   healthMonitor: {
 *     enabled: true,
 *     healthCheckIntervalMs: 5000,
 *     maxRestartAttempts: 10,
 *   },
 * });
 *
 * await handler.startWorkers();
 * handler.printSummary();
 * ```
 */
declare class TaskHandler {
    private client;
    private resolvedWorkers;
    private taskRunners;
    private config;
    private logger;
    private isRunning;
    private healthCheckTimer?;
    private restartAttempts;
    private healthMonitorConfig;
    /**
     * Create a TaskHandler instance with async module imports.
     * Use this instead of `new TaskHandler()` when using `importModules`.
     */
    static create(config: TaskHandlerConfig): Promise<TaskHandler>;
    constructor(config: TaskHandlerConfig);
    /**
     * Start all registered workers.
     *
     * Registers task definitions (if configured), creates a TaskRunner for each
     * worker, and begins polling for tasks.
     * This method is idempotent - calling it multiple times has no effect.
     */
    startWorkers(): Promise<void>;
    /**
     * Stop all running workers gracefully.
     *
     * Stops polling and waits for in-flight tasks to complete.
     * This method is idempotent - calling it multiple times has no effect.
     */
    stopWorkers(): Promise<void>;
    /**
     * Register task definitions for workers that have registerTaskDef=true.
     * Called automatically by startWorkers() before polling begins.
     *
     * Matches Python SDK behavior:
     * - If overwriteTaskDef=true: PUT /api/metadata/taskdefs (create or update)
     * - If overwriteTaskDef=false: GET first, then POST only if not found
     * - Uses taskDef template if provided, otherwise creates minimal definition
     */
    private registerTaskDefinitions;
    private startHealthMonitor;
    private stopHealthMonitor;
    private checkWorkerHealth;
    /**
     * Print a summary of all registered workers and their configurations.
     * Matches Python SDK's print_summary() function.
     */
    printSummary(): void;
    /**
     * Check if all workers are healthy (all polling).
     * Returns false if any worker has stopped unexpectedly.
     */
    isHealthy(): boolean;
    /**
     * Get detailed status of each worker.
     * Matches Python SDK's get_worker_process_status().
     */
    getWorkerStatus(): {
        taskDefName: string;
        domain?: string;
        polling: boolean;
        paused: boolean;
        workerId: string;
        restartCount: number;
    }[];
    /** Get the number of registered workers. */
    get workerCount(): number;
    /** Get the number of running workers. */
    get runningWorkerCount(): number;
    /** Check if workers are currently running. */
    get running(): boolean;
    /**
     * Context manager support (for TypeScript 5.2+ using keyword).
     * Automatically stops workers when disposed.
     */
    [Symbol.asyncDispose](): Promise<void>;
}

/**
 * Options for the @worker decorator.
 */
interface WorkerOptions {
    /**
     * Task definition name (must match workflow task name).
     * This is the only required parameter.
     */
    taskDefName: string;
    /**
     * Maximum concurrent tasks this worker can execute.
     * - Default: 1
     * - Controls concurrency level for task execution
     * - Choose based on workload:
     *   * CPU-bound: 1-4
     *   * I/O-bound: 10-50
     *   * Mixed: 5-20
     */
    concurrency?: number;
    /**
     * Polling interval in milliseconds.
     * - Default: 100ms
     * - Lower values = more responsive but higher server load
     * - Higher values = less server load but slower task pickup
     * - Recommended: 100-500ms for most use cases
     */
    pollInterval?: number;
    /**
     * Task domain for multi-tenancy.
     * - Default: undefined (no domain isolation)
     * - Use when you need to partition tasks across different environments/tenants
     */
    domain?: string;
    /**
     * Unique worker identifier.
     * - Default: undefined (auto-generated)
     * - Useful for debugging and tracking which worker executed which task
     */
    workerId?: string;
    /**
     * Auto-register task definition on startup.
     * - Default: false
     * - When true: Task definition is created/updated on worker startup
     * - When false: Task definition must exist in Conductor already
     * - Recommended: false for production (manage task definitions separately)
     */
    registerTaskDef?: boolean;
    /**
     * Server-side long poll timeout in milliseconds.
     * - Default: 100ms
     * - How long the server will wait for a task before returning empty response
     * - Higher values reduce polling frequency when no tasks available
     * - Recommended: 100-500ms
     */
    pollTimeout?: number;
    /**
     * Task definition template for registration.
     * - Default: undefined
     * - Only used when registerTaskDef=true
     * - Allows specifying retry policies, timeouts, rate limits, etc.
     * - The taskDefName parameter takes precedence for the name field
     */
    taskDef?: TaskDef;
    /**
     * Overwrite existing task definitions on server.
     * - Default: true
     * - When true: Always updates task definition
     * - When false: Only creates if doesn't exist
     * - Can be overridden via env: CONDUCTOR_WORKER_<NAME>_OVERWRITE_TASK_DEF=false
     */
    overwriteTaskDef?: boolean;
    /**
     * Enforce strict JSON schema validation.
     * - Default: false
     * - When false: additionalProperties=true (allows extra fields)
     * - When true: additionalProperties=false (strict validation)
     * - Can be overridden via env: CONDUCTOR_WORKER_<NAME>_STRICT_SCHEMA=true
     */
    strictSchema?: boolean;
    /**
     * JSON Schema for task input validation.
     * - Registered alongside the task definition when registerTaskDef=true
     * - Use the `jsonSchema()` helper to generate from field descriptors
     */
    inputSchema?: Record<string, unknown>;
    /**
     * JSON Schema for task output validation.
     * - Registered alongside the task definition when registerTaskDef=true
     * - Use the `jsonSchema()` helper to generate from field descriptors
     */
    outputSchema?: Record<string, unknown>;
    /**
     * Class decorated with `@schemaField()` for auto-generating input schema.
     * - Alternative to `inputSchema` — schema is generated from class metadata
     * - Takes precedence over `inputSchema` if both are set
     */
    inputType?: new (...args: any[]) => unknown;
    /**
     * Class decorated with `@schemaField()` for auto-generating output schema.
     * - Alternative to `outputSchema` — schema is generated from class metadata
     * - Takes precedence over `outputSchema` if both are set
     */
    outputType?: new (...args: any[]) => unknown;
}
/**
 * Decorator to register a function as a Conductor worker.
 *
 * This decorator enables SDK-style worker registration with auto-discovery,
 * matching the Python SDK's @worker_task pattern.
 *
 * @param options - Worker configuration options
 *
 * @example
 * Basic usage:
 * ```typescript
 * @worker({ taskDefName: "process_order" })
 * async function processOrder(task: Task): Promise<TaskResult> {
 *   const orderId = task.inputData.orderId;
 *   // Process order logic
 *   return {
 *     status: "COMPLETED",
 *     outputData: { orderId, processed: true },
 *   };
 * }
 * ```
 *
 * @example
 * With concurrency:
 * ```typescript
 * @worker({ taskDefName: "send_email", concurrency: 10 })
 * async function sendEmail(task: Task): Promise<TaskResult> {
 *   const { to, subject, body } = task.inputData;
 *   await emailService.send(to, subject, body);
 *   return { status: "COMPLETED", outputData: { sent: true } };
 * }
 * ```
 *
 * @example
 * With domain and custom polling:
 * ```typescript
 * @worker({
 *   taskDefName: "validate_payment",
 *   domain: "payments",
 *   concurrency: 5,
 *   pollInterval: 200,
 * })
 * async function validatePayment(task: Task): Promise<TaskResult> {
 *   // Validation logic
 *   return { status: "COMPLETED", outputData: { valid: true } };
 * }
 * ```
 *
 * @example
 * With task definition registration:
 * ```typescript
 * @worker({
 *   taskDefName: "complex_task",
 *   registerTaskDef: true,
 *   taskDef: {
 *     retryCount: 3,
 *     retryLogic: "EXPONENTIAL_BACKOFF",
 *     timeoutSeconds: 300,
 *   },
 * })
 * async function complexTask(task: Task): Promise<TaskResult> {
 *   // Complex logic
 *   return { status: "COMPLETED", outputData: { result: "..." } };
 * }
 * ```
 *
 * @example
 * Non-retryable errors:
 * ```typescript
 * import { worker, NonRetryableException } from "@io-orkes/conductor-javascript/worker";
 *
 * @worker({ taskDefName: "validate_order" })
 * async function validateOrder(task: Task): Promise<TaskResult> {
 *   const order = await getOrder(task.inputData.orderId);
 *
 *   if (!order) {
 *     // Order doesn't exist - retry won't help
 *     throw new NonRetryableException(`Order ${task.inputData.orderId} not found`);
 *   }
 *
 *   return { status: "COMPLETED", outputData: { validated: true } };
 * }
 * ```
 */
/** Minimal context shape for Stage 3 method decorators (TypeScript 5.0+). */
interface MethodDecoratorContext {
    kind: string;
    name: string | symbol;
}
type WorkerMethod = (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId">>;
declare function worker(options: WorkerOptions): {
    <T extends WorkerMethod>(value: T, context: MethodDecoratorContext): T | undefined;
    (target: object, propertyKey?: string, descriptor?: PropertyDescriptor): PropertyDescriptor | WorkerMethod | undefined;
};

/**
 * Registered worker metadata stored in the global registry.
 */
interface RegisteredWorker {
    /** Task definition name (must match workflow task name) */
    taskDefName: string;
    /** Worker execution function */
    executeFunction: (task: Task) => Promise<Omit<TaskResult, "workflowInstanceId" | "taskId">>;
    /** Maximum concurrent tasks (default: 1) */
    concurrency?: number;
    /** Polling interval in milliseconds (default: 100) */
    pollInterval?: number;
    /** Task domain for multi-tenancy (default: undefined) */
    domain?: string;
    /** Unique worker identifier (default: auto-generated) */
    workerId?: string;
    /** Auto-register task definition on startup (default: false) */
    registerTaskDef?: boolean;
    /** Server-side long poll timeout in milliseconds (default: 100) */
    pollTimeout?: number;
    /** Task definition template for registration (optional) */
    taskDef?: TaskDef;
    /** Overwrite existing task definitions (default: true) */
    overwriteTaskDef?: boolean;
    /** Enforce strict JSON schema validation (default: false) */
    strictSchema?: boolean;
    /** JSON Schema for task input validation (registered alongside task def) */
    inputSchema?: Record<string, unknown>;
    /** JSON Schema for task output validation (registered alongside task def) */
    outputSchema?: Record<string, unknown>;
    /** Whether this worker should start in paused state (default: false) */
    paused?: boolean;
}
/**
 * Get all registered workers from the global registry.
 * Used by TaskHandler for auto-discovery.
 *
 * @returns Array of all registered workers
 */
declare function getRegisteredWorkers(): RegisteredWorker[];
/**
 * Get a specific registered worker.
 *
 * @param taskDefName - Task definition name
 * @param domain - Optional domain
 * @returns Registered worker or undefined
 */
declare function getRegisteredWorker(taskDefName: string, domain?: string): RegisteredWorker | undefined;
/**
 * Clear all registered workers.
 * Primarily for testing purposes.
 */
declare function clearWorkerRegistry(): void;
/**
 * Get the number of registered workers.
 */
declare function getWorkerCount(): number;

/**
 * TaskContext provides async-local context during task execution.
 *
 * This is the JavaScript equivalent of Python's contextvars-based
 * `get_task_context()`. Each task execution runs in its own async context,
 * so `getTaskContext()` returns the context for the currently executing task.
 *
 * @example
 * ```typescript
 * @worker({ taskDefName: "my_task" })
 * async function myTask(task: Task) {
 *   const ctx = getTaskContext();
 *   ctx?.addLog("Starting processing");
 *
 *   if (needsMoreTime) {
 *     ctx?.setCallbackAfter(30);
 *     return { status: "IN_PROGRESS", callbackAfterSeconds: 30 };
 *   }
 *
 *   return { status: "COMPLETED", outputData: { result: "done" } };
 * }
 * ```
 */
declare class TaskContext {
    private _task;
    private _logs;
    private _callbackAfterSeconds?;
    private _output?;
    constructor(task: Task);
    /** Get the task ID */
    getTaskId(): string | undefined;
    /** Get the workflow instance ID */
    getWorkflowInstanceId(): string | undefined;
    /** Get the retry count for this task (0 for first attempt) */
    getRetryCount(): number;
    /** Get the poll count for this task */
    getPollCount(): number;
    /** Get the full task input data */
    getInput(): Record<string, unknown>;
    /** Get the task definition name */
    getTaskDefName(): string | undefined;
    /** Get the workflow task type (e.g., SIMPLE, HTTP, SUB_WORKFLOW) */
    getWorkflowTaskType(): string | undefined;
    /** Get the full task object */
    getTask(): Task;
    /**
     * Add an execution log entry.
     * Logs are merged into the task result when execution completes.
     */
    addLog(message: string): void;
    /** Get all accumulated logs */
    getLogs(): TaskExecLog[];
    /**
     * Set callback-after seconds.
     * Tells Conductor to re-queue the task after the specified number of seconds.
     */
    setCallbackAfter(seconds: number): void;
    /** Get the callback-after value (if set) */
    getCallbackAfterSeconds(): number | undefined;
    /**
     * Set intermediate output data.
     * Merged into the final task result.
     */
    setOutput(data: Record<string, unknown>): void;
    /** Get intermediate output data (if set) */
    getOutput(): Record<string, unknown> | undefined;
}
/**
 * Get the current task context.
 *
 * Must be called from within a task execution callback.
 * Returns `undefined` if called outside of a task execution.
 */
declare function getTaskContext(): TaskContext | undefined;

/**
 * Configuration for MetricsCollector.
 */
interface MetricsCollectorConfig {
    /** Prometheus metric name prefix (default: "conductor_worker") */
    prefix?: string;
    /** If set, auto-starts MetricsServer on this port */
    httpPort?: number;
    /** If set, periodically writes Prometheus metrics to this file path */
    filePath?: string;
    /** File write interval in milliseconds (default: 5000) */
    fileWriteIntervalMs?: number;
    /** Sliding window size for quantile calculations (default: 1000) */
    slidingWindowSize?: number;
    /**
     * Use prom-client for native Prometheus integration.
     * Requires `prom-client` to be installed (`npm install prom-client`).
     * When enabled, metrics are registered in prom-client's default registry
     * and `toPrometheusText()` delegates to `prom-client.register.metrics()`.
     * Falls back to custom text format if prom-client is not installed.
     */
    usePromClient?: boolean;
}
/**
 * Collected worker metrics.
 */
interface WorkerMetrics {
    /** Total polls by taskType */
    pollTotal: Map<string, number>;
    /** Poll errors by taskType */
    pollErrorTotal: Map<string, number>;
    /** Task executions completed by taskType */
    taskExecutionTotal: Map<string, number>;
    /** Task execution errors by "taskType:exceptionName" */
    taskExecutionErrorTotal: Map<string, number>;
    /** Task update failures by taskType */
    taskUpdateFailureTotal: Map<string, number>;
    /** Task ack errors by taskType */
    taskAckErrorTotal: Map<string, number>;
    /** Task execution queue full by taskType */
    taskExecutionQueueFullTotal: Map<string, number>;
    /** Thread/process uncaught exceptions (global counter) */
    uncaughtExceptionTotal: number;
    /** Worker restart count (global counter) */
    workerRestartTotal: number;
    /** Task paused count by taskType */
    taskPausedTotal: Map<string, number>;
    /** Workflow start errors */
    workflowStartErrorTotal: number;
    /** External payload used count by type (workflow_input/task_output) */
    externalPayloadUsedTotal: Map<string, number>;
    /** Poll duration observations in ms by taskType */
    pollDurationMs: Map<string, number[]>;
    /** Execution duration observations in ms by taskType */
    executionDurationMs: Map<string, number[]>;
    /** Update duration observations in ms by taskType */
    updateDurationMs: Map<string, number[]>;
    /** Output size observations in bytes by taskType */
    outputSizeBytes: Map<string, number[]>;
    /** Workflow input size observations in bytes */
    workflowInputSizeBytes: Map<string, number[]>;
    /** API request duration observations in ms by "method:uri:status" */
    apiRequestDurationMs: Map<string, number[]>;
}
/**
 * Built-in metrics collector implementing TaskRunnerEventsListener.
 *
 * Collects 19 metric types matching the Python SDK's MetricsCollector,
 * with sliding-window quantile support (p50, p75, p90, p95, p99).
 *
 * @example
 * ```typescript
 * const metrics = new MetricsCollector({ httpPort: 9090 });
 *
 * const handler = new TaskHandler({
 *   client,
 *   eventListeners: [metrics],
 * });
 *
 * await handler.startWorkers();
 * // GET http://localhost:9090/metrics  — Prometheus format
 * // GET http://localhost:9090/health   — {"status":"UP"}
 * ```
 */
declare class MetricsCollector implements TaskRunnerEventsListener {
    private metrics;
    private readonly _prefix;
    private readonly _slidingWindowSize;
    private _server?;
    private _fileTimer?;
    private _promRegistry?;
    constructor(config?: MetricsCollectorConfig);
    private initPromClient;
    private startServer;
    private startFileWriter;
    private createEmptyMetrics;
    private increment;
    private observe;
    private incrementCounter;
    private observeSummary;
    onPollStarted(event: PollStarted): void;
    onPollCompleted(event: PollCompleted): void;
    onPollFailure(event: PollFailure): void;
    onTaskExecutionStarted(_event: TaskExecutionStarted): void;
    onTaskExecutionCompleted(event: TaskExecutionCompleted): void;
    onTaskExecutionFailure(event: TaskExecutionFailure): void;
    onTaskUpdateCompleted(event: TaskUpdateCompleted): void;
    onTaskUpdateFailure(event: TaskUpdateFailure): void;
    /** Record a task execution queue full event */
    recordTaskExecutionQueueFull(taskType: string): void;
    /** Record an uncaught exception */
    recordUncaughtException(): void;
    /** Record a worker restart */
    recordWorkerRestart(): void;
    /** Record a task paused event */
    recordTaskPaused(taskType: string): void;
    /** Record a task ack error */
    recordTaskAckError(taskType: string): void;
    /** Record a workflow start error */
    recordWorkflowStartError(): void;
    /** Record external payload usage */
    recordExternalPayloadUsed(payloadType: string): void;
    /** Record workflow input size */
    recordWorkflowInputSize(workflowType: string, sizeBytes: number): void;
    /** Record API request duration */
    recordApiRequestTime(method: string, uri: string, status: number, durationMs: number): void;
    /** Get a snapshot of all collected metrics */
    getMetrics(): Readonly<WorkerMetrics>;
    /** Reset all collected metrics */
    reset(): void;
    /** Stop the auto-started metrics HTTP server and file writer (if any) */
    stop(): Promise<void>;
    /**
     * Get the content type for the Prometheus metrics endpoint.
     * Returns prom-client's content type when available, otherwise standard Prometheus text format.
     */
    getContentType(): string;
    /**
     * Render all collected metrics in Prometheus exposition format.
     * If prom-client is available and `usePromClient: true`, delegates to prom-client's registry.
     * Otherwise uses built-in rendering with p50/p75/p90/p95/p99 quantiles.
     *
     * @param prefix - Metric name prefix (defaults to constructor config or "conductor_worker")
     * @returns Prometheus text format string
     */
    /**
     * Async version of toPrometheusText.
     * When prom-client is available, returns its native registry output.
     * Otherwise falls back to the built-in text format.
     */
    toPrometheusTextAsync(): Promise<string>;
    toPrometheusText(prefix?: string): string;
}

/**
 * Lightweight HTTP server exposing Prometheus metrics and a health check endpoint.
 *
 * Uses Node.js built-in `http` module — no external dependencies.
 *
 * Endpoints:
 * - `GET /metrics` — Prometheus text exposition format (`text/plain; version=0.0.4`)
 * - `GET /health` — JSON health check (`{"status":"UP"}`)
 *
 * @example
 * ```typescript
 * const collector = new MetricsCollector();
 * const server = new MetricsServer(collector, 9090);
 * await server.start();
 * // GET http://localhost:9090/metrics
 * // GET http://localhost:9090/health
 * await server.stop();
 * ```
 */
declare class MetricsServer {
    private readonly _collector;
    private readonly _port;
    private _server?;
    constructor(collector: MetricsCollector, port: number);
    /** Start listening on the configured port */
    start(): Promise<void>;
    /** Stop the HTTP server */
    stop(): Promise<void>;
}

/**
 * Lightweight JSON Schema (draft-07) generator from declarative field descriptions.
 *
 * TypeScript has no runtime type reflection, so this provides a practical
 * alternative: describe your fields declaratively and get a valid JSON Schema object.
 *
 * @example
 * ```typescript
 * const schema = jsonSchema({
 *   orderId: { type: "string", required: true },
 *   amount: { type: "number" },
 *   items: { type: "array", items: { type: "string" } },
 *   address: {
 *     type: "object",
 *     properties: {
 *       street: { type: "string", required: true },
 *       city: { type: "string" },
 *     },
 *   },
 * });
 * ```
 */
type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
interface FieldDescriptor {
    type: JsonSchemaType;
    required?: boolean;
    description?: string;
    /** For arrays: schema of array items */
    items?: FieldDescriptor;
    /** For objects: nested property descriptors */
    properties?: Record<string, FieldDescriptor>;
    /** Default value */
    default?: unknown;
    /** Enum values */
    enum?: unknown[];
}
interface JsonSchemaOutput {
    $schema: string;
    type: "object";
    properties: Record<string, unknown>;
    required?: string[];
}
/**
 * Generate a JSON Schema (draft-07) from declarative field descriptions.
 */
declare function jsonSchema(fields: Record<string, FieldDescriptor>): JsonSchemaOutput;

declare global {
    namespace Reflect {
        function getMetadata(key: unknown, target: object, propertyKey?: string): unknown;
        function getOwnMetadata(key: unknown, target: object): unknown;
        function defineMetadata(key: unknown, value: unknown, target: object): void;
    }
}
/**
 * Options for the @schemaField property decorator.
 */
interface SchemaFieldOptions {
    /** JSON Schema type. If omitted, inferred from TypeScript type metadata. */
    type?: JsonSchemaType;
    /** Whether this field is required (default: false) */
    required?: boolean;
    /** Field description */
    description?: string;
    /** For arrays: element type or schema */
    items?: {
        type: JsonSchemaType;
    } | SchemaFieldOptions;
    /** For objects: nested property definitions */
    properties?: Record<string, SchemaFieldOptions>;
    /** Default value */
    default?: unknown;
    /** Enum values */
    enum?: unknown[];
}
/**
 * Property decorator to define JSON Schema metadata on a class.
 *
 * When used with `generateSchemaFromClass()`, produces a JSON Schema draft-07
 * object from the decorated properties.
 *
 * Supports both TypeScript 5.0+ (Stage 3) and legacy (experimentalDecorators)
 * decorator APIs.
 *
 * If `emitDecoratorMetadata` is enabled in tsconfig.json (legacy mode), the
 * TypeScript type is automatically inferred for `string`, `number`, `boolean` —
 * no need to specify `type` explicitly for those.
 *
 * @example
 * ```typescript
 * class OrderInput {
 *   @schemaField({ required: true })
 *   orderId!: string;
 *
 *   @schemaField()
 *   amount!: number;
 *
 *   @schemaField({ type: "array", items: { type: "string" } })
 *   items!: string[];
 * }
 *
 * const schema = generateSchemaFromClass(OrderInput);
 * ```
 */
declare function schemaField(options?: SchemaFieldOptions): (targetOrValue: object | undefined, propertyKeyOrContext?: string | {
    kind: string;
    name: string | symbol;
}) => ((initialValue: unknown) => unknown) | undefined;
/**
 * Generate a JSON Schema (draft-07) from a class decorated with `@schemaField()`.
 *
 * Uses `reflect-metadata` to read TypeScript type information when available,
 * falling back to explicit `type` in `@schemaField()` options.
 *
 * @param cls - A class constructor with `@schemaField()` decorated properties
 * @returns JSON Schema draft-07 object
 *
 * @example
 * ```typescript
 * class OrderInput {
 *   @schemaField({ required: true })
 *   orderId!: string;
 *
 *   @schemaField()
 *   amount!: number;
 * }
 *
 * const schema = generateSchemaFromClass(OrderInput);
 * // → { "$schema": "...", type: "object", properties: { orderId: { type: "string" }, ... }, required: ["orderId"] }
 * ```
 */
declare function generateSchemaFromClass(cls: new (...args: any[]) => unknown): JsonSchemaOutput;

declare class ConductorSdkError extends Error {
    private _trace;
    private __proto__;
    constructor(message?: string, innerError?: Error);
}

export { type AccessKey, type AccessKeyInfo, type Action, ApiError, type ApiRequestOptions, type ApiResult, ApplicationClient, type ApplicationRole, type AssignmentCompletionStrategy, type Auth, AuthorizationClient, type AuthorizationRequest, type AzureOpenAIConfig, BaseHttpRequest, type BulkResponse, type CallMcpToolOptions, CancelError, CancelablePromise, type ChatMessage, type CircuitBreakerTransitionResponse, type ClaimTaskOptions, type Client, type ClientOptions, type CommonTaskDef, type ConductorClient, type ConductorLogger, ConductorSdkError, type ConductorUser, type ConductorWorker, ConductorWorkflow, type Config$1 as Config, type ConnectivityTestInput, type ConnectivityTestResult, Consistency, type CorrelationIdsSearchRequest, DefaultLogger, type DoWhileTaskDef, type EmbeddingModel, type EnhancedSignalResponse, EventClient, EventDispatcher, type EventHandler, type EventMessage, type EventTaskDef, type ExtendedBulkResponse, type ExtendedConductorApplication, type ExtendedConductorUser, type ExtendedEventExecution, type ExtendedGroup, type ExtendedIntegrationApiUpdate, type ExtendedRateLimitConfig, type ExtendedTaskDef, type ExtendedTaskSummary, type ExtendedWorkflowDef, type ExternalStorageLocation, type FieldDescriptor, type ForkJoinDynamicDef, type ForkJoinTaskDef, type GenerateAudioOptions, type GenerateImageOptions, type GenerateTokenRequest, type GetDocumentOptions, type GrantedAccessResponse, type Group, type HTScrollableSearchResultHumanTaskEntry, type HealthMonitorConfig, type HttpInputParameters, type HttpPollInputParameters, type HttpTaskDef, HumanExecutor, type HumanTaskAssignment, type HumanTaskDefinition, type HumanTaskEntry, type HumanTaskOptions, type HumanTaskSearch, type HumanTaskSearchResult, type HumanTaskTemplate, type HumanTaskTrigger, type HumanTaskUser, type InlineTaskDef, type InlineTaskInputParameters, type Integration, type IntegrationApi, type IntegrationApiUpdate, IntegrationClient, type IntegrationConfig, type IntegrationDef, type IntegrationUpdate, type JoinTaskDef, type JsonJQTransformTaskDef, type JsonSchemaOutput, type JsonSchemaType, type KafkaPublishInputParameters, type KafkaPublishTaskDef, LLMProvider, type ListMcpToolsOptions, type LlmChatCompleteOptions, type LlmCompletionParams, type LlmGenerateEmbeddingsOptions, type LlmIndexDocumentOptions, type LlmIndexTextOptions, type LlmQueryEmbeddingsOptions, type LlmSearchEmbeddingsOptions, type LlmSearchIndexOptions, type LlmStoreEmbeddingsOptions, type LlmTextCompleteOptions, type MessageTemplate, MetadataClient, MetricsCollector, type MetricsCollectorConfig, MetricsServer, type Middleware, NonRetryableException, type OnCancel, type OpenAIConfig, type OpenAPIConfig, type OrkesApiConfig, OrkesClients, type PineconeConfig, type PollCompleted, type PollData, type PollFailure, type PollIntervalOptions, type PollStarted, Poller, PromptClient, type PromptTemplateTestRequest, type ProtoRegistryEntry, type QuerySerializerOptions, type RateLimitConfig, type RegisteredWorker, type RequestOptions, type RerunWorkflowRequest, type ResolvedRequestOptions, type Response$1 as Response, ReturnStrategy, Role, type RunnerArgs, type SaveScheduleRequest, SchedulerClient, SchemaClient, type SchemaDef, type SchemaFieldOptions, type ScrollableSearchResultWorkflowSummary, type SearchResultHandledEventResponse, type SearchResultTask, type SearchResultTaskSummary, type SearchResultWorkflow, type SearchResultWorkflowScheduleExecutionModel, type SearchResultWorkflowSummary, SecretClient, type ServiceMethod, type ServiceRegistry, ServiceRegistryClient, ServiceType, type SetVariableTaskDef, type SignalResponse, type SimpleTaskDef, type SkipTaskRequest, type StartWorkflow, type StartWorkflowRequest, type StreamEvent, type SubWorkflowParams, type SubWorkflowTaskDef, type SwitchTaskDef, type Tag, type Task, TaskClient, TaskContext, type TaskDef, type TaskDefTypes, type TaskDetails, type TaskErrorHandler, type TaskExecLog, type TaskExecutionCompleted, type TaskExecutionFailure, type TaskExecutionStarted, type TaskFinderPredicate, TaskHandler, type TaskHandlerConfig, type TaskInProgressResult, type TaskListSearchResultSummary, TaskManager, type TaskResult, type TaskResultOutputData, type TaskResultStatus, TaskResultStatusEnum, TaskRunner, type TaskRunnerEvent, type TaskRunnerEventType, type TaskRunnerEventsListener, type TaskRunnerOptions, type TaskSummary, TaskType, type TaskUpdateCompleted, type TaskUpdateFailure, TemplateClient, type Terminate, type TerminateTaskDef, type TimeoutPolicy, type ToolCall, type ToolSpec, type UpsertGroupRequest, type UpsertUserRequest, type UserFormTemplate, type UserType, VectorDB, type WaitForWebhookOptions, type WaitTaskDef, type WeaviateConfig, type WorkerMetrics, type WorkerOptions, type Workflow, type WorkflowDef, WorkflowExecutor, type WorkflowRun, type WorkflowSchedule, type WorkflowScheduleExecutionModel, type WorkflowScheduleModel, type WorkflowStateUpdate, type WorkflowStatus, type WorkflowSummary, type WorkflowTask, type WorkflowTestRequest, callMcpToolTask, clearWorkerRegistry, conductorEventTask, createConductorClient, doWhileTask, dynamicForkTask, dynamicTask, eventTask, forkTask, forkTaskJoin, generate, generateAudioTask, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateImageTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSchemaFromClass, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, getDocumentTask, getRegisteredWorker, getRegisteredWorkers, getTaskContext, getWorkerCount, httpPollTask, httpTask, humanTask, inlineTask, isTaskInProgress, joinTask, jsonJqTask, jsonSchema, kafkaPublishTask, listMcpToolsTask, llmChatCompleteTask, llmGenerateEmbeddingsTask, llmIndexDocumentTask, llmIndexTextTask, llmQueryEmbeddingsTask, llmSearchEmbeddingsTask, llmSearchIndexTask, llmStoreEmbeddingsTask, llmTextCompleteTask, newLoopTask, noopLogger, createConductorClient as orkesConductorClient, schemaField, setVariableTask, simpleTask, sqsEventTask, startWorkflowTask, subWorkflowTask, switchTask, taskDefinition, taskGenMapper, terminateTask, waitForWebhookTask, waitTaskDuration, waitTaskUntil, withPromptVariable, withPromptVariables, worker, workflow };