/**
 * Braille spinner — 10-frame rotation. The smooth gradient between
 * adjacent frames gives it a more "tech" feel than ASCII spinners
 * (| / - \) and renders in any UTF-8 terminal.
 */
export declare const BRAILLE_SPINNER: string[];
/**
 * Quarter-arc spinner — heavier visual weight than Braille, fits
 * better next to text labels when we want the spinner to read as
 * "active state" rather than ambient indicator.
 */
export declare const ARC_SPINNER: string[];
/**
 * Filling-dot sequence — used by transition animations to suggest
 * "powering up" or "settling" without needing rotation.
 */
export declare const POWER_UP: string[];
export declare const POWER_DOWN: string[];
/**
 * Configure animations globally. Called by index.ts after config
 * load + when the user toggles screen-reader mode.
 */
export declare function setAnimationConfig(opts: {
    enabled?: boolean;
    screenReader?: boolean;
}): void;
/**
 * Resolved "should I animate" check. Combines the static config,
 * the screen-reader flag, the env override, and the TTY check.
 */
export declare function animationsEnabled(): boolean;
/**
 * Paint a frame in-place: `\r` (col 0 of current line) + `\x1b[K`
 * (clear to end of line) + the new content. No trailing newline —
 * the next paint or commitFrame() handles that.
 *
 * Exported because some callers (cancel paths, error fallbacks) need
 * to forcibly repaint a line even when animations are off.
 */
export declare function paintFrame(text: string): void;
/**
 * Commit the current in-place frame by emitting a newline. After
 * this the cursor is on a fresh row and the painted frame is locked
 * into the transcript.
 */
export declare function commitFrame(): void;
/**
 * Play a sequence of frames in place at the given period. The
 * promise resolves once the last frame has been painted and the
 * period for it has elapsed.
 *
 * When animations are disabled the function paints ONLY the last
 * frame (no waiting, no intermediate frames) so the screen still
 * settles on the correct final visual.
 *
 * The caller controls whether to commit the final frame: if you
 * want subsequent prints to start on a new row, call commitFrame()
 * after playFrames() resolves. If you want a spinner to take over
 * the same row, leave the frame uncommitted.
 */
export declare function playFrames(frames: string[], periodMs?: number): Promise<void>;
export interface Spinner {
    /** Stop ticking; leave whatever frame is on screen in place. */
    stop(): void;
    /**
     * Stop ticking, overwrite the spinner line with `line`, then emit
     * a newline. Use when a result is ready and you want the row to
     * settle to the final value before moving on.
     */
    stopAndCommit(line: string): void;
}
/**
 * Start an in-place spinner. The `prefixTemplate` is painted each
 * tick with the literal substring "{S}" replaced by the current
 * spinner frame char. Example:
 *
 *     startSpinner("  {S} running bash")
 *
 * paints, in sequence, "  ⠋ running bash", "  ⠙ running bash", …
 *
 * Returns a handle with stop() and stopAndCommit(). Caller MUST
 * invoke one of them — leaving the interval running leaks an event-
 * loop ref and pins the process open.
 *
 * When animations are off: paints the template once with "●" in
 * place of "{S}" and returns a no-op handle. Callers keep working
 * without changes.
 */
export declare function startSpinner(prefixTemplate: string, periodMs?: number): Spinner;