import type { ScapiConfirmation, ScapiRuntimeControl } from '@salesforce/b2c-tooling-sdk/scapi';
import type { ToolContext, ToolResult } from '../../utils/types.js';
declare function deferred<T>(): {
    promise: Promise<T>;
    resolve: (value: T) => void;
    reject: (reason: Error) => void;
};
interface OperationRecord {
    kind: 'auth' | 'request';
    method?: string;
    path?: string;
    status: 'awaiting_confirmation' | 'completed' | 'failed' | 'in_flight' | 'not_sent' | 'unknown';
    httpStatus?: number;
}
interface ApprovalRound {
    state: string;
    key: string;
    prompt: ToolResult;
    decision: ReturnType<typeof deferred<void>>;
    responded?: boolean;
}
/** One worker survives protocol round trips; none of its code is replayed. */
export declare class ScapiExecution {
    readonly digest: string;
    private readonly supportsElicitation;
    private readonly mintState;
    control?: ScapiRuntimeControl;
    readonly controller: AbortController;
    done: Promise<void>;
    readonly id: `${string}-${string}-${string}-${string}-${string}`;
    readonly operations: OperationRecord[];
    result?: ToolResult;
    readonly rounds: Map<string, ApprovalRound>;
    private cancellation?;
    private cancellationListeners;
    private dispatched;
    private event;
    private pending?;
    private queue;
    constructor(digest: string, supportsElicitation: boolean, mintState: (round: number) => string);
    cancel(reason?: string): void;
    confirm(request: ScapiConfirmation): Promise<void>;
    finish(result: ToolResult): void;
    markDispatched(): void;
    retry(state: string, context: ToolContext): Promise<ToolResult>;
    runCall<T>(kind: OperationRecord['kind'], input: unknown, operation: () => Promise<T>): Promise<T>;
    wait(context?: ToolContext): Promise<ToolResult>;
}
/** Stdio-server-owned continuations. Terminal records are bounded; tokens never start new work. */
export declare class ScapiExecutionRegistry {
    private readonly options;
    private readonly executions;
    private readonly secret;
    constructor(options?: {
        maxActive?: number;
    });
    cancel(id: string): Promise<ToolResult>;
    destroyAll(): Promise<void>;
    retry(args: unknown, context: ToolContext): Promise<ToolResult>;
    start(args: unknown, context: ToolContext | undefined, run: (execution: ScapiExecution) => Promise<ToolResult>): Promise<ToolResult>;
}
export {};