import { AssistantConversationStatus } from './conversation';
import { AssistantTr } from './i18n';
/**
 * Every string the assistant shows while a turn is still working.
 *
 * ★★ RENDERED, NEVER STORED (BOFF-7277). This copy is drawn from the turn's
 * live processing state (`AssistantConversationProcessing.stage`) by
 * `AssistantTurnActivity`; a message's `content` holds only what the model
 * produced or a genuine settled outcome. It used to be written into content,
 * which is how filler reached the history preview, Copy, Export and the preview
 * — and how a reload mid-turn left "Thinking..." standing as an answer forever.
 *
 * ★ Recognising the copy that OLDER builds stored is a separate concern, kept
 * in `legacyFiller.ts` so nothing that runs a turn can reach for it.
 */
export interface StageCopyEntry {
    /** Relative i18n key, resolved through `AssistantTr`. */
    readonly key: string;
    /** English copy, used when the key is unseeded or no provider is mounted. */
    readonly fallback: string;
}
/**
 * The environment steps.
 *
 * ★ These are INFORMATIVE, not filler: each names a different thing the runtime
 * is actually doing, and on a cold start they are the only signal the user gets
 * for 11-15 seconds. They are deliberately NOT part of the rotation — swapping
 * "Starting assistant environment..." for "Pondering..." would trade real
 * progress information for decoration.
 */
export declare const STAGE_COPY: {
    readonly reusingEnvironment: {
        readonly key: "stage.reusingEnvironment";
        readonly fallback: "Reusing assistant environment...";
    };
    readonly lookingForEnvironment: {
        readonly key: "stage.lookingForEnvironment";
        readonly fallback: "Looking for existing environment...";
    };
    readonly startingEnvironment: {
        readonly key: "stage.startingEnvironment";
        readonly fallback: "Starting assistant environment...";
    };
    readonly preparingSession: {
        readonly key: "stage.preparingSession";
        readonly fallback: "Preparing session...";
    };
    readonly connecting: {
        readonly key: "stage.connecting";
        readonly fallback: "Connecting to assistant...";
    };
    readonly thinking: {
        readonly key: "stage.thinking";
        readonly fallback: "Thinking...";
    };
    /**
     * What a turn that ended without producing anything is shown as.
     *
     * ★ Deliberately NOT legacy filler (`legacyFiller.ts`): it is a settled
     * outcome, not a turn still working, and a model can genuinely answer
     * "Stopped the pump at 4pm."
     */
    readonly stopped: {
        readonly key: "stage.stopped";
        readonly fallback: "Stopped";
    };
};
/**
 * Filler shown while the model is working and has produced nothing yet.
 *
 * ★ `thinking` is first so the sequence always opens on the familiar word, and
 * so index 0 is stable for tests. The rest exist because a single frozen
 * "Thinking..." for the length of a turn reads as a hang; a phrase that moves
 * reads as work in progress.
 *
 * ★ Every entry here is machine copy by construction, so legacy recognition
 * covers the whole list rather than a hand-maintained subset.
 */
export declare const THINKING_PHRASES: readonly StageCopyEntry[];
/**
 * How long each phrase holds.
 *
 * ★ Not the poll cadence. Polls land every 600-1500ms
 * (`voice/assistantPollSchedule`), and rotating on every one of them flickers.
 * Rotation is driven by ELAPSED TIME, from the stage's stored origin, so the
 * cadence is independent of how often anything writes.
 */
export declare const PHRASE_ROTATE_MS = 2500;
/** Resolve one entry through the product's translator. */
export declare function stageText(tr: AssistantTr, entry: StageCopyEntry): string;
/**
 * The phrase for a turn that has been working `elapsedMs`.
 *
 * Pure in `elapsedMs` — the caller owns the clock — so the rotation is
 * exercised by tests without faking timers.
 */
export declare function thinkingPhrase(tr: AssistantTr, elapsedMs: number): string;
/**
 * The ENTRY behind `thinkingPhrase` — for a caller that needs to know which
 * key is showing, not just its text. Two keys can translate to the same word,
 * so recovering the entry from the text is ambiguous.
 */
export declare function thinkingPhraseEntry(elapsedMs: number): StageCopyEntry;
/**
 * The copy for a conversation status, when a caller has none of its own.
 *
 * ★ Translated, where the literals it replaces were bare English. The assistant
 * rendering English in every locale is a defect this codebase has already paid
 * for once in the fe-libs shell.
 */
export declare function statusStageCopy(tr: AssistantTr, status: AssistantConversationStatus): string;
//# sourceMappingURL=stageCopy.d.ts.map