@bleedingdev/modern-js-utils 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/compiled/inquirer/index.d.ts

@@ -1,997 +1,800 @@
-// Type definitions for inquirer 8.2
-// Project: https://github.com/SBoudrias/Inquirer.js
-// Definitions by: Qubo <https://github.com/tkQubo>
-//                 Parvez <https://github.com/ppathan>
-//                 Jouderian <https://github.com/jouderianjr>
-//                 Qibang <https://github.com/bang88>
-//                 Jason Dreyzehner <https://github.com/bitjson>
-//                 Synarque <https://github.com/synarque>
-//                 Justin Rockwood <https://github.com/jrockwood>
-//                 Keith Kelly <https://github.com/kwkelly>
-//                 Richard Lea <https://github.com/chigix>
-//                 Jed Mao <https://github.com/jedmao>
-//                 Manuel Thalmann <https://github.com/manuth>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 4.2
-import { Interface as ReadlineInterface } from 'readline';
-import { Observable } from './rxjs';
-import Choice = require('./lib/objects/choice');
-import Choices = require('./lib/objects/choices');
-import Separator = require('./lib/objects/separator');
-import './lib/prompts/base';
-import './lib/prompts/checkbox';
-import './lib/prompts/confirm';
-import './lib/prompts/editor';
-import './lib/prompts/expand';
-import './lib/prompts/input';
-import './lib/prompts/list';
-import './lib/prompts/number';
-import './lib/prompts/password';
-import './lib/prompts/rawlist';
-import './lib/utils/events';
-import './lib/utils/paginator';
-import './lib/utils/readline';
-import './lib/utils/screen-manager';
-import './lib/utils/utils';
-import BottomBar = require('./lib/ui/bottom-bar');
-import PromptUI = require('./lib/ui/prompt');
+import { Duplex } from 'node:stream';
 
 /**
- * Represents a union which preserves autocompletion.
- *
- * @template T
- * The keys which are available for autocompletion.
- *
- * @template F
- * The fallback-type.
+ * `InquirerReadline` is a re-implementation of `readline.Interface` from Node.js.
+ * We're reimplementing it because of 3 reasons:
+ * 1. The `readline.Interface` API is not complete; it's missing for example `clearLine`.
+ * 2. The input/output streams are not generics, meaning they're inexact.
+ * 3. Since ReadLine isn't built-in Typescript Global NodeJS type, it'd force us to ship `@types/node` as a dependency to all users.
  */
-type LiteralUnion<T extends F, F = string> = T | (F & {});
+type InquirerReadline = {
+    output: Duplex & {
+        mute: () => void;
+        unmute: () => void;
+    };
+    input: NodeJS.ReadableStream;
+    clearLine: (dir: 0 | 1 | -1) => void;
+    getCursorPos: () => {
+        rows: number;
+        cols: number;
+    };
+    setPrompt: (prompt: string) => void;
+    line: string;
+    write: (data: string) => void;
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+    removeListener: (event: string, listener: (...args: unknown[]) => void) => void;
+    pause: () => void;
+    resume: () => void;
+    close: () => void;
+};
+type Context = {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    clearPromptOnDone?: boolean;
+    signal?: AbortSignal;
+};
+type Prompt<Value, Config> = (config: Config, context?: Context) => Promise<Value>;
 
 /**
- * Provides prompts for answering questions.
+ * Recursively expand intersections and mapped types for better IDE display,
+ * while preserving functions, arrays, primitives, and types with a string
+ * index signature (e.g. `Record<string, ...>`) as-is.
  */
-interface PromptModuleBase {
-    /**
-     * Registers a new prompt-type.
-     *
-     * @param name
-     * The name of the prompt.
-     *
-     * @param prompt
-     * The constructor of the prompt.
-     */
-    registerPrompt(name: string, prompt: inquirer.prompts.PromptConstructor): void;
+type Prettify<T> = T extends (...args: never[]) => unknown ? T : T extends ReadonlyArray<unknown> ? T : T extends string | number | boolean | symbol | bigint | null | undefined ? T : T extends object ? string extends keyof T ? T : {
+    [K in keyof T]: Prettify<T[K]>;
+} & {} : T;
+type PartialDeep<T> = T extends object ? {
+    [P in keyof T]?: PartialDeep<T[P]>;
+} : T;
+type DistributiveMerge<A, B> = A extends any ? Prettify<Omit<A, keyof B> & B> : never;
 
-    /**
-     * Registers the default prompts.
-     */
-    restoreDefaultPrompts(): void;
-}
+type Keybinding = 'emacs' | 'vim';
 
 /**
- * Represents a list-based question.
- *
- * @template T
- * The type of the answers.
+ * Union type representing the possible statuses of a prompt.
  *
- * @template TChoiceMap
- * The valid choices for the question.
+ * -   `'loading'`: The prompt is currently loading.
+ * -   `'idle'`: The prompt is loaded and currently waiting for the user to
+ *     submit an answer.
+ * -   `'done'`: The user has submitted an answer and the prompt is finished.
+ * -   `string`: Any other string: The prompt is in a custom state.
  */
-interface ListQuestionOptionsBase<T extends inquirer.Answers, TChoiceMap extends inquirer.Answers> extends inquirer.Question<T> {
-    /**
-     * The choices of the prompt.
-     */
-    choices?: inquirer.AsyncDynamicQuestionProperty<ReadonlyArray<inquirer.DistinctChoice<TChoiceMap>>, T> | undefined;
-
+type Status = 'loading' | 'idle' | 'done' | (string & {});
+type DefaultTheme = {
     /**
-     * The number of elements to show on each page.
-     */
-    pageSize?: number | undefined;
-}
-
-/**
- * Provides components for the module.
- */
-declare namespace inquirer {
-    /**
-     * Represents either a key of `T` or a `string`.
+     * Prefix to prepend to the message. If a function is provided, it will be
+     * called with the current status of the prompt, and the return value will be
+     * used as the prefix.
      *
-     * @template T
-     * The type of the keys to suggest.
-     */
-    type KeyUnion<T> = LiteralUnion<Extract<keyof T, string>>;
-
-    /**
-     * Converts the specified union-type `U` to an intersection-type.
+     * @remarks
+     * If `status === 'loading'`, this property is ignored and the spinner (styled
+     * by the `spinner` property) will be displayed instead.
      *
-     * @template U
-     * The union to convert to an intersection.
+     * @defaultValue
+     * ```ts
+     * // import { styleText } from 'node:util';
+     * (status) => status === 'done' ? styleText('green', '✔') : styleText('blue', '?')
+     * ```
      */
-    type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-
+    prefix: string | Prettify<Omit<Record<Status, string>, 'loading'>>;
     /**
-     * Provides an input and an output-stream.
+     * Configuration for the spinner that is displayed when the prompt is in the
+     * `'loading'` state.
+     *
+     * We recommend the use of {@link https://github.com/sindresorhus/cli-spinners|cli-spinners} for a list of available spinners.
      */
-    interface StreamOptions {
+    spinner: {
         /**
-         * A stream to read the input from.
+         * The time interval between frames, in milliseconds.
+         *
+         * @defaultValue
+         * ```ts
+         * 80
+         * ```
          */
-        input?: NodeJS.ReadStream | undefined;
-
+        interval: number;
         /**
-         * A stream to write the output to.
+         * A list of frames to show for the spinner.
+         *
+         * @defaultValue
+         * ```ts
+         * ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+         * ```
          */
-        output?: NodeJS.WriteStream | undefined;
-    }
-
+        frames: string[];
+    };
     /**
-     * Provides the functionality to prompt questions to the user.
+     * Alternative keybindings enabled for prompt navigation.
+     *
+     * @defaultValue
+     * ```ts
+     * process.env['INQUIRER_KEYBINDINGS']
+     * ```
      */
-    interface PromptModule extends PromptModuleBase {
-        /**
-         * The prompts of the prompt-module.
-         */
-        prompts: prompts.PromptCollection;
-
-        /**
-         * Prompts the questions to the user.
-         */
-        <T extends Answers = Answers>(questions: QuestionCollection<T>, initialAnswers?: Partial<T>): Promise<T> & { ui: PromptUI<T> };
-
+    keybindings: ReadonlyArray<Keybinding>;
+    /**
+     * Object containing functions to style different parts of the prompt.
+     */
+    style: {
         /**
-         * Registers a new prompt-type.
+         * Style to apply to the user's answer once it has been submitted.
          *
-         * @param name
-         * The name of the prompt.
+         * @param text - The user's answer.
+         * @returns The styled answer.
          *
-         * @param prompt
-         * The constructor of the prompt.
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', text)
+         * ```
          */
-        registerPrompt(name: string, prompt: prompts.PromptConstructor): this;
-    }
-
-    interface Inquirer extends PromptModuleBase {
+        answer: (text: string) => string;
         /**
-         * Registers a new prompt-type.
+         * Style to apply to the message displayed to the user.
          *
-         * @param name
-         * The name of the prompt.
+         * @param text - The message to style.
+         * @param status - The current status of the prompt.
+         * @returns The styled message.
          *
-         * @param prompt
-         * The constructor of the prompt.
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text, status) => styleText('bold', text)
+         * ```
          */
-        registerPrompt(name: string, prompt: prompts.PromptConstructor): void;
-
+        message: (text: string, status: Status) => string;
         /**
-         * Creates a prompt-module.
+         * Style to apply to error messages.
          *
-         * @param opt
-         * The streams for the prompt-module.
+         * @param text - The error message.
+         * @returns The styled error message.
          *
-         * @returns
-         * The new prompt-module.
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('red', `> ${text}`)
+         * ```
          */
-        createPromptModule(opt?: StreamOptions): PromptModule;
-
-        /**
-         * The default prompt-module.
-         */
-        prompt: PromptModule;
-
+        error: (text: string) => string;
         /**
-         * The prompts of the default prompt-module.
+         * Style to apply to the default answer when one is provided.
          *
-         * @deprecated
-         */
-        prompts: {};
-
-        /**
-         * Represents a choice-item separator.
-         */
-        Separator: typeof Separator;
-
-        /**
-         * Provides ui-components.
-         */
-        ui: {
-            /**
-             * Represents the bottom-bar UI.
-             */
-            BottomBar: typeof BottomBar;
-
-            /**
-             * Represents the prompt ui.
-             */
-            Prompt: typeof PromptUI;
-        };
-    }
-
-    /**
-     * A set of answers.
-     */
-    interface Answers extends Record<string, any> {}
-
-    /**
-     * Provides the functionality to validate answers.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    type Validator<T extends Answers = Answers> = Question<T>['validate'];
-
-    /**
-     * Provides the functionality to transform an answer.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    type Transformer<T extends Answers = Answers> = InputQuestionOptions<T>['transformer'];
-
-    /**
-     * Represents a dynamic property for a question.
-     *
-     * @template T
-     * The type of the property.
-     *
-     * @template TAnswers
-     * The type of the answers.
-     */
-    type DynamicQuestionProperty<T, TAnswers extends Answers = Answers> = T | ((answers: TAnswers) => T);
-
-    /**
-     * Represents a dynamic property for a question which can be fetched asynchronously.
-     *
-     * @template T
-     * The type of the property.
-     *
-     * @template TAnswers
-     * The type of the answers.
-     */
-    type AsyncDynamicQuestionProperty<T, TAnswers extends Answers = Answers> = DynamicQuestionProperty<
-        T | Promise<T>,
-        TAnswers
-    >;
-
-    /**
-     * Provides options for a question.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface Question<T extends Answers = Answers> {
-        /**
-         * The type of the question.
-         */
-        type?: string | undefined;
-
-        /**
-         * The key to save the answer to the answers-hash.
-         */
-        name?: KeyUnion<T> | undefined;
-
-        /**
-         * The message to show to the user.
-         */
-        message?: AsyncDynamicQuestionProperty<string, T> | undefined;
-
-        /**
-         * The default value of the question.
-         */
-        default?: AsyncDynamicQuestionProperty<any, T> | undefined;
-
-        /**
-         * The prefix of the `message`.
-         */
-        prefix?: string | undefined;
-
-        /**
-         * The suffix of the `message`.
+         * @param text - The default answer.
+         * @returns The styled default answer.
+         *
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('dim', `(${text})`)
+         * ```
          */
-        suffix?: string | undefined;
-
+        defaultAnswer: (text: string) => string;
         /**
-         * Post-processes the answer.
+         * Style to apply to help text.
          *
-         * @param input
-         * The answer provided by the user.
+         * @param text - The help text.
+         * @returns The styled help text.
          *
-         * @param answers
-         * The answers provided by the user.
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('dim', text)
+         * ```
          */
-        filter?(input: any, answers: T): any;
-
+        help: (text: string) => string;
         /**
-         * A value indicating whether the question should be prompted.
-         */
-        when?: AsyncDynamicQuestionProperty<boolean, T> | undefined;
-
-        /**
-         * Validates the integrity of the answer.
+         * Style to apply to highlighted text.
          *
-         * @param input
-         * The answer provided by the user.
+         * @param text - The text to highlight.
+         * @returns The highlighted text.
          *
-         * @param answers
-         * The answers provided by the user.
-         *
-         * @returns
-         * Either a value indicating whether the answer is valid or a `string` which describes the error.
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', text)
+         * ```
          */
-        validate?(input: any, answers?: T): boolean | string | Promise<boolean | string>;
-
+        highlight: (text: string) => string;
         /**
-         * Force to prompt the question if the answer already exists.
-         */
-        askAnswered?: boolean;
-    }
-
-    /**
-     * Represents the possible answers of each question in the prompt
-     */
-    type QuestionAnswer<T extends Answers = Answers> = {
-        [K in keyof T]: {
-            name: K;
-            answer: T[K]
-        }
-    }[keyof T];
-
-    /**
-     * Represents a choice-item.
-     */
-    interface ChoiceBase {
-        /**
-         * The type of the choice.
-         */
-        type?: string | undefined;
-    }
-
-    /**
-     * Provides options for a choice.
-     */
-    interface ChoiceOptions extends ChoiceBase {
-        /**
-         * @inheritdoc
-         */
-        type?: 'choice' | undefined;
-
-        /**
-         * The name of the choice to show to the user.
-         */
-        name?: string | undefined;
-
-        /**
-         * The value of the choice.
-         */
-        value?: any;
-
-        /**
-         * The short form of the name of the choice.
-         */
-        short?: string | undefined;
-
-        /**
-         * The extra properties of the choice.
-         */
-        extra?: any;
-    }
-
-    /**
-     * Provides options for a choice of the `ListPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ListChoiceOptions<T extends Answers = Answers> extends ChoiceOptions {
-        /**
-         * A value indicating whether the choice is disabled.
-         */
-        disabled?: DynamicQuestionProperty<boolean | string, T> | undefined;
-    }
-
-    /**
-     * Provides options for a choice of the `CheckboxPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface CheckboxChoiceOptions<T extends Answers = Answers> extends ListChoiceOptions<T> {
-        /**
-         * A value indicating whether the choice should be initially checked.
-         */
-        checked?: boolean | undefined;
-    }
-
-    /**
-     * Provides options for a choice of the `ExpandPrompt`.
-     */
-    interface ExpandChoiceOptions extends ChoiceOptions {
-        /**
-         * The key to press for selecting the choice.
-         */
-        key?: string | undefined;
-    }
-
-    /**
-     * Represents a separator.
-     */
-    interface SeparatorOptions extends ChoiceBase {
-        /**
-         * Gets the type of the choice.
-         */
-        type: 'separator';
-
-        /**
-         * Gets or sets the text of the separator.
-         */
-        line?: string | undefined;
-    }
-
-    /**
-     * Provides all valid choice-types for any kind of question.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface BaseChoiceMap<T extends Answers = Answers> {
-        Choice: Choice<T>;
-        ChoiceOptions: ChoiceOptions;
-        SeparatorOptions: SeparatorOptions;
-        Separator: Separator;
-    }
-
-    /**
-     * Provides all valid choice-types for the `ListQuestion`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ListChoiceMap<T extends Answers = Answers> extends BaseChoiceMap<T> {
-        ListChoiceOptions: ListChoiceOptions<T>;
-    }
-
-    /**
-     * Provides all valid choice-types for the `CheckboxQuestion`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface CheckboxChoiceMap<T extends Answers = Answers> extends BaseChoiceMap<T> {
-        CheckboxChoiceOptions: CheckboxChoiceOptions<T>;
-    }
-
-    /**
-     * Provides all valid choice-types for the `ExpandQuestion`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ExpandChoiceMap<T extends Answers = Answers> extends BaseChoiceMap<T> {
-        ExpandChoiceOptions: ExpandChoiceOptions;
-    }
-
-    /**
-     * Provides all valid choice-types.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface AllChoiceMap<T extends Answers = Answers> {
-        BaseChoiceMap: BaseChoiceMap<T>[keyof BaseChoiceMap<T>];
-        ListChoiceMap: ListChoiceMap<T>[keyof ListChoiceMap<T>];
-        CheckboxChoiceMap: CheckboxChoiceMap<T>[keyof CheckboxChoiceMap<T>];
-        ExpandChoiceMap: ExpandChoiceMap<T>[keyof ExpandChoiceMap<T>];
-    }
-
-    /**
-     * Provides valid choices for the question of the `TChoiceMap`.
-     *
-     * @template TAnswers
-     * The type of the answers.
-     *
-     * @template TChoiceMap
-     * The choice-types to provide.
-     */
-    type DistinctChoice<TAnswers extends Answers = Answers, TChoiceMap = AllChoiceMap<TAnswers>> =
-        | string
-        | TChoiceMap[keyof TChoiceMap];
-
-    /**
-     * Represents a set of choices.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    type ChoiceCollection<T extends Answers = Answers> = Array<DistinctChoice<AllChoiceMap<T>>>;
-
-    /**
-     * Provides options for a question for the `InputPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface InputQuestionOptions<T extends Answers = Answers> extends Question<T> {
-        /**
-         * Transforms the value to display to the user.
+         * Style to apply to keyboard keys referred to in help texts.
          *
-         * @param input
-         * The input provided by the user.
+         * @param text - The key to style.
+         * @returns The styled key.
          *
-         * @param answers
-         * The answers provided by the users.
-         *
-         * @param flags
-         * Additional information about the value.
-         *
-         * @returns
-         * The value to display to the user.
+         * @defaultValue
+         * ```ts
+         * // import { styleText } from 'node:util';
+         * (text) => styleText('cyan', styleText('bold', `<${text}>`))
+         * ```
          */
-        transformer?(input: any, answers: T, flags: { isFinal?: boolean | undefined }): string | Promise<string>;
-    }
+        key: (text: string) => string;
+    };
+};
+type Theme<Extension extends object = object> = Extension & DefaultTheme;
 
-    /**
-     * Provides options for a question for the `InputPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface InputQuestion<T extends Answers = Answers> extends InputQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type?: 'input' | undefined;
-    }
-
-    /**
-     * Provides options for a question for the `NumberPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface NumberQuestionOptions<T extends Answers = Answers> extends InputQuestionOptions<T> {}
-
-    /**
-     * Provides options for a question for the `NumberPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface NumberQuestion<T extends Answers = Answers> extends NumberQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'number';
-    }
-
-    /**
-     * Provides options for a question for the `PasswordPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface PasswordQuestionOptions<T extends Answers = Answers> extends InputQuestionOptions<T> {
-        /**
-         * The character to replace the user-input.
-         */
-        mask?: string | undefined;
-    }
-
-    /**
-     * Provides options for a question for the `PasswordPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface PasswordQuestion<T extends Answers = Answers> extends PasswordQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'password';
-    }
-
-    /**
-     * Represents a list-based question that can loop.
-     *
-     * @template T
-     * The type of the answers.
-     *
-     * @template TChoiceMap
-     * The valid choices for the question.
-     */
-    interface LoopableListQuestionOptionsBase<T extends Answers, TChoiceMap extends Answers> extends ListQuestionOptionsBase<T, TChoiceMap> {
-        /**
-         * A value indicating whether choices in a list should be looped.
-         */
-        loop?: boolean | undefined;
-    }
-
-    /**
-     * Provides options for a question for the `ListPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ListQuestionOptions<T extends Answers = Answers>
-        extends LoopableListQuestionOptionsBase<T, ListChoiceMap<T>> {}
-
-    /**
-     * Provides options for a question for the `ListPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ListQuestion<T extends Answers = Answers> extends ListQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'list';
-    }
-
-    /**
-     * Provides options for a question for the `RawListPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface RawListQuestionOptions<T extends Answers = Answers> extends ListQuestionOptions<T> {}
-
-    /**
-     * Provides options for a question for the `RawListPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface RawListQuestion<T extends Answers = Answers> extends RawListQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'rawlist';
-    }
-
-    /**
-     * Provides options for a question for the `ExpandPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ExpandQuestionOptions<T extends Answers = Answers>
-        extends ListQuestionOptionsBase<T, ExpandChoiceMap<T>> {}
-
-    /**
-     * Provides options for a question for the `ExpandPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ExpandQuestion<T extends Answers = Answers> extends ExpandQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'expand';
-    }
-
-    /**
-     * Provides options for a question for the `CheckboxPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface CheckboxQuestionOptions<T extends Answers = Answers>
-        extends LoopableListQuestionOptionsBase<T, CheckboxChoiceMap<T>> {}
-
-    /**
-     * Provides options for a question for the `CheckboxPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface CheckboxQuestion<T extends Answers = Answers> extends CheckboxQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'checkbox';
-    }
-
-    /**
-     * Provides options for a question for the `ConfirmPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ConfirmQuestionOptions<T extends Answers = Answers> extends Question<T> {}
-
-    /**
-     * Provides options for a question for the `ConfirmPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface ConfirmQuestion<T extends Answers = Answers> extends ConfirmQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'confirm';
-    }
-
-    /**
-     * Provides options for a question for the `EditorPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface EditorQuestionOptions<T extends Answers = Answers> extends Question<T> {}
+/**
+ * Separator object
+ * Used to space/separate choices group
+ */
+declare class Separator {
+    readonly separator: string;
+    readonly type: string;
+    constructor(separator?: string);
+    static isSeparator(choice: unknown): choice is Separator;
+}
 
-    /**
-     * Provides options for a question for the `EditorPrompt`.
-     *
-     * @template T
-     * The type of the answers.
-     */
-    interface EditorQuestion<T extends Answers = Answers> extends EditorQuestionOptions<T> {
-        /**
-         * @inheritdoc
-         */
-        type: 'editor';
+type CheckboxTheme = {
+    icon: {
+        checked: string;
+        unchecked: string;
+        cursor: string;
+        disabledChecked: string;
+        disabledUnchecked: string;
+    };
+    style: {
+        disabled: (text: string) => string;
+        renderSelectedChoices: <T>(selectedChoices: ReadonlyArray<NormalizedChoice<T>>, allChoices: ReadonlyArray<NormalizedChoice<T> | Separator>) => string;
+        description: (text: string) => string;
+        keysHelpTip: (keys: [key: string, action: string][]) => string | undefined;
+    };
+    i18n: {
+        disabledError: string;
+    };
+};
+type CheckboxShortcuts = {
+    all?: string | null;
+    invert?: string | null;
+};
+type Choice$4<Value> = {
+    value: Value;
+    name?: string;
+    checkedName?: string;
+    description?: string;
+    short?: string;
+    disabled?: boolean | string;
+    checked?: boolean;
+    type?: never;
+};
+type NormalizedChoice<Value> = {
+    value: Value;
+    name: string;
+    checkedName: string;
+    description?: string;
+    short: string;
+    disabled: boolean | string;
+    checked: boolean;
+};
+type CheckboxConfig<Value = string> = {
+    message: string;
+    prefix?: string;
+    pageSize?: number;
+    choices: ReadonlyArray<Value | Choice$4<Value> | Separator>;
+    loop?: boolean;
+    required?: boolean;
+    validate?: (choices: readonly NormalizedChoice<Value>[]) => boolean | string | Promise<string | boolean>;
+    theme?: PartialDeep<Theme<CheckboxTheme>>;
+    shortcuts?: CheckboxShortcuts;
+};
+declare const _default$8: <const Value>(config: {
+    message: string;
+    prefix?: string | undefined;
+    pageSize?: number | undefined;
+    choices: readonly (Separator | Value | Choice$4<Value>)[];
+    loop?: boolean | undefined;
+    required?: boolean | undefined;
+    validate?: ((choices: readonly NormalizedChoice<Value>[]) => boolean | string | Promise<string | boolean>) | undefined;
+    theme?: PartialDeep<Theme<CheckboxTheme>> | undefined;
+    shortcuts?: CheckboxShortcuts | undefined;
+} & CheckboxConfig<Value>, context?: Context) => Promise<Value[]>;
+
+type FileOptions = {
+    prefix?: string;
+    postfix?: string;
+    mode?: number;
+    template?: string;
+    dir?: string;
+};
+
+type EditorTheme = {
+    validationFailureMode: 'keep' | 'clear';
+    style: {
+        loadingMessage: () => string;
+        waitingMessage: (enterKey: string) => string;
+    };
+};
+type EditorConfig = {
+    message: string;
+    default?: string | undefined;
+    postfix?: string;
+    waitForUserInput?: boolean;
+    validate?: (value: string) => boolean | string | Promise<string | boolean>;
+    file?: FileOptions;
+    theme?: PartialDeep<Theme<EditorTheme>>;
+};
+declare const _default$7: Prompt<string, {
+    message: string;
+    default?: string | undefined | undefined;
+    postfix?: string | undefined;
+    waitForUserInput?: boolean | undefined;
+    validate?: ((value: string) => boolean | string | Promise<string | boolean>) | undefined;
+    file?: FileOptions | undefined;
+    theme?: PartialDeep<Theme<EditorTheme>> | undefined;
+} & EditorConfig>;
+
+type ConfirmConfig = {
+    message: string;
+    default?: boolean | undefined;
+    transformer?: (value: boolean) => string;
+    theme?: PartialDeep<Theme<ConfirmTheme>>;
+};
+type ConfirmTheme = {
+    /**
+     * Words accepted as "yes" and "no" answers. Matching is prefix-based and
+     * case-insensitive, and the first character of each word is shown in the
+     * hint. These words are also displayed once the prompt is answered.
+     * Regardless of these keywords, the built-in `y`/`n`/`yes`/`no` answers are
+     * always accepted.
+     */
+    keywords: {
+        yes: string;
+        no: string;
+        /**
+         * Message shown when the submitted input matches no keyword. Receives the
+         * yes/no keywords; this is how `@inquirer/i18n` localizes the message.
+         */
+        error: (keywords: {
+            yes: string;
+            no: string;
+        }) => string;
+    };
+    style: {
+        /**
+         * Style the character representing the default answer in the hint (e.g.
+         * "Y/n"). Uppercases it by default; scripts without case (e.g. Chinese)
+         * are highlighted with a color instead.
+         */
+        confirmDefault: (text: string) => string;
+    };
+};
+declare const _default$6: Prompt<boolean, {
+    message: string;
+    default?: boolean | undefined | undefined;
+    transformer?: ((value: boolean) => string) | undefined;
+    theme?: PartialDeep<Theme<ConfirmTheme>> | undefined;
+} & ConfirmConfig>;
+
+type InputTheme = {
+    validationFailureMode: 'keep' | 'clear';
+};
+type InputConfig = {
+    message: string;
+    default?: string | undefined;
+    prefill?: 'tab' | 'editable';
+    required?: boolean;
+    transformer?: (value: string, { isFinal }: {
+        isFinal: boolean;
+    }) => string;
+    validate?: (value: string) => boolean | string | Promise<string | boolean>;
+    theme?: PartialDeep<Theme<InputTheme>>;
+    pattern?: RegExp;
+    patternError?: string;
+};
+declare const _default$5: Prompt<string, {
+    message: string;
+    default?: string | undefined | undefined;
+    prefill?: "tab" | "editable" | undefined;
+    required?: boolean | undefined;
+    transformer?: ((value: string, { isFinal }: {
+        isFinal: boolean;
+    }) => string) | undefined;
+    validate?: ((value: string) => boolean | string | Promise<string | boolean>) | undefined;
+    theme?: PartialDeep<Theme<InputTheme>> | undefined;
+    pattern?: RegExp | undefined;
+    patternError?: string | undefined;
+} & InputConfig>;
+
+type NumberConfig<Required extends boolean = boolean> = {
+    message: string;
+    default?: number | undefined;
+    min?: number;
+    max?: number;
+    step?: number | 'any';
+    required?: Required;
+    validate?: (value: Required extends true ? number : number | undefined) => boolean | string | Promise<string | boolean>;
+    theme?: PartialDeep<Theme>;
+};
+declare const _default$4: <Required extends boolean>(config: {
+    message: string;
+    default?: number | undefined | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    step?: number | "any" | undefined;
+    required?: Required | undefined;
+    validate?: ((value: Required extends true ? number : number | undefined) => boolean | string | Promise<string | boolean>) | undefined;
+    theme?: PartialDeep<Theme> | undefined;
+} & NumberConfig<Required>, context?: Context) => Promise<Required extends true ? number : number | undefined>;
+
+type Key = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type Choice$3<Value> = {
+    key: Key;
+    value: Value;
+} | {
+    key: Key;
+    name: string;
+    value: Value;
+};
+type ExpandConfig<Value = string> = {
+    message: string;
+    choices: readonly (Separator | {
+        key: Key;
+        name: Value & string;
+        value?: never;
+    } | Choice$3<Value>)[];
+    default?: Key | 'h';
+    expanded?: boolean;
+    theme?: PartialDeep<Theme>;
+};
+declare const expand: <const Value>(config: {
+    message: string;
+    choices: readonly (Separator | {
+        key: Key;
+        name: Value & string;
+        value?: never;
+    } | Choice$3<Value>)[];
+    default?: (Key | "h") | undefined;
+    expanded?: boolean | undefined;
+    theme?: PartialDeep<Theme> | undefined;
+} & ExpandConfig<Value>, context?: Context) => Promise<Value>;
+
+type RawlistTheme = {
+    style: {
+        description: (text: string) => string;
+    };
+};
+type Choice$2<Value> = {
+    value: Value;
+    name?: string;
+    short?: string;
+    key?: string;
+    description?: string;
+};
+type RawlistConfig<Value> = {
+    message: string;
+    choices: ReadonlyArray<Value | Choice$2<Value> | Separator>;
+    loop?: boolean;
+    theme?: PartialDeep<Theme<RawlistTheme>>;
+    default?: NoInfer<Value>;
+};
+declare const _default$3: <const Value>(config: {
+    message: string;
+    choices: readonly (Separator | Value | Choice$2<Value>)[];
+    loop?: boolean | undefined;
+    theme?: PartialDeep<Theme<RawlistTheme>> | undefined;
+    default?: NoInfer<Value> | undefined;
+} & RawlistConfig<Value>, context?: Context) => Promise<Value>;
+
+type PasswordTheme = {
+    style: {
+        maskedText: string;
+        keysHelpTip: (keys: [key: string, action: string][]) => string | undefined;
+    };
+};
+type PasswordConfig = {
+    message: string;
+    mask?: boolean | string;
+    toggleMask?: boolean;
+    validate?: (value: string) => boolean | string | Promise<string | boolean>;
+    theme?: PartialDeep<Theme<PasswordTheme>>;
+};
+declare const _default$2: Prompt<string, {
+    message: string;
+    mask?: boolean | string | undefined;
+    toggleMask?: boolean | undefined;
+    validate?: ((value: string) => boolean | string | Promise<string | boolean>) | undefined;
+    theme?: PartialDeep<Theme<PasswordTheme>> | undefined;
+} & PasswordConfig>;
+
+type SearchTheme = {
+    icon: {
+        cursor: string;
+    };
+    style: {
+        disabled: (text: string) => string;
+        searchTerm: (text: string) => string;
+        description: (text: string) => string;
+        keysHelpTip: (keys: [key: string, action: string][]) => string | undefined;
+    };
+};
+type Choice$1<Value> = {
+    value: Value;
+    name?: string;
+    description?: string;
+    short?: string;
+    disabled?: boolean | string;
+    type?: never;
+};
+type SearchConfig<Value = string> = {
+    message: string;
+    source: (term: string | undefined, opt: {
+        signal: AbortSignal;
+    }) => ReadonlyArray<Value | Choice$1<Value> | Separator> | Promise<ReadonlyArray<Value | Choice$1<Value> | Separator>>;
+    validate?: (value: Value) => boolean | string | Promise<string | boolean>;
+    pageSize?: number;
+    default?: NoInfer<Value>;
+    initialValue?: string;
+    theme?: PartialDeep<Theme<SearchTheme>>;
+};
+declare const _default$1: <const Value>(config: {
+    message: string;
+    source: (term: string | undefined, opt: {
+        signal: AbortSignal;
+    }) => readonly (Separator | Value | Choice$1<Value>)[] | Promise<readonly (Separator | Value | Choice$1<Value>)[]>;
+    validate?: ((value: Value) => boolean | string | Promise<string | boolean>) | undefined;
+    pageSize?: number | undefined;
+    default?: NoInfer<Value> | undefined;
+    initialValue?: string | undefined;
+    theme?: PartialDeep<Theme<SearchTheme>> | undefined;
+} & SearchConfig<Value>, context?: Context) => Promise<Value>;
+
+type SelectTheme = {
+    icon: {
+        cursor: string;
+    };
+    style: {
+        disabled: (text: string) => string;
+        description: (text: string) => string;
+        keysHelpTip: (keys: [key: string, action: string][]) => string | undefined;
+    };
+    i18n: {
+        disabledError: string;
+    };
+    indexMode: 'hidden' | 'number';
+};
+type Choice<Value> = {
+    value: Value;
+    name?: string;
+    description?: string;
+    short?: string;
+    disabled?: boolean | string;
+    type?: never;
+};
+type SelectConfig<Value> = {
+    message: string;
+    choices: ReadonlyArray<Value | Choice<Value> | Separator>;
+    pageSize?: number;
+    loop?: boolean;
+    default?: NoInfer<Value>;
+    theme?: PartialDeep<Theme<SelectTheme>>;
+};
+declare const _default: <const Value>(config: {
+    message: string;
+    choices: readonly (Separator | Value | Choice<Value>)[];
+    pageSize?: number | undefined;
+    loop?: boolean | undefined;
+    default?: NoInfer<Value> | undefined;
+    theme?: PartialDeep<Theme<SelectTheme>> | undefined;
+} & SelectConfig<Value>, context?: Context) => Promise<Value>;
+
+type NextHandler<T> = (value: T) => void;
+type ErrorHandler = (error: unknown) => void;
+type CompleteHandler = () => void;
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
     }
-
+}
+type Observer<T> = {
+    next?: NextHandler<T>;
+    error?: ErrorHandler;
+    complete?: CompleteHandler;
+};
+type SubscriptionLike = {
+    closed?: boolean;
+    unsubscribe: () => void;
+};
+type Observable<T> = {
+    subscribe: {
+        (observer: Observer<T>): SubscriptionLike;
+        (next?: NextHandler<T> | null, error?: ErrorHandler | null, complete?: CompleteHandler | null): SubscriptionLike;
+    };
+};
+type InteropObservable<T> = Observable<T> & AsyncIterable<T> & {
+    readonly [Symbol.observable]: () => Observable<T>;
+    readonly '@@observable': () => Observable<T>;
+};
+
+type Answers<Key extends string = string> = Record<Key, any>;
+type NoInfer$1<T> = [T][T extends any ? 0 : never];
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
+type EmptyRecord = Record<string, never>;
+type DotPathRecord<Path extends string, Value> = Path extends `${infer Head}.${infer Rest}` ? Head extends '' ? EmptyRecord : {
+    [K in Head]: DotPathRecord<Rest, Value>;
+} : Path extends '' ? EmptyRecord : {
+    [K in Path]: Value;
+};
+type NormalizeAnswers<A extends Answers> = string extends keyof A ? A : Extract<keyof A, string> extends never ? EmptyRecord : Prettify<UnionToIntersection<{
+    [Key in Extract<keyof A, string>]: DotPathRecord<Key, [
+        A[Key]
+    ] extends [never] ? any : A[Key]>;
+}[Extract<keyof A, string>]>>;
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type WidenAnswerLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T extends ReadonlyArray<infer U> ? ReadonlyArray<WidenAnswerLiterals<U>> : T extends Array<infer U> ? Array<WidenAnswerLiterals<U>> : T extends Record<string, unknown> ? {
+    [K in keyof Mutable<T>]: Mutable<T>[K] extends infer V ? V extends undefined ? never : WidenAnswerLiterals<V> : never;
+} : T;
+type MergeAnswerObjects<Base, Override> = Prettify<Omit<Base, keyof Override> & Override>;
+type AsyncGetterFunction<T, A extends Answers> = (this: {
+    async: () => (...args: [error: null | undefined, value: T] | [error: Error, value: undefined]) => void;
+}, answers: NoInfer$1<Partial<A>>) => void | T | Promise<T>;
+type MaybeAsyncValue<T, A extends Answers> = T | AsyncGetterFunction<T, A>;
+/**
+ * Allows to inject a custom question type into inquirer module.
+ *
+ * @example
+ * ```ts
+ * declare module 'inquirer' {
+ *   interface QuestionMap {
+ *     custom: { message: string };
+ *   }
+ * }
+ * ```
+ *
+ * Globally defined question types are not correct.
+ */
+interface QuestionMap {
+    __dummy: {
+        message: string;
+    };
+}
+type KeyValueOrAsyncGetterFunction<T, k extends string, A extends Answers> = T extends Record<string, any> ? MaybeAsyncValue<T[k], A> : never;
+type Question<A extends Answers = Answers, Type extends string = string> = {
+    type?: Type;
+    name: string;
+    message: MaybeAsyncValue<string, A>;
+    default?: any;
+    choices?: any;
+    validate?: (value: any, answers: NoInfer$1<Partial<A>>) => boolean | string | Promise<boolean | string>;
+    filter?: (answer: any, answers: NoInfer$1<Partial<A>>) => any;
+    askAnswered?: boolean;
+    when?: MaybeAsyncValue<boolean, A>;
+};
+type QuestionWithGetters<Type extends string, Q extends Record<string, any>, A extends Answers> = DistributiveMerge<Q, {
+    type: Type;
+    askAnswered?: boolean;
+    when?: MaybeAsyncValue<boolean, A>;
+    filter?(input: any, answers: NoInfer$1<A>): any;
+    message: KeyValueOrAsyncGetterFunction<Q, 'message', A>;
+    default?: KeyValueOrAsyncGetterFunction<Q, 'default', A>;
+    choices?: KeyValueOrAsyncGetterFunction<Q, 'choices', A>;
+}>;
+type UnnamedDistinctQuestion<A extends Answers = object> = QuestionWithGetters<'checkbox', Parameters<typeof _default$8>[0] & {
+    default: unknown[];
+}, A> | QuestionWithGetters<'confirm', Parameters<typeof _default$6>[0], A> | QuestionWithGetters<'editor', Parameters<typeof _default$7>[0], A> | QuestionWithGetters<'expand', Parameters<typeof expand>[0], A> | QuestionWithGetters<'input', Parameters<typeof _default$5>[0], A> | QuestionWithGetters<'number', Parameters<typeof _default$4>[0], A> | QuestionWithGetters<'password', Parameters<typeof _default$2>[0], A> | QuestionWithGetters<'rawlist', Parameters<typeof _default$3>[0], A> | QuestionWithGetters<'search', Parameters<typeof _default$1>[0], A> | QuestionWithGetters<'select', Parameters<typeof _default>[0], A>;
+type CustomQuestion<A extends Answers, Q extends Record<string, Record<string, any>>> = {
+    [key in Extract<keyof Q, string>]: Readonly<QuestionWithGetters<key, Q[key], A>>;
+}[Extract<keyof Q, string>];
+type PromptModuleSpecificQuestion<A extends Answers, Prompts extends Record<string, Record<string, any>> = never> = UnnamedDistinctQuestion<A> | CustomQuestion<A, Prompts>;
+type PromptModuleNamedQuestion<A extends Answers, Prompts extends Record<string, Record<string, any>> = never, Flat extends Answers = A> = PromptModuleSpecificQuestion<A, Prompts> & {
+    name: Extract<keyof Flat, string>;
+};
+type DistinctQuestion<A extends Answers = Answers> = PromptModuleNamedQuestion<A>;
+type PromptSession<A extends Answers = Answers, Q extends Question<A> = Question<A>> = readonly Q[] | Record<string, Omit<Q, 'name'>> | Observable<Q> | Q;
+type QuestionSequence<Q> = Q | readonly Q[] | Observable<Q>;
+type MergedAnswers<A extends Answers, Prefilled extends Answers> = MergeAnswerObjects<NormalizeAnswers<A>, WidenAnswerLiterals<Prefilled>>;
+type DictionaryAnswers<A extends Answers, Prefilled extends Answers> = MergeAnswerObjects<NormalizeAnswers<Answers<Extract<keyof A, string>>>, WidenAnswerLiterals<Prefilled>>;
+type PromptModulePublicQuestion<A extends Answers, Flat extends Answers = A> = {
+    type?: 'input' | 'confirm' | 'editor' | 'password' | 'number' | 'rawlist' | 'expand' | 'checkbox' | 'search' | 'select';
+    name: Extract<keyof Flat, string>;
+    message: MaybeAsyncValue<string, A>;
+    default?: unknown;
+    choices?: unknown;
+    filter?: (input: any, answers: NoInfer$1<Partial<A>>) => any;
+    askAnswered?: boolean;
+    when?: MaybeAsyncValue<boolean, A>;
+} & Record<string, unknown>;
+type StreamOptions = Prettify<Context & {
+    skipTTYChecks?: boolean;
+}>;
+
+interface PromptBase {
+    /**
+     * Runs the prompt.
+     *
+     * @returns
+     * The result of the prompt.
+     */
+    run(): Promise<any>;
+}
+/**
+ * Provides the functionality to initialize new prompts.
+ */
+interface LegacyPromptConstructor {
     /**
-     * Provides the available question-types.
+     * Initializes a new instance of a prompt.
      *
-     * @template T
-     * The type of the answers.
-     */
-    interface QuestionMap<T extends Answers = Answers> {
-        /**
-         * The `InputQuestion` type.
-         */
-        input: InputQuestion<T>;
-
-        /**
-         * The `NumberQuestion` type.
-         */
-        number: NumberQuestion<T>;
-
-        /**
-         * The `PasswordQuestion` type.
-         */
-        password: PasswordQuestion<T>;
-
-        /**
-         * The `ListQuestion` type.
-         */
-        list: ListQuestion<T>;
-
-        /**
-         * The `RawListQuestion` type.
-         */
-        rawList: RawListQuestion<T>;
-
-        /**
-         * The `ExpandQuestion` type.
-         */
-        expand: ExpandQuestion<T>;
-
-        /**
-         * The `CheckboxQuestion` type.
-         */
-        checkbox: CheckboxQuestion<T>;
-
-        /**
-         * The `ConfirmQuestion` type.
-         */
-        confirm: ConfirmQuestion<T>;
-
-        /**
-         * The `EditorQuestion` type.
-         */
-        editor: EditorQuestion<T>;
-    }
-
-    /**
-     * Represents one of the available questions.
+     * @param question
+     * The question to prompt.
      *
-     * @template T
-     * The type of the answers.
-     */
-    type DistinctQuestion<T extends Answers = Answers> = QuestionMap<T>[keyof QuestionMap<T>];
-
-    /**
-     * Indicates the type of a question
-     */
-    type QuestionTypeName = DistinctQuestion['type'];
-
-    /**
-     * Represents a collection of questions.
+     * @param readLine
+     * An object for reading from the command-line.
      *
-     * @template T
-     * The type of the answers.
-     */
-    type QuestionCollection<T extends Answers = Answers> =
-        | DistinctQuestion<T>
-        | ReadonlyArray<DistinctQuestion<T>>
-        | Observable<DistinctQuestion<T>>;
-
-    /**
-     * Provides components for the prompts.
+     * @param answers
+     * The answers provided by the user.
      */
-    namespace prompts {
-        /**
-         * Provides a base for and prompt-options.
-         *
-         * @template T
-         * The type of the answers.
-         */
-        type PromptOptions<T extends Question = Question> = T & {
-            /**
-             * The choices of the prompt.
-             */
-            choices: Choices;
-        };
-
-        /**
-         * Represents the state of a prompt.
-         */
-        type PromptState = LiteralUnion<'pending' | 'idle' | 'loading' | 'answered' | 'done'>;
-
-        /**
-         * Represents a prompt.
-         */
-        interface PromptBase {
-            /**
-             * Gets or sets a string which represents the state of the prompt.
-             */
-            status: PromptState;
-
-            /**
-             * Runs the prompt.
-             *
-             * @returns
-             * The result of the prompt.
-             */
-            run(): Promise<any>;
-        }
-
-        /**
-         * Provides the functionality to initialize new prompts.
-         */
-        interface PromptConstructor {
-            /**
-             * Initializes a new instance of a prompt.
-             *
-             * @param question
-             * The question to prompt.
-             *
-             * @param readLine
-             * An object for reading from the command-line.
-             *
-             * @param answers
-             * The answers provided by the user.
-             */
-            new (question: any, readLine: ReadlineInterface, answers: Answers): PromptBase;
-        }
-
-        /**
-         * Provides a set of prompt-constructors.
-         */
-        type PromptCollection = Record<string, PromptConstructor>;
-
-        /**
-         * Provides data about the state of a prompt.
-         */
-        interface PromptStateData {
-            /**
-             * Either a string which describes the error of the prompt or a boolean indicating whether the prompt-value is valid.
-             */
-            isValid: string | boolean;
-        }
-
-        /**
-         * Provides data about the successful state of a prompt.
-         *
-         * @param T
-         * The type of the answer.
-         */
-        interface SuccessfulPromptStateData<T = any> extends PromptStateData {
-            /**
-             * @inheritdoc
-             */
-            isValid: true;
-
-            /**
-             * The value of the prompt.
-             */
-            value: T;
-        }
-
-        /**
-         * Provides data about the failed state of a prompt.
-         */
-        interface FailedPromptStateData extends PromptStateData {
-            /**
-             * @inheritdoc
-             */
-            isValid: false | string;
-        }
-
-        /**
-         * Provides pipes for handling events of a prompt.
-         *
-         * @param T
-         * The type of the answer.
-         */
-        interface PromptEventPipes<T = any> {
-            /**
-             * A pypeline for succesful inputs.
-             */
-            success: Observable<SuccessfulPromptStateData<T>>;
-
-            /**
-             * An object representing an error.
-             */
-            error: Observable<FailedPromptStateData>;
-        }
-    }
-
-    /**
-     * Provides components for the ui.
-     */
-    namespace ui {
-        /**
-         * Provides options for the bottom-bar UI.
-         */
-        interface BottomBarOptions extends StreamOptions {
-            /**
-             * The initial text to display.
-             */
-            bottomBar?: string | undefined;
-        }
-
-        /**
-         * Represents a fetched answer.
-         *
-         * @template T
-         * The type of the answers.
-         */
-        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>;
-        };
+    new (question: any, readLine: InquirerReadline, answers: Record<string, any>): PromptBase;
+}
+type PromptFn<Value = any, Config = any> = (config: Config, context: StreamOptions & {
+    signal: AbortSignal;
+}) => Promise<Value>;
+/**
+ * Provides a set of prompt-constructors.
+ */
+type PromptCollection = Record<string, PromptFn | LegacyPromptConstructor>;
+type AnswerEvent = {
+    name: string;
+    answer: unknown;
+};
+/**
+ * Base interface class other can inherits from
+ */
+declare class PromptsRunner<A extends Answers> {
+    private prompts;
+    answers: Partial<A>;
+    process: InteropObservable<AnswerEvent>;
+    private abortController;
+    private opt;
+    constructor(prompts: PromptCollection, opt?: StreamOptions);
+    run(questions: PromptSession<A>, answers?: Partial<A>): Promise<A>;
+    private getQuestions;
+    private prepareQuestion;
+    private fetchAnswer;
+    /**
+     * Close the interface and cleanup listeners
+     */
+    close: () => void;
+    private shouldRun;
+}
 
-        /**
-         * Represents a fetched answer.
-         */
-        interface FetchedAnswer {
-            /**
-             * The name of the answer.
-             */
-            name: string;
+/**
+ * Inquirer.js
+ * A collection of common interactive command line user interfaces.
+ */
 
-            /**
-             * The value of the answer.
-             */
-            answer: any;
-        }
-    }
-}
+type PublicQuestions<A extends Answers, Prefilled extends Answers> = QuestionSequence<PromptModulePublicQuestion<MergedAnswers<A, Prefilled>, A>>;
+type InternalQuestions<A extends Answers, Prefilled extends Answers, Prompts extends Record<string, Record<string, unknown>>> = QuestionSequence<PromptModuleNamedQuestion<MergedAnswers<A, Prefilled>, Prompts, A>>;
+type QuestionsDictionary<A extends Answers, Prefilled extends Answers, Prompts extends Record<string, Record<string, unknown>>> = {
+    [name in keyof A]: PromptModuleSpecificQuestion<MergedAnswers<A, Prefilled>, Prompts>;
+};
+type PromptModuleApi<Prompts extends Record<string, Record<string, unknown>> = never> = {
+    <const A extends Answers, const Prefilled extends Answers = object>(questions: PublicQuestions<A, Prefilled> | InternalQuestions<A, Prefilled, Prompts>, answers?: Prefilled): PromptReturnType<MergedAnswers<A, Prefilled>>;
+    <const A extends Answers, const Prefilled extends Answers = object>(questions: QuestionsDictionary<A, Prefilled, Prompts>, answers?: Prefilled): PromptReturnType<DictionaryAnswers<A, Prefilled>>;
+    <A extends Answers>(questions: PromptSession<A>, answers?: Partial<A>): PromptReturnType<A>;
+} & {
+    prompts: PromptCollection;
+    registerPrompt(name: string, prompt: LegacyPromptConstructor | PromptFn): PromptModuleApi<Prompts>;
+    restoreDefaultPrompts(): void;
+};
 
+type PromptReturnType<T extends Answers> = Promise<T> & {
+    ui: PromptsRunner<T>;
+};
 /**
- * Provides the functionality to prompt questions.
+ * Create a new self-contained prompt module.
  */
-declare var inquirer: inquirer.Inquirer;
-export = inquirer;
+declare function createPromptModule<Prompts extends Record<string, Record<string, unknown>> = never>(opt?: StreamOptions): PromptModuleApi<Prompts>;
+declare function registerPrompt(name: string, newPrompt: LegacyPromptConstructor): void;
+declare function restoreDefaultPrompts(): void;
+declare const inquirer: {
+    prompt: PromptModuleApi<Omit<QuestionMap, "__dummy">>;
+    ui: {
+        Prompt: typeof PromptsRunner;
+    };
+    createPromptModule: typeof createPromptModule;
+    registerPrompt: typeof registerPrompt;
+    restoreDefaultPrompts: typeof restoreDefaultPrompts;
+    Separator: typeof Separator;
+};
+
+export { createPromptModule, inquirer as default };
+export type { Answers, DistinctQuestion, PromptSession, Question, QuestionMap };