import { type CacheDirective, type CacheRef, type CacheRegistryDefinition } from "./cache.js";
export { defineCache, fileCache, memoryCache } from "./cache.js";
export declare const cache: CacheRegistryDefinition;
export type RuntimeStatus = "idle" | "running" | "passed" | "failed" | "started" | "stopped";
export type RuntimeNext = () => Promise<unknown>;
export type RuntimeNodeKind = "task" | "middleware" | "series" | "parallel" | "branch" | "cache";
export type RuntimeNodeStatus = "passed" | "failed" | "cached";
export interface RuntimeContext<Input = unknown> {
    input: Input;
    state: Record<string, unknown>;
    taskId: string;
    path: string[];
    signal?: AbortSignal;
    output?: unknown;
    cacheHit?: boolean;
}
export type RuntimeMiddleware<Input = unknown> = (context: RuntimeContext<Input>, next: RuntimeNext) => unknown | Promise<unknown>;
export type RuntimeBranchPredicate<Input = unknown> = (context: RuntimeContext<Input>) => boolean | Promise<boolean>;
export interface RuntimeSeriesDefinition<Input = unknown> {
    kind: "async-pipeline.runtime.series";
    items: RuntimeRunItem<Input>[];
}
export interface RuntimeParallelDefinition<Input = unknown> {
    kind: "async-pipeline.runtime.parallel";
    items: RuntimeRunItem<Input>[];
    concurrency?: number;
}
export interface RuntimeParallelOptions {
    concurrency?: number;
}
export interface RuntimeBranchDefinition<Input = unknown> {
    kind: "async-pipeline.runtime.branch";
    predicate: RuntimeBranchPredicate<Input>;
    whenTrue: RuntimeRunItem<Input>[];
    whenFalse?: RuntimeRunItem<Input>[];
}
export type RuntimeFlowDefinition<Input = unknown> = RuntimeSeriesDefinition<Input> | RuntimeParallelDefinition<Input> | RuntimeBranchDefinition<Input>;
export type RuntimeRunItem<Input = unknown> = RuntimeMiddleware<Input> | CacheDirective | RuntimeFlowDefinition<Input> | readonly RuntimeRunItem<Input>[];
export type RuntimeRunDefinition<Input = unknown> = RuntimeRunItem<Input> | readonly RuntimeRunItem<Input>[];
export interface RuntimeInspectNode {
    kind: RuntimeNodeKind;
    id: string;
    path: string[];
    children: RuntimeInspectNode[];
}
export interface RuntimeTaskConfig<Input = unknown> {
    id?: string;
    description?: string;
    dependsOn?: string[];
    cache?: false | CacheRef;
    run?: RuntimeRunDefinition<Input>;
}
export interface RuntimeTaskDefinition<Input = unknown> extends RuntimeTaskConfig<Input> {
    children: RuntimeTaskDefinition<Input>[];
    flow?: RuntimeInspectNode;
}
export interface RuntimeDefinition<Input = unknown> {
    kind: "runtime-definition";
    tasks: RuntimeTaskDefinition<Input>[];
    cache: CacheRegistryDefinition;
}
export interface RuntimeTaskResult {
    id: string;
    status: "passed" | "failed" | "cached";
    cacheHit: boolean;
    path?: string[];
    error?: string;
    errorCode?: string;
    nodes?: RuntimeNodeResult[];
}
export interface RuntimeNodeResult {
    id: string;
    kind: RuntimeNodeKind;
    path: string[];
    status: RuntimeNodeStatus;
    error?: string;
    errorCode?: string;
}
export interface RuntimeExecution {
    status: "passed" | "failed";
    tasks: RuntimeTaskResult[];
    nodes: RuntimeNodeResult[];
    output?: unknown;
    error?: string;
    errorCode?: string;
}
export interface Runtime<Input = unknown> {
    inspect(): RuntimeDefinition<Input>;
    run(input?: Input, options?: {
        task?: string;
        signal?: AbortSignal;
    }): Promise<RuntimeExecution>;
    start(): Promise<void>;
    stop(): Promise<void>;
    close(): Promise<void>;
}
export declare function compose<Input = unknown>(...items: RuntimeRunDefinition<Input>[]): RuntimeSeriesDefinition<Input>;
export declare function series<Input = unknown>(items: RuntimeRunDefinition<Input>): RuntimeSeriesDefinition<Input>;
export declare function parallel<Input = unknown>(items: readonly RuntimeRunDefinition<Input>[]): RuntimeParallelDefinition<Input>;
export declare function parallel<Input = unknown>(options: RuntimeParallelOptions, items: readonly RuntimeRunDefinition<Input>[]): RuntimeParallelDefinition<Input>;
export declare function branch<Input = unknown>(predicate: RuntimeBranchPredicate<Input>, whenTrue: RuntimeRunDefinition<Input>, whenFalse?: RuntimeRunDefinition<Input>): RuntimeBranchDefinition<Input>;
export declare function task<Input = unknown>(config: RuntimeTaskConfig<Input>): RuntimeTaskDefinition<Input>;
export declare function task<Input = unknown>(config: RuntimeTaskConfig<Input>, runOrChildren: RuntimeRunDefinition<Input> | readonly RuntimeTaskDefinition<Input>[]): RuntimeTaskDefinition<Input>;
export declare function defineRuntime<Input = unknown>(definition: readonly RuntimeTaskDefinition<Input>[] | readonly RuntimeRunItem<Input>[] | {
    tasks: readonly RuntimeTaskDefinition<Input>[] | readonly RuntimeRunItem<Input>[];
    cache?: CacheRegistryDefinition;
}): RuntimeDefinition<Input>;
export declare function createRuntime<Input = unknown>(definition: RuntimeDefinition<Input> | readonly RuntimeTaskDefinition<Input>[], options?: {
    cache?: CacheRegistryDefinition;
}): Runtime<Input>;
//# sourceMappingURL=runtime.d.ts.map