import { InvokePhase } from './invoker.types';
import { ProviderScope, Token } from '@frontmcp/sdk';
import { Scope } from '../scope/scope.instance';
type HistoryEntry<T> = {
    at: number;
    stage?: string;
    phase?: InvokePhase;
    value: T | undefined;
    note?: string;
};
export declare abstract class InvokerContext<TRawIn = unknown, // transport/raw input (HTTP req, DB row, etc.)
InputSchemaType = unknown, // validated input (post-Zod)
OutputSchemaType = unknown, // validated output (post-Zod)
TErr = unknown, TInDraft = Partial<InputSchemaType>, // normalized-but-untrusted input
TOutDraft = Partial<OutputSchemaType>> {
    readonly runId: string;
    data: Map<string, unknown>;
    activeStage?: string;
    phase: InvokePhase;
    readonly startTime: number;
    providers: Map<ProviderScope, Map<import("@frontmcp/sdk").Reference<any>, unknown>>;
    protected _error?: TErr;
    protected _rawInput?: TRawIn;
    protected _inputDraft?: TInDraft;
    protected _input?: InputSchemaType;
    protected _outputDraft?: TOutDraft;
    protected _output?: OutputSchemaType;
    private readonly _rawInputHistory;
    private readonly _inputDraftHistory;
    private readonly _inputHistory;
    private readonly _outputDraftHistory;
    private readonly _outputHistory;
    get scope(): Scope;
    protected constructor(init?: {
        runId?: string;
        rawInput?: TRawIn;
    });
    get rawInput(): TRawIn;
    set rawInput(v: TRawIn | undefined);
    get rawInputHistory(): ReadonlyArray<HistoryEntry<TRawIn>>;
    get inputDraft(): TInDraft | undefined;
    set inputDraft(v: TInDraft | undefined);
    get inputDraftHistory(): ReadonlyArray<HistoryEntry<TInDraft>>;
    get input(): InputSchemaType;
    set input(v: InputSchemaType | undefined);
    get inputHistory(): ReadonlyArray<HistoryEntry<InputSchemaType>>;
    get validatedInput(): InputSchemaType | undefined;
    set validatedInput(v: InputSchemaType | undefined);
    get outputDraft(): TOutDraft | undefined;
    set outputDraft(v: TOutDraft | undefined);
    get outputDraftHistory(): ReadonlyArray<HistoryEntry<TOutDraft>>;
    get output(): OutputSchemaType | undefined;
    set output(v: OutputSchemaType | undefined);
    get outputHistory(): ReadonlyArray<HistoryEntry<OutputSchemaType>>;
    get validatedOutput(): OutputSchemaType | undefined;
    set validatedOutput(v: OutputSchemaType | undefined);
    get error(): unknown | undefined;
    set error(e: TErr | undefined);
    get<T>(token: Token<T>): T;
    bindProvider<T>(token: Token<T>, value: T, scope: ProviderScope): void;
    bindProviders(bindings: [Token, unknown, ProviderScope][]): void;
    /** Signal a control response (invoker will treat as success path and run post/finalize). */
    respond(value: OutputSchemaType): never;
    /** Fail the run (invoker will run error/finalize). */
    fail(err: unknown): never;
    /** Mark current stage & phase (invoker should call this before executing a stage). */
    mark(stage: string, phase: InvokePhase): void;
    private _lastHistory;
}
export {};