import { type ProcessInstance, type ProcessProject, type ProcessTurnStartSelection, type ProcessTurnTerminalLifecycleStatus, type ScopedSettingsSnapshot, type TurnId, type TurnProgressReport } from "@leitwerk-dev/domain";
import type { AutomaticTurnDefinition, ExternalTurnDefinition, HumanTurnDefinition, HumanTurnOperatorAttention, LlmModelPurpose, LlmOutcomeSubmission, LlmTurnDefinition, OutcomeParameterContext, ProcessEffectPlan, ProcessHumanTurnActionSpec, ProcessHumanTurnExternalActionSpec, ProcessOutcomeBranchSpec, ProcessOutcomeEffect, ProcessOutcomeExecution, ProcessRuntimeTurnContext, ProcessToolOutcomeSpec, ProcessTurnEndSpec, TurnDefinition } from "./define-process.js";
import type { Codec, ExtensionProcessDefinition, ExternalActionSource, ExternalSourceEffect, ExternalSourceEffectContext, FormDefinition, ProcessActionDefinition, ProcessLauncherAPI, ProcessLauncherDefinition, ProcessWatcherAPI, ProcessWatcherDefinition, ServerProcessAPI, TurnDiagnosticReport, UiProcessAPI, WorkerCompleteInput } from "./extension-api.js";
import type { MappedCollect, MappedCollectRouting, MappedItemYield, MappedLlmTurnSpec, MappedTurnItemContext, MappedTurnServerContext } from "./mapped-turn.js";
import type { TurnWaitPredicate } from "./turn-wait.js";
import type { OutcomeToolArrayItemSpec, OutcomeToolParameterSpec, PiBuiltInToolName, ProcessPiConfig } from "./types.js";
/** @public */
type MaybePromise<T> = T | Promise<T>;
/** @internal */
export declare const DEFAULT_PLAN_RESULT_OUTCOME_ID: "plan_saved";
/** @internal */
export declare const DEFAULT_FLOW_PRODUCT_NAME: "default";
/** @public */
export interface FlowLlmTurn<TParams = unknown, TState = unknown, TOutcome extends string = string> {
    /** @public */
    id: TurnId;
    /** @public */
    definition: LlmTurnDefinition<TOutcome, TParams, TState>;
}
/** @public */
export interface FlowAutomaticTurn<TParams = unknown, TState = unknown, TOutcome extends string = string> {
    /** @public */
    id: TurnId;
    /** @public */
    definition: AutomaticTurnDefinition<TOutcome, TParams, TState>;
}
/** @public */
export interface FlowHumanTurn<TParams = unknown, TState = unknown> {
    /** @public */
    id: TurnId;
    /** @public */
    definition: HumanTurnDefinition<TParams, TState>;
}
/** @public */
export interface FlowExternalTurn<TParams = unknown, TState = unknown> {
    /** @public */
    id: TurnId;
    /** @public */
    definition: ExternalTurnDefinition<TParams, TState>;
}
/** @public */
export type FlowTurn<TParams = unknown, TState = unknown> = FlowLlmTurn<TParams, TState, string> | FlowAutomaticTurn<TParams, TState, string> | FlowHumanTurn<TParams, TState> | FlowExternalTurn<TParams, TState> | {
    /** @public */
    id: TurnId;
    /** @public */
    definition: TurnDefinition<TParams, TState>;
};
/** @internal */
export interface PlanFieldOptions {
    /** @internal */
    description?: string;
    /** @internal */
    requiredErrorCode?: string;
}
/** @internal */
export interface PlanAcceptanceCriteriaOptions extends PlanFieldOptions {
    /** @internal */
    minItems?: number;
    /** @internal */
    minItemsErrorCode?: string;
}
export interface PlanSavedStateInput<TParams = unknown, TState = unknown> {
    effect: ProcessOutcomeEffect<TParams, TState>;
}
/** @public */
export interface FlowRepoContext {
    /** @internal */
    key: string;
    /** @public */
    fsPath: string;
    /** @internal */
    workspaceClonePath: string;
    /** @public */
    baseBranch: string;
    /** @public */
    workBranch: string;
    /** @internal */
    locator: string;
}
/** @public */
export interface FlowRepoLookup {
    /** @public */
    get(key: string): FlowRepoContext;
    /** @internal */
    optional(key: string): FlowRepoContext | undefined;
    /** @internal */
    all(): FlowRepoContext[];
}
/** @public */
export type FlowPromptContext<TParams = unknown, TState = unknown, TConsumedProducts extends string = string, TPrepared = undefined> = {
    /** @internal */
    process: ProcessInstance;
    /** @internal */
    projects: readonly ProcessProject[];
    /** @public */
    params: TParams;
    /** @public */
    state: TState;
    /** @internal */
    workspaceRoot?: string;
    /** @internal */
    prompts: {
        /** @internal */
        initial: string;
    };
    /** @public */
    input: Readonly<Partial<Record<TConsumedProducts, string>>>;
    /** @internal */
    repo: FlowRepoLookup;
} & ([TPrepared] extends [undefined] ? {
    /** @internal */
    prepared?: undefined;
} : {
    /** @internal */
    prepared: TPrepared;
});
/** @public */
export interface FlowAutomaticRunContext<TParams = unknown, TState = unknown> {
    /** Immutable non-secret settings captured for this turn. @public */
    readonly scopedSettings?: ScopedSettingsSnapshot;
    /** @public */
    process: ProcessInstance;
    /** @public */
    projects: readonly ProcessProject[];
    /** @public */
    params: TParams;
    /** @public */
    state: TState;
    /** @public */
    workspaceRoot?: string;
    /** @public */
    repo: FlowRepoLookup;
    /** @public */
    callIntegrationTool(name: string, args: Record<string, unknown>): Promise<unknown>;
    /** @public */
    reportProgress(report: TurnProgressReport): void;
    /** Append a non-secret worker diagnostic for this turn attempt. @internal */
    reportDiagnostic(report: TurnDiagnosticReport): void;
}
/** Worker context for correcting a submission before accepting it. @public */
export interface FlowOutcomeValidationContext<TParams = unknown, TState = unknown> extends FlowAutomaticRunContext<TParams, TState> {
    /** Preparation captured before prompting. @public */
    prepared?: unknown;
}
/** @public */
export type FlowLlmPreparationContext<TParams = unknown, TState = unknown> = FlowAutomaticRunContext<TParams, TState>;
/** @public */
interface FlowOutcomeEffectContext<TParams = unknown, TState = unknown> {
    /** @public */
    process: ProcessInstance;
    /** @internal */
    projects: readonly ProcessProject[];
    /** @internal */
    params: TParams;
    /** @public */
    state: TState;
    /** @internal */
    output: {
        /** @internal */
        content: string | null;
    } | null;
}
/** @public */
export interface FlowLlmOutcomeEffectContext<TParams = unknown, TState = unknown> extends FlowOutcomeEffectContext<TParams, TState> {
}
/** @public */
export interface FlowAutomaticOutcomeEffectContext<TParams = unknown, TState = unknown> extends FlowOutcomeEffectContext<TParams, TState> {
}
/** @internal */
export interface FlowExternalSourceContext<TParams = unknown, TState = unknown, TEvent = unknown, TInput extends Record<string, unknown> = Record<string, unknown>> extends ExternalSourceEffectContext<TParams, TState, TEvent, TInput> {
}
/** @public */
type FlowOutcomeEffectInput<TParams, TState, TContext> = {
    /** @public */
    ctx: TContext;
    /** @public */
    event: ProcessOutcomeExecution<TParams, TState>["event"];
    /** @internal */
    turnId: TurnId;
    /** @internal */
    outcome: string;
};
/** @public */
type FlowOutcomeEffect<TParams, TState, TContext> = (input: FlowOutcomeEffectInput<TParams, TState, TContext>) => MaybePromise<ProcessEffectPlan<TState> | undefined>;
/** @public */
type FlowOutcomeStateEffect<TParams, TState, TContext> = (input: FlowOutcomeEffectInput<TParams, TState, TContext>) => MaybePromise<TState>;
/** @internal */
export declare function createFlowPromptContext<TParams, TState, TConsumedProducts extends string = string, TPrepared = undefined>(ctx: ProcessRuntimeTurnContext<TParams, TState>, consumedProducts: readonly TConsumedProducts[], optionalConsumedProducts?: readonly string[]): FlowPromptContext<TParams, TState, TConsumedProducts, TPrepared>;
/** @internal */
export declare function createFlowAutomaticRunContext<TParams, TState>(ctx: ProcessRuntimeTurnContext<TParams, TState>): FlowAutomaticRunContext<TParams, TState>;
/** @public */
declare class RouteAndEffectBuilder<TParams, TState, TContext> {
    /** @internal */
    protected target: FlowTargetSpec;
    /** @internal */
    protected flowEffect: FlowOutcomeEffect<TParams, TState, TContext> | undefined;
    /** @internal */
    protected setTarget(next: FlowTargetSpec): this;
    /** @public */
    to(turnId: TurnId): this;
    /** @public */
    complete(): this;
    /** @public */
    lifecycleStatus(status: ProcessTurnTerminalLifecycleStatus): this;
    /** @internal */
    stay(): this;
    /** @public */
    state(fn: FlowOutcomeStateEffect<TParams, TState, TContext>): this;
    /** @public */
    effect(fn: FlowOutcomeEffect<TParams, TState, TContext>): this;
    /** @internal */
    getEffect(): FlowOutcomeEffect<TParams, TState, TContext> | undefined;
    /** @internal */
    hasRoute(): boolean;
    /** @internal */
    buildRouteTarget(): Pick<ProcessTurnEndSpec, "to" | "complete" | "lifecycleStatus">;
}
/** @internal */
export type FlowTargetSpec = {
    /** @internal */
    to: TurnId;
} | {
    /** @internal */
    complete: true;
} | {
    /** @internal */
    lifecycleStatus: ProcessTurnTerminalLifecycleStatus;
} | null;
/** @public */
interface ParameterOptions extends Partial<Omit<OutcomeToolParameterSpec, "type" | "description">> {
    /** @public */
    description?: string;
    /** @internal */
    requiredErrorCode?: string;
}
/** @public */
interface ArrayParameterOptions extends ParameterOptions {
    /** @public */
    items?: OutcomeToolParameterSpec["items"];
}
/** @internal */
interface EnumParameterOptions extends ParameterOptions {
    /** @internal */
    values?: readonly string[];
}
/** @public */
interface MarkdownParameterOptions extends ParameterOptions {
    /** @public */
    publish?: true;
}
/** @public */
declare class OutcomeParametersBuilder<TParams = unknown, TState = unknown> {
    /** @internal */
    protected outcomeDescription: string | null;
    /** @internal */
    protected parameters: Record<string, OutcomeToolParameterSpec>;
    /** @internal */
    protected summaryParameter: string | null;
    private enforceSchema;
    /** @internal */
    protected parameterResolver?: (ctx: OutcomeParameterContext<TParams, TState>) => Record<string, OutcomeToolParameterSpec>;
    /** Enforce a closed schema with no optional properties at supported providers. @public */
    strictSchema(): this;
    /** Declare alternatives for one argument. @public */
    union(name: string, variants: readonly OutcomeToolArrayItemSpec[], options?: string | ParameterOptions): this;
    /** Optional concise result publication, separate from the full Markdown. @public */
    resultSummary(name?: string): this;
    /** @internal */
    protected buildParameterSpec(kind: string): Pick<ProcessToolOutcomeSpec, "description" | "parameters" | "resultSummaryParameter">;
    /** @public */
    description(text: string): this;
    /** @internal */
    parameter(name: string, spec: OutcomeToolParameterSpec): this;
    private withRequired;
    /** @internal */
    protected typedParameter(name: string, type: OutcomeToolParameterSpec["type"], options?: string | ArrayParameterOptions): this;
    /** @public */
    string(name: string, options?: string | ParameterOptions): this;
    /** @public */
    requiredString(name: string, options?: string | ParameterOptions): this;
    /** @internal */
    number(name: string, options?: string | ParameterOptions): this;
    /** @public */
    requiredNumber(name: string, options?: string | ParameterOptions): this;
    /** @internal */
    boolean(name: string, options?: string | ParameterOptions): this;
    /** @public */
    requiredBoolean(name: string, options?: string | ParameterOptions): this;
    /** @internal */
    stringArray(name: string, options?: string | ArrayParameterOptions): this;
    /** @public */
    requiredStringArray(name: string, options?: string | ArrayParameterOptions): this;
    /** @internal */
    enum(name: string, valuesOrOptions: readonly string[] | EnumParameterOptions): this;
    /** @public */
    object(name: string, options?: string | ParameterOptions): this;
    /** @internal */
    array(name: string, options?: string | ArrayParameterOptions): this;
    /** @public */
    requiredArray(name: string, options?: string | ArrayParameterOptions): this;
}
/** @public */
declare class ParameterizedOutcomeBuilder<TParams, TState, TContext> extends OutcomeParametersBuilder<TParams, TState> {
    private readonly route;
    private publishedMarkdownParameter;
    /** @public */
    to(turnId: TurnId): this;
    /** @public */
    complete(): this;
    /** @public */
    lifecycleStatus(status: ProcessTurnTerminalLifecycleStatus): this;
    /** @internal */
    stay(): this;
    /** @public */
    state(fn: FlowOutcomeStateEffect<TParams, TState, TContext>): this;
    /** @public */
    effect(fn: FlowOutcomeEffect<TParams, TState, TContext>): this;
    /** @internal */
    hasRoute(): boolean;
    /** @internal */
    protected get flowEffect(): FlowOutcomeEffect<TParams, TState, TContext> | undefined;
    /** @internal */
    protected buildRouteTarget(): Pick<ProcessTurnEndSpec<unknown, unknown, string>, "to" | "complete" | "lifecycleStatus">;
    /** @internal */
    protected buildParameterSpec(kind: string): ProcessToolOutcomeSpec<TParams, TState>;
    /** @public */
    markdown(name: string, options?: string | MarkdownParameterOptions): this;
}
/** @public */
export declare class OutcomeToolBuilder<TParams = unknown, TState = unknown> extends ParameterizedOutcomeBuilder<TParams, TState, FlowLlmOutcomeEffectContext<TParams, TState>> {
    /** Pure synchronous resolution at turn-start preparation. @public */
    resolveParameters(fn: (ctx: OutcomeParameterContext<TParams, TState>) => Record<string, OutcomeToolParameterSpec>): this;
    private stateRouting;
    /** @public */
    routeByState(branches: Record<string, TurnId | ProcessOutcomeBranchSpec>, choose: (input: FlowOutcomeEffectInput<TParams, TState, FlowLlmOutcomeEffectContext<TParams, TState>>) => MaybePromise<string>): this;
    /** @internal */
    build(): ProcessToolOutcomeSpec<TParams, TState>;
}
/** @public */
export declare class AutomaticOutcomeBuilder<TParams = unknown, TState = unknown> extends ParameterizedOutcomeBuilder<TParams, TState, FlowAutomaticOutcomeEffectContext<TParams, TState>> {
    private waits;
    /** @public */
    wait(): this;
    /** @internal */
    build(): ProcessToolOutcomeSpec<TParams, TState>;
}
/** @internal */
export declare class PlanResultBuilder<TParams = unknown, TState = unknown> extends RouteAndEffectBuilder<TParams, TState, FlowLlmOutcomeEffectContext<TParams, TState>> {
    private resultDescription;
    private summarySpec;
    private acceptanceCriteriaSpec;
    private reviewTurnId;
    /** @internal */
    description(text: string): this;
    /** @internal */
    summary(options?: string | PlanFieldOptions): this;
    /** @internal */
    acceptanceCriteria(options?: string | PlanAcceptanceCriteriaOptions): this;
    /** @internal */
    review(turnId: TurnId): this;
    /** @internal */
    buildOutcome(): ProcessToolOutcomeSpec<TParams, TState>;
}
/** @public */
export declare class LlmTurnEndBuilder<TParams = unknown, TState = unknown> extends RouteAndEffectBuilder<TParams, TState, FlowLlmOutcomeEffectContext<TParams, TState>> implements FlowLlmTurn<TParams, TState, string> {
    private readonly outcomeId;
    private readonly parent?;
    /** @internal */
    protected readonly builderName: string;
    /** @internal */
    constructor(outcomeId: string, parent?: FlowLlmTurn<TParams, TState, string> | undefined);
    private get turn();
    /** @internal */
    get id(): TurnId;
    /** @internal */
    get definition(): LlmTurnDefinition<string, TParams, TState>;
    /** @internal */
    build(): ProcessTurnEndSpec<TParams, TState, string>;
}
/** @public */
export declare class PublishedResultBuilder<TParams = unknown, TState = unknown> extends LlmTurnEndBuilder<TParams, TState> {
    /** @internal */
    protected readonly builderName = "Published result";
    /** @internal */
    buildTurnEnd(): ProcessTurnEndSpec<TParams, TState, string>;
}
/** @public */
declare abstract class DescribedTurnBuilder {
    /** @internal */
    protected readonly turnId: TurnId;
    /** @internal */
    protected turnDescription: string | null;
    /** @internal */
    constructor(
    /** @internal */
    turnId: TurnId);
    /** @internal */
    get id(): TurnId;
    /** @public */
    description(description: string): this;
}
/** @public */
declare abstract class ExternalActionTurnBuilder<TParams, TState> extends DescribedTurnBuilder {
    /** @internal */
    protected abstract readonly turnKind: "LLM" | "Automatic" | "Human";
    private externalActionBuilders;
    /** @public */
    externalAction<TEvent = unknown, TInput extends Record<string, unknown> = Record<string, unknown>>(externalActionId: string, source: ExternalActionSource<TParams, TState, TEvent, TInput>, configure: (external: ExternalActionBuilder<TParams, TState, TEvent, TInput>) => ExternalActionBuilder<TParams, TState, TEvent, TInput> | undefined): this;
    /** @internal */
    protected buildExternalActions(): Record<string, ProcessHumanTurnExternalActionSpec<TParams, TState>> | undefined;
}
/** LLM authoring families used to preserve fluent context and completion types. @public */
type LlmBuilderFamily = {
    /** @public */
    kind: "ordinary";
} | {
    /** @public */
    kind: "mapped";
    /** @public */
    item: unknown;
    /** @public */
    result: unknown;
};
/** Active-item context supplied by an LLM authoring family. @public */
type LlmItemContext<TFamily extends LlmBuilderFamily> = TFamily extends {
    kind: "mapped";
    item: infer TItem;
} ? MappedTurnItemContext<TItem> : Record<never, never>;
/** Preserve the concrete completion API when preparation or products refine its types. @public */
type ConfiguredLlmBuilder<TFamily extends LlmBuilderFamily, TParams, TState, TConsumedProducts extends string, TPrepared> = TFamily extends {
    kind: "mapped";
    item: infer TItem;
    result: infer TResult;
} ? MappedLlmFlowBuilder<TParams, TState, TItem, TResult, TConsumedProducts, TPrepared> : LlmFlowBuilder<TParams, TState, TConsumedProducts, TPrepared>;
/** @public */
declare abstract class LlmConfigurationBuilder<TParams, TState, TConsumedProducts extends string, TPrepared, TFamily extends LlmBuilderFamily> extends ExternalActionTurnBuilder<TParams, TState> {
    /** @internal */
    protected readonly turnKind = "LLM";
    private readonly configuration;
    /** Wait on the server before this turn may allocate a worker. @public */
    waitFor(predicate: TurnWaitPredicate<TParams, TState>): this;
    private promptBuilder;
    private readonly consumedProductNames;
    private readonly optionalConsumedProductNames;
    /** @internal */
    protected abstract itemContext(ctx: ProcessRuntimeTurnContext<TParams, TState>): LlmItemContext<TFamily>;
    /** @public */
    executionPurpose(purpose: string): this;
    /** @internal */
    modelPurpose(purpose: LlmModelPurpose): this;
    /** @public */
    tools(...tools: readonly PiBuiltInToolName[]): this;
    /** @public */
    integrationTools(...tools: readonly string[]): this;
    /** @public */
    resolveIntegrationTools(resolver: (params: TParams, state: TState) => readonly string[]): this;
    /** @public */
    prepare<TNextPrepared>(fn: (ctx: FlowLlmPreparationContext<TParams, TState> & LlmItemContext<TFamily>) => MaybePromise<TNextPrepared>): ConfiguredLlmBuilder<TFamily, TParams, TState, TConsumedProducts, TNextPrepared>;
    /** Return correction errors before accepting an outcome. @public */
    validateOutcome(fn: (ctx: FlowOutcomeValidationContext<TParams, TState> & LlmItemContext<TFamily>, outcome: LlmOutcomeSubmission) => MaybePromise<readonly string[]>): this;
    /** Enable durable questions, optionally constrained by captured input. @public */
    askQuestions(when?: (ctx: FlowPromptContext<TParams, TState, TConsumedProducts, TPrepared> & LlmItemContext<TFamily>) => boolean): this;
    /** @public */
    freshPrimary(): this;
    /** @internal */
    freshSeededPrimary(): this;
    /** @public */
    fullPrimary(): this;
    /** @internal */
    rootBranchReview(): this;
    /** @public */
    continueFromPrimaryLeaf(): this;
    /** @internal */
    continueFromReviewBranch(): this;
    /** @internal */
    continueFromProductBranch(productName: string, fallback?: ProcessTurnStartSelection): this;
    /** @internal */
    startFromReviewBranch(): this;
    /** @internal */
    startFromProductBranch(productName: string, fallback?: ProcessTurnStartSelection): this;
    /** @internal */
    startFromRoot(): this;
    /** @public */
    consume<TProductName extends string>(productName: TProductName): ConfiguredLlmBuilder<TFamily, TParams, TState, TConsumedProducts | TProductName, TPrepared>;
    /** @public */
    optionalConsume<TProductName extends string>(productName: TProductName): ConfiguredLlmBuilder<TFamily, TParams, TState, TConsumedProducts | TProductName, TPrepared>;
    private refineContext;
    /** @public */
    buildPrompt(fn: (ctx: FlowPromptContext<TParams, TState, TConsumedProducts, TPrepared> & LlmItemContext<TFamily>) => MaybePromise<string>): this;
    /** @public */
    prompt(prompt: string | ((ctx: ProcessRuntimeTurnContext<TParams, TState>) => MaybePromise<string>)): this;
    /** @internal */
    protected buildBaseDefinition(): Omit<LlmTurnDefinition<string, TParams, TState>, "outcomes" | "turnEnd" | "forEach">;
}
/** @public */
export declare class LlmFlowBuilder<TParams = unknown, TState = unknown, TConsumedProducts extends string = never, TPrepared = undefined> extends LlmConfigurationBuilder<TParams, TState, TConsumedProducts, TPrepared, {
    kind: "ordinary";
}> implements FlowLlmTurn<TParams, TState, string> {
    private publishedResult;
    private endResult;
    private outcomeToolBuilders;
    /** @internal */
    protected itemContext(): Record<never, never>;
    /** @public */
    publish(productName: string): PublishedResultBuilder<TParams, TState>;
    /** @public */
    end(outcomeId: string): LlmTurnEndBuilder<TParams, TState>;
    /** @public */
    outcomeTool(id: string, configure: (tool: OutcomeToolBuilder<TParams, TState>) => OutcomeToolBuilder<TParams, TState> | undefined): this;
    /** @internal */
    producesPlan(configure: (plan: PlanResultBuilder<TParams, TState>) => PlanResultBuilder<TParams, TState>): FlowLlmTurn<TParams, TState, typeof DEFAULT_PLAN_RESULT_OUTCOME_ID>;
    /** @internal */
    get definition(): LlmTurnDefinition<string, TParams, TState>;
}
/** Item selection for `flow.mappedLlm(...)`. @public */
export type FlowForEachOptions<TParams, TState, TItem, TResult> = Pick<MappedLlmTurnSpec<TParams, TState, TItem, TResult>, "items" | "itemCodec" | "resultCodec" | "key" | "label" | "stateAfterSnapshot">;
/** @public */
export type FlowMappedPromptContext<TParams, TState, TItem, TConsumedProducts extends string, TPrepared> = FlowPromptContext<TParams, TState, TConsumedProducts, TPrepared> & MappedTurnItemContext<TItem>;
/** @public */
export type FlowMappedPreparationContext<TParams, TState, TItem> = FlowLlmPreparationContext<TParams, TState> & MappedTurnItemContext<TItem>;
/**
 * Outcome of one mapped item. It declares parameters and yields the item's
 * result; it cannot route, change process state, or publish products.
 * @public
 */
export declare class MappedOutcomeBuilder<TParams = unknown, TState = unknown, TItem = unknown, TResult = unknown> extends OutcomeParametersBuilder<TParams, TState> {
    /** Resolve parameters from captured state and the frozen mapped item. @public */
    resolveParameters(fn: (ctx: OutcomeParameterContext<TParams, TState> & MappedTurnItemContext<TItem>) => Record<string, OutcomeToolParameterSpec>): this;
    private yieldResult;
    /** Map this outcome to the item's typed result. @public */
    yield(fn: MappedItemYield<TParams, TState, TItem, TResult>): this;
    /** @internal */
    build(): {
        /** @internal */
        tool: ProcessToolOutcomeSpec<TParams, TState>;
        /** @internal */
        yieldResult: MappedItemYield<TParams, TState, TItem, TResult>;
    };
}
/** Routes a mapped turn once, after all item results are collected. @public */
export declare class MappedCollectBuilder<TParams = unknown, TState = unknown> implements FlowLlmTurn<TParams, TState, string> {
    private readonly turn;
    private readonly setRouting;
    /** @internal */
    constructor(turn: FlowLlmTurn<TParams, TState, string>, setRouting: (routing: MappedCollectRouting<TParams, TState>) => void);
    /** @internal */
    get id(): TurnId;
    /** @internal */
    get definition(): LlmTurnDefinition<string, TParams, TState>;
    /** @public */
    to(turnId: TurnId): this;
    /** @public */
    complete(): this;
    /** @public */
    lifecycleStatus(status: ProcessTurnTerminalLifecycleStatus): this;
    /** Choose the next turn from the collected state. @public */
    routeByState(branches: Record<string, TurnId>, choose: (ctx: MappedTurnServerContext<TParams, TState>) => MaybePromise<string>): this;
}
/**
 * LLM turn that runs once per frozen item. Business state and routing belong
 * to `.collect(...)`.
 * @public
 */
export declare class MappedLlmFlowBuilder<TParams = unknown, TState = unknown, TItem = unknown, TResult = unknown, TConsumedProducts extends string = never, TPrepared = undefined> extends LlmConfigurationBuilder<TParams, TState, TConsumedProducts, TPrepared, {
    kind: "mapped";
    item: TItem;
    result: TResult;
}> implements FlowLlmTurn<TParams, TState, string> {
    private readonly items;
    private readonly outcomes;
    private collection;
    private routing;
    /** @internal */
    constructor(turnId: TurnId, items: FlowForEachOptions<TParams, TState, TItem, TResult>);
    /** @internal */
    protected itemContext(ctx: ProcessRuntimeTurnContext<TParams, TState>): MappedTurnItemContext<TItem>;
    /** @public */
    outcomeTool(id: string, configure: (outcome: MappedOutcomeBuilder<TParams, TState, TItem, TResult>) => MappedOutcomeBuilder<TParams, TState, TItem, TResult> | undefined): this;
    /** Combine ordered item results into process state, once. @public */
    collect(fn: MappedCollect<TParams, TState, TResult>): MappedCollectBuilder<TParams, TState>;
    /** @internal */
    get definition(): LlmTurnDefinition<string, TParams, TState>;
}
/** @public */
export declare class AutomaticFlowBuilder<TParams = unknown, TState = unknown> extends ExternalActionTurnBuilder<TParams, TState> implements FlowAutomaticTurn<TParams, TState, string> {
    /** @internal */
    protected readonly turnKind = "Automatic";
    private runFn;
    private outcomeBuilders;
    private availableIntegrationTools;
    private waitPredicate;
    /** Wait on the server before this turn may allocate a worker. @public */
    waitFor(predicate: TurnWaitPredicate<TParams, TState>): this;
    /** @public */
    run(fn: (ctx: FlowAutomaticRunContext<TParams, TState>) => MaybePromise<WorkerCompleteInput<string>>): this;
    /** @public */
    integrationTools(...tools: readonly string[]): this;
    /** @public */
    outcome(id: string, configure: (outcome: AutomaticOutcomeBuilder<TParams, TState>) => AutomaticOutcomeBuilder<TParams, TState> | undefined): this;
    /** @internal */
    get definition(): AutomaticTurnDefinition<string, TParams, TState>;
}
/** @public */
export declare class HumanActionBuilder<TParams = unknown, TState = unknown> {
    private readonly actionId;
    private spec;
    /** @internal */
    constructor(actionId: string);
    /** @public */
    label(label: string): this;
    /** @internal */
    description(description: string): this;
    /** @public */
    acceptanceState(state: ProcessHumanTurnActionSpec<TParams, TState>["acceptanceState"]): this;
    /** @public */
    form(form: FormDefinition): this;
    /** @public */
    to(turnId: TurnId): this;
    /** @internal */
    complete(): this;
    /** @public */
    lifecycleStatus(status: ProcessTurnTerminalLifecycleStatus): this;
    /** @internal */
    trigger(trigger: string): this;
    /** @internal */
    schedulable(value?: boolean): this;
    /** @public */
    effect(effect: ProcessHumanTurnActionSpec<TParams, TState>["effect"]): this;
    /** @internal */
    build(): ProcessHumanTurnActionSpec<TParams, TState>;
}
/** @public */
export declare class ExternalActionBuilder<TParams = unknown, TState = unknown, TEvent = unknown, TInput extends Record<string, unknown> = Record<string, unknown>> {
    private spec;
    /** @internal */
    constructor(actionId: string, source: ExternalActionSource<TParams, TState, TEvent, TInput>);
    /** @public */
    label(label: string): this;
    /** @public */
    description(description: string): this;
    /** @public */
    when(condition: NonNullable<ProcessHumanTurnExternalActionSpec<TParams, TState>["when"]>): this;
    /** @public */
    to(turnId: TurnId): this;
    /** @internal */
    complete(): this;
    /** @public */
    lifecycleStatus(status: ProcessTurnTerminalLifecycleStatus): this;
    /** @internal */
    publishInput(productName: string, options: {
        /** @internal */
        inputField: string;
    }): this;
    /** @public */
    effect(effect: ExternalSourceEffect<TParams, TState, TEvent, TInput>): this;
    /** @internal */
    build(): ProcessHumanTurnExternalActionSpec<TParams, TState, TEvent, TInput>;
}
/** @public */
export declare class HumanFlowBuilder<TParams = unknown, TState = unknown> extends ExternalActionTurnBuilder<TParams, TState> implements FlowHumanTurn<TParams, TState> {
    /** @internal */
    protected readonly turnKind = "Human";
    private readonly metadata;
    private actions;
    /** @public */
    get definition(): HumanTurnDefinition<TParams, TState>;
    /** @public */
    reviewProduct(productName: string): this;
    /** @public */
    operatorAttention(attention: HumanTurnOperatorAttention): this;
    /** @internal */
    commentary(commentary: string): this;
    /** @internal */
    notesFields(notes: HumanTurnDefinition<TParams, TState>["notesFields"]): this;
    /** @public */
    action(actionId: string, configure: (action: HumanActionBuilder<TParams, TState>) => HumanActionBuilder<TParams, TState> | undefined): this;
}
/** @public */
export declare class ExternalRouteBuilder<TParams = unknown, TState = unknown, TEvent = unknown, TInput extends Record<string, unknown> = Record<string, unknown>> implements FlowExternalTurn<TParams, TState> {
    private readonly parent;
    private readonly source;
    private externalEffect;
    private target;
    /** @internal */
    constructor(parent: ExternalFlowBuilder<TParams, TState>, source: ExternalActionSource<TParams, TState, TEvent, TInput>);
    /** @internal */
    get id(): TurnId;
    /** @internal */
    get definition(): ExternalTurnDefinition<TParams, TState>;
    private setTarget;
    /** @public */
    to(turnId: TurnId): this;
    /** @internal */
    complete(): this;
    /** @internal */
    lifecycleStatus(status: ProcessTurnTerminalLifecycleStatus): this;
    /** @internal */
    state(fn: (input: {
        /** @internal */
        ctx: FlowExternalSourceContext<TParams, TState, TEvent, TInput>;
        /** @internal */
        event: TEvent;
        /** @internal */
        input: TInput;
    }) => MaybePromise<TState>): this;
    /** @internal */
    effect(fn: (input: {
        /** @internal */
        ctx: FlowExternalSourceContext<TParams, TState, TEvent, TInput>;
        /** @internal */
        event: TEvent;
        /** @internal */
        input: TInput;
    }) => MaybePromise<ProcessEffectPlan<TState> | undefined>): this;
    /** @internal */
    build(): {
        /** @internal */
        effect?: ExternalSourceEffect<TParams, TState, TEvent, TInput> | undefined;
        /** @internal */
        source: ExternalActionSource<TParams, TState, TEvent, TInput>;
    } | {
        /** @internal */
        effect?: ExternalSourceEffect<TParams, TState, TEvent, TInput> | undefined;
        /** @internal */
        to: TurnId;
        /** @internal */
        source: ExternalActionSource<TParams, TState, TEvent, TInput>;
    } | {
        /** @internal */
        effect?: ExternalSourceEffect<TParams, TState, TEvent, TInput> | undefined;
        /** @internal */
        complete: true;
        /** @internal */
        source: ExternalActionSource<TParams, TState, TEvent, TInput>;
    } | {
        /** @internal */
        effect?: ExternalSourceEffect<TParams, TState, TEvent, TInput> | undefined;
        /** @internal */
        lifecycleStatus: ProcessTurnTerminalLifecycleStatus;
        /** @internal */
        source: ExternalActionSource<TParams, TState, TEvent, TInput>;
    };
}
/** @public */
export declare class ExternalFlowBuilder<TParams = unknown, TState = unknown> extends DescribedTurnBuilder implements FlowExternalTurn<TParams, TState> {
    private routeBuilders;
    /** @internal */
    get definition(): ExternalTurnDefinition<TParams, TState>;
    /** @public */
    from<TEvent = unknown, TInput extends Record<string, unknown> = Record<string, unknown>>(source: ExternalActionSource<TParams, TState, TEvent, TInput>): ExternalRouteBuilder<TParams, TState, TEvent, TInput>;
}
/** @public */
type Hook<TApi> = (api: TApi) => void;
/** @public */
export declare abstract class FlowComponentBuilder<TParams = unknown, TState = unknown> {
    /** @internal */
    readonly turns: FlowTurn<TParams, TState>[];
    /** @internal */
    readonly serverHooks: Hook<ServerProcessAPI<TParams, TState>>[];
    /** @internal */
    readonly uiHooks: Hook<UiProcessAPI<TParams, TState>>[];
    /** @internal */
    readonly launcherHooks: Hook<ProcessLauncherAPI<TParams>>[];
    /** @internal */
    readonly watcherHooks: Hook<ProcessWatcherAPI<TParams>>[];
    /** @public */
    turn(turn: FlowTurn<TParams, TState>): this;
    /** @internal */
    server(hook: Hook<ServerProcessAPI<TParams, TState>>): this;
    /** @internal */
    action(definition: ProcessActionDefinition<TParams, TState>): this;
    /** @internal */
    ui(hook: Hook<UiProcessAPI<TParams, TState>>): this;
    /** @public */
    launcher(definitionOrHook: ProcessLauncherDefinition<TParams> | Hook<ProcessLauncherAPI<TParams>>): this;
    /** @public */
    watcher<TEvent = unknown, TConfig = unknown>(definitionOrHook: ProcessWatcherDefinition<TParams, TEvent, TConfig> | Hook<ProcessWatcherAPI<TParams>>): this;
}
/** @public */
export declare class FlowFragmentBuilder<TParams = unknown, TState = unknown> extends FlowComponentBuilder<TParams, TState> {
    /** @internal */
    readonly name: string;
    /** @internal */
    constructor(name: string);
}
/** @public */
export declare class FlowProcessBuilder<TParams = unknown, TState = unknown> extends FlowComponentBuilder<TParams, TState> {
    private readonly processId;
    private readonly configuration;
    private readonly alternateEntryTurnIds;
    /** @internal */
    constructor(processId: string);
    /** @public */
    displayName(displayName: string): this;
    /** @public */
    entry(turnId: TurnId): this;
    /** Declare an additional turn that launchers may select as the first turn. @internal */
    alternateEntry(turnId: TurnId): this;
    /**
     * Declare the happy path: the ordered spine of turns a successful run walks
     * through. Flow diagrams render this as the main line. Must start at the entry
     * turn and reference only declared turns without repeats.
     */
    /** @public */
    happyPath(...turnIds: readonly TurnId[]): this;
    /** @public */
    codecs(input: {
        /** @public */
        params: Codec<TParams>;
        /** @public */
        state: Codec<TState>;
    }): this;
    /** @public */
    initialState(fn: (params: TParams) => TState): this;
    /** @public */
    repositoryCredentials(fn: NonNullable<ExtensionProcessDefinition<TParams, TState>["repositoryCredentials"]>): this;
    /** Resolve new process-volume capacity on the server; operator configuration wins. @internal */
    resolveStorageSize(fn: NonNullable<ExtensionProcessDefinition<TParams, TState>["resolveStorageSize"]>): this;
    /** @public */
    piConfig(config: ProcessPiConfig): this;
    /** Declare runner-provided process runtime capabilities. @public */
    runtime(capabilities: {
        /** @internal */
        developmentTools?: boolean;
        /** @public */
        docker?: boolean;
        /** @internal */
        repositoryCheckout?: "eager" | "on_demand" | "none";
    }): this;
    /** @internal */
    use(fragment: FlowFragmentBuilder<TParams, TState>): this;
    /** @public */
    define(): ExtensionProcessDefinition<TParams, TState>;
}
/** @public */
export declare const flow: {
    /** @public */
    llm<TParams = unknown, TState = unknown>(turnId: TurnId): LlmFlowBuilder<TParams, TState>;
    /** Run an LLM turn sequentially over frozen items, then collect and route once. @public */
    mappedLlm<TParams = unknown, TState = unknown, TItem = unknown, TResult = unknown>(turnId: TurnId, items: FlowForEachOptions<TParams, TState, TItem, TResult>): MappedLlmFlowBuilder<TParams, TState, TItem, TResult>;
    /** @public */
    automatic<TParams = unknown, TState = unknown>(turnId: TurnId): AutomaticFlowBuilder<TParams, TState>;
    /** @public */
    human<TParams = unknown, TState = unknown>(turnId: TurnId): HumanFlowBuilder<TParams, TState>;
    /** @public */
    external<TParams = unknown, TState = unknown>(turnId: TurnId): ExternalFlowBuilder<TParams, TState>;
    /** @public */
    fragment<TParams = unknown, TState = unknown>(name: string): FlowFragmentBuilder<TParams, TState>;
    /** @public */
    process<TParams = unknown, TState = unknown>(processId: string): FlowProcessBuilder<TParams, TState>;
};
export {};
//# sourceMappingURL=flow.d.ts.map