/**
 * UserInteractionCoordinator
 *
 * Manages the AskUserQuestion interaction lifecycle — the "amber dot" feature.
 * When the agent invokes AskUserQuestion, this coordinator:
 *
 * 1. Flushes the current assistant text buffer so the question text appears
 *    above the green answer bubble in the chat history.
 * 2. Stores the interaction data in session state for the frontend to render.
 * 3. Updates the turn status to `awaiting_input` (amber dot in the UI).
 * 4. Returns a Promise that the SDK stream blocks on until the user answers.
 *
 * `respondToInteraction` is called by the facade when the user submits
 * answers through the API. It persists the answers as a structured message
 * and resolves the pending Promise, unblocking the SDK stream.
 *
 * Extracted from `interactive-session.service.ts` in phase 5 of the
 * strangler refactor documented at
 * `docs/plans/2026-04-14-interactive-session-service-refactor.md`.
 */
import type { SessionPersistence } from '../core/session-persistence.js';
import type { StreamEventDispatcher } from '../core/stream-event-dispatcher.js';
import type { SessionRegistry, SessionState } from '../core/session-registry.js';
import type { ILogger } from '../../../../application/ports/output/services/logger.interface.js';
import type { UserInteractionData } from '../../../../application/ports/output/agents/interactive-agent-executor.interface.js';
export declare class UserInteractionCoordinator {
    private readonly persistence;
    private readonly dispatcher;
    private readonly logger;
    private readonly registry;
    constructor(persistence: SessionPersistence, dispatcher: StreamEventDispatcher, logger: ILogger, registry: SessionRegistry);
    /**
     * Build the `onUserQuestion` callback for a session.
     * Called by the SDK's `canUseTool` when the agent invokes AskUserQuestion.
     * Returns a Promise that doesn't resolve until `respondToInteraction` is called.
     */
    buildOnUserQuestionCallback(state: SessionState): (interaction: UserInteractionData) => Promise<Record<string, string>>;
    /**
     * Feature-scoped entry point: looks up the active session state for
     * `featureId` and delegates to `respondToInteraction`. Throws when there
     * is no pending interaction for that feature scope.
     */
    respondToInteractionByFeature(featureId: string, answers: Record<string, string>): Promise<void>;
    /**
     * Called by the facade when the user submits answers through the API.
     * Persists the answers as a structured `{{interaction}}` message,
     * resolves the pending Promise, and resets interaction state.
     *
     * @param state   The live session state (caller must have already looked it up).
     * @param answers Key-value map of question answers.
     */
    respondToInteraction(state: SessionState, answers: Record<string, string>): Promise<void>;
}
//# sourceMappingURL=user-interaction.coordinator.d.ts.map