import { type Token, type Type } from '@frontmcp/di';
import { type z } from '@frontmcp/lazy-zod';
import type { FrontMcpContext } from '../../context/frontmcp-context';
import { type HookEntry, type ScopeEntry } from '../entries';
import { type FlowMetadata, type FlowName } from '../metadata';
import { type FlowStateOf } from './internal/flow.utils';
import { type FrontMcpLogger } from './logger.interface';
export type FlowInputOf<N extends FlowName> = z.infer<ExtendFlows[N]['input']>;
export type FlowOutputOf<N extends FlowName> = z.infer<ExtendFlows[N]['output']>;
export type FlowPlanOf<N extends FlowName> = ExtendFlows[N]['plan'];
export type FlowCtxOf<N extends FlowName> = ExtendFlows[N]['ctx'];
export type FlowStagesOf<N extends FlowName> = ExtendFlows[N]['stage'];
export type FlowExecuteStagesOf<N extends FlowName> = ExtendFlows[N]['executeStage'];
export type FlowControlType = 'respond' | 'fail' | 'abort' | 'next' | 'handled';
export declare class FlowControl extends Error {
    readonly type: FlowControlType;
    readonly output: any;
    constructor(type: FlowControlType, output: any);
    static respond<T>(output: T): never;
    static next(): never;
    static handled(): never;
    static fail(error: Error): never;
    static abort(reason: string): never;
}
export declare abstract class FlowBase<N extends FlowName = FlowName> {
    protected readonly metadata: FlowMetadata<N>;
    readonly rawInput: Partial<FlowInputOf<N>> | any;
    protected readonly scope: ScopeEntry;
    protected readonly appendContextHooks: (hooks: HookEntry[]) => void;
    protected readonly deps: ReadonlyMap<Token, unknown>;
    protected input: FlowInputOf<N>;
    state: FlowStateOf<N>;
    scopeLogger: FrontMcpLogger;
    constructor(metadata: FlowMetadata<N>, rawInput: Partial<FlowInputOf<N>> | any, scope: ScopeEntry, appendContextHooks: (hooks: HookEntry[]) => void, deps?: ReadonlyMap<Token, unknown>);
    get<T>(token: Token<T>): T;
    respond(output: FlowOutputOf<N>): void;
    fail(error: Error): void;
    protected abort(message: string): void;
    protected next(): void;
    protected handled(): void;
    /**
     * Get the current FrontMcpContext from AsyncLocalStorage.
     * Available in all stages after context initialization.
     *
     * @throws Error if not in a context scope
     */
    protected get context(): FrontMcpContext;
    /**
     * Safely try to get FrontMcpContext (returns undefined if not available).
     * Use this when context might not be available (e.g., non-HTTP flows).
     */
    protected tryGetContext(): FrontMcpContext | undefined;
}
export type FlowType<Provide = FlowBase<any>> = Type<Provide>;
//# sourceMappingURL=flow.interface.d.ts.map