import type { StandardSchemaV1 } from "@standard-schema/spec";
import { type OpenTuiRendererSession } from "./runtime/open-tui-session.js";
export type PromptMode = "inline" | "interactive";
interface BasePromptOptions<TFallback> {
    mode?: PromptMode;
    fallbackValue?: TFallback;
}
export interface PromptOptions extends BasePromptOptions<string> {
    default?: string;
    validate?: (input: string) => boolean | string;
    schema?: StandardSchemaV1;
    placeholder?: string;
    multiline?: boolean;
    charLimit?: number;
    height?: number;
}
export interface ConfirmOptions extends BasePromptOptions<boolean> {
    default?: boolean;
    affirmativeLabel?: string;
    negativeLabel?: string;
    timeout?: number;
}
export interface SelectOption<T = string> {
    label: string;
    value: T;
    hint?: string;
    disabled?: boolean;
}
export interface SelectOptions<T = string> extends BasePromptOptions<T> {
    options: SelectOption<T>[];
    default?: T;
    hint?: string;
}
export interface MultiSelectOptions<T = string> extends BasePromptOptions<T[]> {
    options: SelectOption<T>[];
    min?: number;
    max?: number;
    initialValues?: T[];
    ordered?: boolean;
    height?: number;
}
export interface FilterOptions<T = string> extends BasePromptOptions<T | T[]> {
    options: SelectOption<T>[];
    placeholder?: string;
    prompt?: string;
    multiple?: boolean;
    limit?: number;
    fuzzy?: boolean;
    reverse?: boolean;
    selectIfOne?: boolean;
    height?: number;
}
export interface PagerOptions {
    title?: string;
    showLineNumbers?: boolean;
    height?: number | `${number}%` | "auto";
    width?: number | `${number}%` | "auto";
}
export declare const CANCEL: unique symbol;
export type Cancel = typeof CANCEL | symbol;
interface KeypressEvent {
    name?: string;
    sequence?: string;
    ctrl?: boolean;
    shift?: boolean;
    meta?: boolean;
}
type PromptSymbolMode = "ascii" | "unicode";
declare function resolvePromptSymbolMode(env?: NodeJS.ProcessEnv): PromptSymbolMode;
declare function isCIEnvironmentFromEnv(env: NodeJS.ProcessEnv): boolean;
interface PromptEnvironment {
    stdinIsTTY: boolean;
    stdoutIsTTY: boolean;
    env: NodeJS.ProcessEnv;
}
declare function canPromptInEnvironment(mode: PromptMode | undefined, environment: PromptEnvironment): boolean;
declare function canPrompt(mode?: PromptMode): boolean;
export declare function isCancel(value: unknown): value is Cancel;
export declare class PromptCancelledError extends Error {
    constructor(message?: string);
}
export declare function assertNotCancelled<T>(value: T | Cancel, message?: string): T;
export declare function promptOrExit<T>(value: T | Cancel, message?: string): T;
declare function isCancelKey(key: KeypressEvent): boolean;
declare function isSubmitKey(key: KeypressEvent): boolean;
declare function isPasswordRevealToggleKey(key: KeypressEvent): boolean;
declare function isMultiSelectToggleKey(key: KeypressEvent): boolean;
declare function resolveTextInput(sequence: string): string;
declare function formatQuestionLabel(message: string): string;
declare function formatErrorLine(message: string): string;
declare function formatIntroLine(message: string): string;
declare function formatOutroLine(message: string): string;
declare function formatNoteLines(message: string, title?: string): string[];
declare function renderFrame(lines: string[], prevLineCount: number): number;
declare function renderSelectFrame<T>(args: {
    message: string;
    options: SelectOption<T>[];
    selectedIndex: number;
    hint?: string;
    tick?: number;
}): string[];
declare function renderMultiSelectFrame<T>(args: {
    message: string;
    options: SelectOption<T>[];
    selectedIndex: number;
    selected: Set<T>;
    errorMessage?: string;
    tick?: number;
}): string[];
declare function simulateSelectKeySequence<T>(args: {
    options: SelectOption<T>[];
    keys: KeypressEvent[];
    initialValue?: T;
}): {
    result: T | Cancel | null;
    selectedIndex: number;
};
declare function simulateMultiSelectKeySequence<T>(args: {
    options: SelectOption<T>[];
    keys: KeypressEvent[];
    initialValues?: T[];
    required?: boolean;
}): {
    result: T[] | Cancel | null;
    selectedIndex: number;
    selected: Set<T>;
    errorMessage?: string;
};
declare function simulatePasswordKeySequence(args: {
    keys: KeypressEvent[];
    validate?: (value: string) => string | undefined;
}): {
    result: string | Cancel | null;
    revealed: boolean;
    value: string;
};
declare function initialSelectableIndex<T>(options: SelectOption<T>[], preferred?: T): number;
declare function moveSelectableIndex<T>(options: SelectOption<T>[], currentIndex: number, delta: number): number;
declare function shortcutIndexFromKey(key: KeypressEvent): number | null;
declare function resolveShortcutOption<T>(key: KeypressEvent, options: SelectOption<T>[]): SelectOption<T> | undefined;
declare function buildSelectedSummary<T>(selected: Set<T>, options: SelectOption<T>[]): string;
declare function toggleSelection<T>(selected: Set<T>, option: SelectOption<T>): void;
interface RawSpinner {
    start(text?: string): void;
    stop(text?: string, options?: {
        silent?: boolean;
    }): void;
    message(text: string): void;
}
type RawSpinnerAnimation = "line" | "dots" | "braille";
interface RawSpinnerOptions {
    animation?: RawSpinnerAnimation;
    showTimer?: boolean;
    intervalMs?: number;
}
interface PromptDriver {
    text(args: {
        message: string;
        placeholder?: string;
        defaultValue?: string;
        validate?: (value: string) => string | undefined;
        multiline?: boolean;
        charLimit?: number;
        height?: number;
    }): Promise<string | Cancel>;
    password(args: {
        message: string;
        validate?: (value: string) => string | undefined;
    }): Promise<string | Cancel>;
    confirm(args: {
        message: string;
        initialValue?: boolean;
        affirmativeLabel?: string;
        negativeLabel?: string;
        timeout?: number;
    }): Promise<boolean | Cancel>;
    select<T>(args: {
        message: string;
        options: SelectOption<T>[];
        initialValue?: T;
    }): Promise<T | Cancel>;
    multiselect<T>(args: {
        message: string;
        options: SelectOption<T>[];
        initialValues?: T[];
        required?: boolean;
        ordered?: boolean;
        height?: number;
    }): Promise<T[] | Cancel>;
    filter<T>(args: {
        message: string;
        options: SelectOption<T>[];
        placeholder?: string;
        prompt?: string;
        multiple?: boolean;
        limit?: number;
        fuzzy?: boolean;
        reverse?: boolean;
        selectIfOne?: boolean;
        height?: number;
    }): Promise<T | T[] | Cancel>;
    pager(args: PagerOptions & {
        content: string;
    }): Promise<void>;
    intro(message: string): void;
    outro(message: string): void;
    note(message: string, title?: string): void;
    cancel(message?: string): void;
    log: {
        info(message: string): void;
        success(message: string): void;
        warn(message: string): void;
        error(message: string): void;
    };
    spinner(options?: RawSpinnerOptions): RawSpinner;
}
declare function disposeGlobalOpenTuiSession(): Promise<void>;
declare const runtime: PromptDriver;
export declare function __setPromptRuntimeForTests(overrides: Partial<PromptDriver>): () => void;
export declare const __promptInternalsForTests: {
    shortcutIndexFromKey: typeof shortcutIndexFromKey;
    moveSelectableIndex: typeof moveSelectableIndex;
    initialSelectableIndex: typeof initialSelectableIndex;
    resolveShortcutOption: typeof resolveShortcutOption;
    buildSelectedSummary: typeof buildSelectedSummary;
    toggleSelection: typeof toggleSelection;
    isCancelKey: typeof isCancelKey;
    isSubmitKey: typeof isSubmitKey;
    isPasswordRevealToggleKey: typeof isPasswordRevealToggleKey;
    isMultiSelectToggleKey: typeof isMultiSelectToggleKey;
    formatQuestionLabel: typeof formatQuestionLabel;
    renderFrame: typeof renderFrame;
    renderSelectFrame: typeof renderSelectFrame;
    renderMultiSelectFrame: typeof renderMultiSelectFrame;
    simulateSelectKeySequence: typeof simulateSelectKeySequence;
    simulateMultiSelectKeySequence: typeof simulateMultiSelectKeySequence;
    simulatePasswordKeySequence: typeof simulatePasswordKeySequence;
    formatIntroLine: typeof formatIntroLine;
    formatOutroLine: typeof formatOutroLine;
    formatNoteLines: typeof formatNoteLines;
    formatErrorLine: typeof formatErrorLine;
    canPrompt: typeof canPrompt;
    canPromptInEnvironment: typeof canPromptInEnvironment;
    isCIEnvironmentFromEnv: typeof isCIEnvironmentFromEnv;
    resolvePromptSymbolMode: typeof resolvePromptSymbolMode;
    resolveTextInput: typeof resolveTextInput;
    ensureGlobalOpenTuiSession: () => OpenTuiRendererSession;
    peekGlobalOpenTuiSession: () => OpenTuiRendererSession;
    disposeGlobalOpenTuiSession: typeof disposeGlobalOpenTuiSession;
};
export declare function text<T = string>(message: string, options?: PromptOptions): Promise<T>;
export declare function password<T = string>(message: string, options?: PromptOptions): Promise<T>;
export declare function confirm(message: string, options?: ConfirmOptions): Promise<boolean>;
export declare function select<T = string>(message: string, options: SelectOptions<T>): Promise<T>;
export declare function multiselect<T = string>(message: string, options: MultiSelectOptions<T>): Promise<T[]>;
export declare function filter<T = string>(message: string, options: FilterOptions<T>): Promise<T | T[]>;
export declare function pager(content: string, options?: PagerOptions): Promise<void>;
export declare function group<T extends Record<string, () => Promise<unknown>>>(steps: T): Promise<{
    [K in keyof T]: Awaited<ReturnType<T[K]>>;
}>;
export declare const intro: (...args: Parameters<typeof runtime.intro>) => void;
export declare const outro: (...args: Parameters<typeof runtime.outro>) => void;
export declare const note: (...args: Parameters<typeof runtime.note>) => void;
export declare const log: PromptDriver["log"];
export declare const cancel: (...args: Parameters<typeof runtime.cancel>) => void;
export declare const rawSpinner: (...args: Parameters<typeof runtime.spinner>) => RawSpinner;
export type SpinnerAnimation = RawSpinnerAnimation;
export interface SpinnerOptions {
    text?: string;
    animation?: SpinnerAnimation;
    showTimer?: boolean;
    intervalMs?: number;
}
export interface Spinner {
    start(text?: string): void;
    stop(text?: string): void;
    succeed(text?: string): void;
    fail(text?: string): void;
    warn(text?: string): void;
    info(text?: string): void;
    update(text: string): void;
}
export interface PromptSession {
    initialize: () => Promise<void>;
    prompt: PromptApi;
    spinner: PromptSpinnerFactory;
    dispose: () => Promise<void>;
}
export declare function createPromptSession(): PromptSession;
export interface PromptApi {
    <T = string>(message: string, options?: PromptOptions): Promise<T>;
    confirm(message: string, options?: ConfirmOptions): Promise<boolean>;
    select<T = string>(message: string, options: SelectOptions<T>): Promise<T>;
    password<T = string>(message: string, options?: PromptOptions): Promise<T>;
    text(message: string, options?: PromptOptions): Promise<string>;
    multiselect<T = string>(message: string, options: MultiSelectOptions<T>): Promise<T[]>;
    filter<T = string>(message: string, options: FilterOptions<T>): Promise<T | T[]>;
    pager(content: string, options?: PagerOptions): Promise<void>;
    group<T extends Record<string, () => Promise<unknown>>>(steps: T): Promise<{
        [K in keyof T]: Awaited<ReturnType<T[K]>>;
    }>;
    intro: typeof intro;
    outro: typeof outro;
    note: typeof note;
    log: typeof log;
    cancel: typeof cancel;
    isCancel: typeof isCancel;
    spinner: PromptSpinnerFactory;
}
export type BunliPrompt = PromptApi;
export type PromptSpinnerFactory = (options?: SpinnerOptions | string) => Spinner;
export {};
//# sourceMappingURL=index.d.ts.map