@types/inquirer

BaseChoiceMap: BaseChoiceMap<T>[keyof BaseChoiceMap<T>];

CheckboxChoiceMap: CheckboxChoiceMap<T>[keyof CheckboxChoiceMap<T>];

ExpandChoiceMap: ExpandChoiceMap<T>[keyof ExpandChoiceMap<T>];

ListChoiceMap: ListChoiceMap<T>[keyof ListChoiceMap<T>];

Choice: Choice<T>;

ChoiceOptions: ChoiceOptions;

Separator: Separator;

SeparatorOptions: SeparatorOptions;

CheckboxChoiceOptions: CheckboxChoiceOptions<T>;

checked?: boolean | undefined;

type: 'checkbox';

type?: string | undefined;

extra?: any;

name?: string | undefined;

short?: string | undefined;

type?: 'choice' | undefined;

value?: any;

type: 'confirm';

type: 'editor';

postfix?: string;

ExpandChoiceOptions: ExpandChoiceOptions;

key?: string | undefined;

type: 'expand';

type?: 'input' | undefined;

transformer: (
    input: any,
    answers: T,
    flags: { isFinal?: boolean | undefined }
) => string | Promise<string>;

ListChoiceOptions: ListChoiceOptions<T>;

disabled?: DynamicQuestionProperty<boolean | string, T> | undefined;

type: 'list';

type: 'number';

type: 'password';

mask?: string | undefined;

<T extends Answers = Answers>(
    questions: QuestionCollection<T>,
    initialAnswers?: Partial<T>
): Promise<T>;

prompts: inquirer.prompts.PromptCollection;

registerPrompt: (
    name: string,
    prompt: inquirer.prompts.PromptConstructor
) => this;

<T extends Answers = Answers>(
    questions: QuestionCollection<T>,
    initialAnswers?: Partial<T>
): Promise<T> & { ui: inquirer.ui.Prompt<T> };

registerPrompt: (
    name: string,
    prompt: inquirer.prompts.PromptConstructor
) => void;

restoreDefaultPrompts: () => void;

askAnswered?: boolean;

default?: AsyncDynamicQuestionProperty<any, T> | undefined;

message?: AsyncDynamicQuestionProperty<string, T> | undefined;

name?: KeyUnion<T> | undefined;

prefix?: string | undefined;

suffix?: string | undefined;

type?: string | undefined;

when?: AsyncDynamicQuestionProperty<boolean, T> | undefined;

filter: (input: any, answers: T) => any;

validate: (
    input: any,
    answers?: T
) => boolean | string | Promise<boolean | string>;

checkbox: CheckboxQuestion<T>;

confirm: ConfirmQuestion<T>;

editor: EditorQuestion<T>;

expand: ExpandQuestion<T>;

input: InputQuestion<T>;

list: ListQuestion<T>;

number: NumberQuestion<T>;

password: PasswordQuestion<T>;

rawList: RawListQuestion<T>;

type: 'rawlist';

line?: string | undefined;

type: 'separator';

input?: NodeJS.ReadStream | undefined;

output?: NodeJS.WriteStream | undefined;

skipTTYChecks?: boolean | undefined;

let createPromptModule: (opt?: StreamOptions) => PromptModule;

let prompt: PromptModule;

let registerPrompt: (name: string, prompt: prompts.PromptConstructor) => void;

let restoreDefaultPrompts: () => void;

type PromptCollection = Record<string, PromptConstructor>;

type PromptOptions<T extends Question = Question> = T & {
    /**
     * The choices of the prompt.
     */
    choices: Choices;
};

type PromptState = LiteralUnion<
    'pending' | 'idle' | 'loading' | 'answered' | 'done'
>;

type FetchedQuestion<T extends Answers = Answers> = DistinctQuestion<T> & {
    /**
     * The type of the question.
     */
    type: string;

    /**
     * The message to show to the user.
     */
    message: string;

    /**
     * The default value of the question.
     */
    default: any;

    /**
     * The choices of the question.
     */
    choices: ChoiceCollection<T>;
};