diff --git a/packages/inquirer/inquirer.test.mts b/packages/inquirer/inquirer.test.mts
index ad26064b9..589c07285 100644
--- a/packages/inquirer/inquirer.test.mts
+++ b/packages/inquirer/inquirer.test.mts
@@ -8,22 +8,29 @@ import os from 'node:os';
 import stream from 'node:stream';
 import tty from 'node:tty';
 import { vi, expect, beforeEach, afterEach, describe, it, expectTypeOf } from 'vitest';
-import { Observable } from 'rxjs';
+import { of } from 'rxjs';
 import type { InquirerReadline } from '@inquirer/type';
 import inquirer, { type QuestionMap } from './src/index.mjs';
-import type { Answers, Question } from './src/types.mjs';
+import type { Answers } from './src/types.mjs';
 import { _ } from './src/ui/prompt.mjs';
 
 declare module './src/index.mjs' {
   interface QuestionMap {
-    stub: { answer?: string | boolean; message: string };
+    stub: { answer?: string | boolean; message: string; default?: string };
     stub2: { answer?: string | boolean; message: string; default: string };
-    stubSelect: { choices: { value: string }[] };
+    stubSelect: { choices: string[] };
     failing: { message: string };
   }
 }
 
-function throwFunc(step: string) {
+type TestQuestions = {
+  stub: { answer?: string | boolean; message: string };
+  stub2: { answer?: string | boolean; message: string; default: string };
+  stubSelect: { choices: string[] };
+  failing: { message: string };
+};
+
+function throwFunc(step: any): any {
   throw new Error(`askAnswered Error ${step}`);
 }
 
@@ -110,27 +117,24 @@ describe('inquirer.prompt(...)', () => {
 
     it('takes an Observable', async () => {
       const answers = await inquirer.prompt(
-        new Observable<Question<{ q1: boolean; q2: boolean }>>((subscriber) => {
-          subscriber.next({
+        of(
+          {
             type: 'stub',
             name: 'q1',
             message: 'message',
             answer: true,
-          });
-          setTimeout(() => {
-            subscriber.next({
-              type: 'stub',
-              name: 'q2',
-              message: 'message',
-              answer: false,
-            });
-            subscriber.complete();
-          }, 30);
-        }),
+          } as const,
+          {
+            type: 'stub',
+            name: 'q2',
+            message: 'message',
+            answer: false,
+          } as const,
+        ),
       );
 
       expect(answers).toEqual({ q1: true, q2: false });
-      expectTypeOf(answers).toEqualTypeOf<{ q1: boolean; q2: boolean }>();
+      expectTypeOf(answers).toEqualTypeOf<{ q1: any; q2: any }>();
     });
   });
 
@@ -273,7 +277,6 @@ describe('inquirer.prompt(...)', () => {
         name: 'name2',
         answer: 'foo',
         message(answers) {
-          // @ts-expect-error TODO fix answer types passed in getters.
           expectTypeOf(answers).toEqualTypeOf<Partial<{ name1: any; name2: any }>>();
           expect(answers).toEqual({ name1: 'bar' });
           const goOn = this.async();
@@ -299,7 +302,7 @@ describe('inquirer.prompt(...)', () => {
         type: 'stub',
         name: 'name',
         message: 'message',
-        default(answers: { name1: string }) {
+        default(answers) {
           expect(answers.name1).toEqual('bar');
           return 'foo';
         },
@@ -337,7 +340,6 @@ describe('inquirer.prompt(...)', () => {
         message: 'message',
         default(answers) {
           goesInDefault = true;
-          // @ts-expect-error TODO fix answer types passed in getters.
           expectTypeOf(answers).toEqualTypeOf<Partial<{ name1: any; q2: any }>>();
           expect(answers).toEqual({ name1: 'bar' });
           const goOn = this.async();
@@ -413,7 +415,6 @@ describe('inquirer.prompt(...)', () => {
         name: 'name',
         message: 'message',
         choices(answers) {
-          // @ts-expect-error TODO fix answer types passed in getters.
           expectTypeOf(answers).toEqualTypeOf<Partial<{ name1: any; name: any }>>();
           expect(answers).toEqual({ name1: 'bar' });
           return stubChoices;
@@ -581,7 +582,6 @@ describe('inquirer.prompt(...)', () => {
           answer: 'answer from running',
           when(answers) {
             expect(answers).toEqual({ q1: 'bar' });
-            // @ts-expect-error TODO fix answer types passed in getters.
             expectTypeOf(answers).toEqualTypeOf<Partial<{ q1: any; q2: any }>>();
 
             goesInWhen = true;
@@ -635,14 +635,13 @@ describe('inquirer.prompt(...)', () => {
 
     it('should not run prompt if answer exists for question', async () => {
       const answers = await inquirer.prompt(
-        // @ts-expect-error Passing wrong type on purpose.
         [
           {
             type: 'input',
             name: 'prefilled',
-            when: throwFunc.bind(undefined, 'when'),
-            validate: throwFunc.bind(undefined, 'validate'),
-            transformer: throwFunc.bind(undefined, 'transformer'),
+            when: throwFunc,
+            validate: throwFunc,
+            transformer: throwFunc,
             message: 'message',
             default: 'newValue',
           },
@@ -655,14 +654,13 @@ describe('inquirer.prompt(...)', () => {
 
     it('should not run prompt if nested answer exists for question', async () => {
       const answers = await inquirer.prompt(
-        // @ts-expect-error Passing wrong type on purpose.
         [
           {
             type: 'input',
             name: 'prefilled.nested',
-            when: throwFunc.bind(undefined, 'when'),
-            validate: throwFunc.bind(undefined, 'validate'),
-            transformer: throwFunc.bind(undefined, 'transformer'),
+            when: throwFunc,
+            validate: throwFunc,
+            transformer: throwFunc,
             message: 'message',
             default: 'newValue',
           },
@@ -773,7 +771,9 @@ describe('Non-TTY checks', () => {
   });
 
   it('Throw an exception when run in non-tty', async () => {
-    const localPrompt = inquirer.createPromptModule({ skipTTYChecks: false });
+    const localPrompt = inquirer.createPromptModule<TestQuestions>({
+      skipTTYChecks: false,
+    });
     localPrompt.registerPrompt('stub', StubPrompt);
 
     const promise = localPrompt([
@@ -787,7 +787,7 @@ describe('Non-TTY checks', () => {
   });
 
   it("Don't throw an exception when run in non-tty by default ", async () => {
-    const localPrompt = inquirer.createPromptModule();
+    const localPrompt = inquirer.createPromptModule<TestQuestions>();
     localPrompt.registerPrompt('stub', StubPrompt);
 
     await localPrompt([
@@ -805,7 +805,9 @@ describe('Non-TTY checks', () => {
   });
 
   it("Don't throw an exception when run in non-tty and skipTTYChecks is true ", async () => {
-    const localPrompt = inquirer.createPromptModule({ skipTTYChecks: true });
+    const localPrompt = inquirer.createPromptModule<TestQuestions>({
+      skipTTYChecks: true,
+    });
     localPrompt.registerPrompt('stub', StubPrompt);
 
     await localPrompt([
@@ -823,7 +825,7 @@ describe('Non-TTY checks', () => {
   });
 
   it("Don't throw an exception when run in non-tty and custom input is provided async ", async () => {
-    const localPrompt = inquirer.createPromptModule({
+    const localPrompt = inquirer.createPromptModule<TestQuestions>({
       input: new stream.Readable({
         // We must have a default read implementation
         // for this to work, if not it will error out
@@ -849,7 +851,7 @@ describe('Non-TTY checks', () => {
   });
 
   it('Throw an exception when run in non-tty and custom input is provided with skipTTYChecks: false', async () => {
-    const localPrompt = inquirer.createPromptModule({
+    const localPrompt = inquirer.createPromptModule<TestQuestions>({
       input: new stream.Readable(),
       skipTTYChecks: false,
     });
@@ -871,7 +873,7 @@ describe('Non-TTY checks', () => {
     const input = new tty.ReadStream(fs.openSync('/dev/tty', 'r+'));
 
     // Uses manually opened tty as input instead of process.stdin
-    const localPrompt = inquirer.createPromptModule({
+    const localPrompt = inquirer.createPromptModule<TestQuestions>({
       input,
       skipTTYChecks: false,
     });
diff --git a/packages/inquirer/src/index.mts b/packages/inquirer/src/index.mts
index 0de17eb7f..6c414dd1a 100644
--- a/packages/inquirer/src/index.mts
+++ b/packages/inquirer/src/index.mts
@@ -16,7 +16,7 @@ import {
   search,
   Separator,
 } from '@inquirer/prompts';
-import type { Prettify, UnionToIntersection } from '@inquirer/type';
+import type { Prettify } from '@inquirer/type';
 import { default as PromptsRunner } from './ui/prompt.mjs';
 import type {
   PromptCollection,
@@ -25,12 +25,12 @@ import type {
 } from './ui/prompt.mjs';
 import type {
   Answers,
-  Question,
-  QuestionAnswerMap,
-  QuestionArray,
-  QuestionObservable,
+  CustomQuestion,
+  BuiltInQuestion,
   StreamOptions,
+  QuestionMap,
 } from './types.mjs';
+import { Observable } from 'rxjs';
 
 export type { QuestionMap } from './types.mjs';
 
@@ -56,42 +56,52 @@ type PromptReturnType<T> = Promise<Prettify<T>> & {
 /**
  * Create a new self-contained prompt module.
  */
-export function createPromptModule(opt?: StreamOptions) {
+export function createPromptModule<
+  Prompts extends Record<string, Record<string, unknown>> = never,
+>(opt?: StreamOptions) {
+  type Question<A extends Answers> = BuiltInQuestion<A> | CustomQuestion<A, Prompts>;
+  type NamedQuestion<A extends Answers> = Question<A> & {
+    name: Extract<keyof A, string>;
+  };
   function promptModule<
-    const AnswerList extends readonly Answers[],
+    const A extends Answers,
     PrefilledAnswers extends Answers = object,
   >(
-    questions: { [I in keyof AnswerList]: Question<PrefilledAnswers & AnswerList[I]> },
+    questions: NamedQuestion<Prettify<PrefilledAnswers & A>>[],
     answers?: PrefilledAnswers,
-  ): PromptReturnType<PrefilledAnswers & UnionToIntersection<AnswerList[number]>>;
+  ): PromptReturnType<Prettify<PrefilledAnswers & A>>;
   function promptModule<
-    const Map extends QuestionAnswerMap<A>,
-    const A extends Answers<Extract<keyof Map, string>>,
+    const A extends Answers,
     PrefilledAnswers extends Answers = object,
-  >(questions: Map, answers?: PrefilledAnswers): PromptReturnType<PrefilledAnswers & A>;
+  >(
+    questions: {
+      [name in keyof A]: Question<Prettify<PrefilledAnswers & A>>;
+    },
+    answers?: PrefilledAnswers,
+  ): PromptReturnType<Prettify<PrefilledAnswers & Answers<Extract<keyof A, string>>>>;
   function promptModule<
     const A extends Answers,
     PrefilledAnswers extends Answers = object,
   >(
-    questions: QuestionObservable<A>,
+    questions: Observable<NamedQuestion<Prettify<PrefilledAnswers & A>>>,
     answers?: PrefilledAnswers,
-  ): PromptReturnType<PrefilledAnswers & A>;
+  ): PromptReturnType<Prettify<PrefilledAnswers & A>>;
   function promptModule<
     const A extends Answers,
     PrefilledAnswers extends Answers = object,
   >(
-    questions: Question<A>,
+    questions: NamedQuestion<A & PrefilledAnswers>,
     answers?: PrefilledAnswers,
   ): PromptReturnType<PrefilledAnswers & A>;
-  function promptModule(
+  function promptModule<A extends Answers>(
     questions:
-      | QuestionArray<Answers>
-      | QuestionAnswerMap<Answers>
-      | QuestionObservable<Answers>
-      | Question<Answers>,
-    answers?: Partial<Answers>,
-  ): PromptReturnType<Answers> {
-    const runner = new PromptsRunner(promptModule.prompts, opt);
+      | NamedQuestion<A>[]
+      | Record<keyof A, Question<A>>
+      | Observable<NamedQuestion<A>>
+      | NamedQuestion<A>,
+    answers?: Partial<A>,
+  ): PromptReturnType<A> {
+    const runner = new PromptsRunner<A>(promptModule.prompts, opt);
 
     const promptPromise = runner.run(questions, answers);
     return Object.assign(promptPromise, { ui: runner });
@@ -123,7 +133,7 @@ export function createPromptModule(opt?: StreamOptions) {
 /**
  * Public CLI helper interface
  */
-const prompt = createPromptModule();
+const prompt = createPromptModule<Omit<QuestionMap, '__dummy'>>();
 
 // Expose helper functions on the top level for easiest usage by common users
 function registerPrompt(name: string, newPrompt: LegacyPromptConstructor) {
diff --git a/packages/inquirer/src/types.mts b/packages/inquirer/src/types.mts
index f531c4973..1a3d49da9 100644
--- a/packages/inquirer/src/types.mts
+++ b/packages/inquirer/src/types.mts
@@ -1,21 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type {
-  input,
-  select,
-  number,
+import {
+  checkbox,
   confirm,
-  rawlist,
+  editor,
   expand,
-  checkbox,
+  input,
+  number,
   password,
-  editor,
+  rawlist,
+  search,
+  select,
 } from '@inquirer/prompts';
-import type { Prettify, KeyUnion, DistributiveMerge, Pick } from '@inquirer/type';
+import type { Context, DistributiveMerge, Prettify } from '@inquirer/type';
 import { Observable } from 'rxjs';
 
-export type Answers<Key extends string = string> = {
-  [key in Key]: any;
-};
+export type Answers<Key extends string = string> = Record<Key, any>;
 
 type AsyncCallbackFunction<R> = (
   ...args: [error: null | undefined, value: R] | [error: Error, value: undefined]
@@ -23,66 +22,80 @@ type AsyncCallbackFunction<R> = (
 
 type AsyncGetterFunction<R, A extends Answers> = (
   this: { async: () => AsyncCallbackFunction<R> },
-  answers: Partial<A>,
+  answers: Prettify<Partial<A>>,
 ) => void | R | Promise<R>;
 
+/**
+ * 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.
+ */
 export interface QuestionMap {
-  input: Parameters<typeof input>[0];
-  select: Parameters<typeof select>[0];
-  /** @deprecated `list` is now named `select` */
-  list: Parameters<typeof select>[0];
-  number: Parameters<typeof number>[0];
-  confirm: Parameters<typeof confirm>[0];
-  rawlist: Parameters<typeof rawlist>[0];
-  expand: Parameters<typeof expand>[0];
-  checkbox: Parameters<typeof checkbox>[0];
-  password: Parameters<typeof password>[0];
-  editor: Parameters<typeof editor>[0];
+  // Dummy key to avoid empty object type
+  __dummy: { message: string };
 }
 
-type PromptConfigMap<A extends Answers> = {
-  [key in keyof QuestionMap]: Readonly<
-    DistributiveMerge<
-      QuestionMap[keyof QuestionMap],
-      {
-        type: keyof QuestionMap;
-        name: KeyUnion<A>;
-        when?: AsyncGetterFunction<boolean, Prettify<A>> | boolean;
-        askAnswered?: boolean;
-        message:
-          | Pick<QuestionMap[keyof QuestionMap], 'message'>
-          | AsyncGetterFunction<
-              Pick<QuestionMap[keyof QuestionMap], 'message'>,
-              Prettify<A>
-            >;
-        choices?:
-          | Pick<QuestionMap[keyof QuestionMap], 'choices'>
-          | string[]
-          | AsyncGetterFunction<
-              Pick<QuestionMap[keyof QuestionMap], 'choices'> | string[],
-              Prettify<A>
-            >;
-        default?:
-          | Pick<QuestionMap[keyof QuestionMap], 'default'>
-          | AsyncGetterFunction<
-              Pick<QuestionMap[keyof QuestionMap], 'default'> | string[],
-              Prettify<A>
-            >;
-      }
-    >
-  >;
+type KeyValueOrAsyncGetterFunction<T, k extends string, A extends Answers> =
+  T extends Record<string, any> ? T[k] | AsyncGetterFunction<T[k], A> : never;
+
+export type AnyQuestion<A extends Answers, Type extends string = string> = {
+  type: Type;
+  name: string;
+  askAnswered?: boolean;
+  when?: boolean | AsyncGetterFunction<boolean, A>;
 };
 
-export type Question<A extends Answers> = PromptConfigMap<A>[keyof PromptConfigMap<A>];
+type QuestionWithGetters<
+  Type extends string,
+  Q extends Record<string, any>,
+  A extends Answers,
+> = DistributiveMerge<
+  Q,
+  {
+    type: Type;
+    askAnswered?: boolean;
+    when?: boolean | AsyncGetterFunction<boolean, A>;
+    filter?(input: any, answers: A): any;
+    message: KeyValueOrAsyncGetterFunction<Q, 'message', A>;
+    default?: KeyValueOrAsyncGetterFunction<Q, 'default', A>;
+    choices?: KeyValueOrAsyncGetterFunction<Q, 'choices', A>;
+  }
+>;
 
-export type QuestionAnswerMap<A extends Answers> = Readonly<{
-  [name in KeyUnion<A>]: Omit<Question<A>, 'name'>;
-}>;
+export type BuiltInQuestion<A extends Answers = object> =
+  | QuestionWithGetters<'checkbox', Parameters<typeof checkbox>[0], A>
+  | QuestionWithGetters<'confirm', Parameters<typeof confirm>[0], A>
+  | QuestionWithGetters<'editor', Parameters<typeof editor>[0], A>
+  | QuestionWithGetters<'expand', Parameters<typeof expand>[0], A>
+  | QuestionWithGetters<'input', Parameters<typeof input>[0], A>
+  | QuestionWithGetters<'number', Parameters<typeof number>[0], A>
+  | QuestionWithGetters<'password', Parameters<typeof password>[0], A>
+  | QuestionWithGetters<'rawlist', Parameters<typeof rawlist>[0], A>
+  | QuestionWithGetters<'search', Parameters<typeof search>[0], A>
+  // Alias list type to select; it's been renamed.
+  | QuestionWithGetters<'list', Parameters<typeof select>[0], A>
+  | QuestionWithGetters<'select', Parameters<typeof select>[0], A>;
 
-export type QuestionArray<A extends Answers> = readonly Question<A>[];
+export 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>];
 
-export type QuestionObservable<A extends Answers> = Observable<Question<A>>;
+export type PromptSession<Q extends AnyQuestion<any>> =
+  | Q[]
+  | Record<string, Omit<Q, 'name'>>
+  | Observable<Q>
+  | Q;
 
-export type StreamOptions = Prettify<
-  Parameters<typeof input>[1] & { skipTTYChecks?: boolean }
->;
+export type StreamOptions = Prettify<Context & { skipTTYChecks?: boolean }>;
diff --git a/packages/inquirer/src/ui/prompt.mts b/packages/inquirer/src/ui/prompt.mts
index 79ad4c297..b0bf282db 100644
--- a/packages/inquirer/src/ui/prompt.mts
+++ b/packages/inquirer/src/ui/prompt.mts
@@ -16,14 +16,7 @@ import runAsync from 'run-async';
 import MuteStream from 'mute-stream';
 import type { InquirerReadline } from '@inquirer/type';
 import ansiEscapes from 'ansi-escapes';
-import type {
-  Answers,
-  Question,
-  QuestionAnswerMap,
-  QuestionArray,
-  QuestionObservable,
-  StreamOptions,
-} from '../types.mjs';
+import type { Answers, AnyQuestion, PromptSession, StreamOptions } from '../types.mjs';
 
 export const _ = {
   set: (obj: Record<string, unknown>, path: string = '', value: unknown): void => {
@@ -64,11 +57,11 @@ export const _ = {
  * Resolve a question property value if it is passed as a function.
  * This method will overwrite the property on the question object with the received value.
  */
-function fetchAsyncQuestionProperty<A extends Answers, Q extends Question<A>>(
+function fetchAsyncQuestionProperty<A extends Answers, Q extends AnyQuestion<A>>(
   question: Q,
   prop: string,
   answers: A,
-) {
+): Observable<AnyQuestion<A>> {
   if (prop in question) {
     const propGetter = question[prop as keyof Q];
     if (typeof propGetter === 'function') {
@@ -130,7 +123,7 @@ class TTYError extends Error {
   isTtyError = true;
 }
 
-function setupReadlineOptions(opt: StreamOptions = {}) {
+function setupReadlineOptions(opt: StreamOptions) {
   // Inquirer 8.x:
   // opt.skipTTYChecks = opt.skipTTYChecks === undefined ? opt.input !== undefined : opt.skipTTYChecks;
   opt.skipTTYChecks = opt.skipTTYChecks === undefined ? true : opt.skipTTYChecks;
@@ -161,22 +154,14 @@ function setupReadlineOptions(opt: StreamOptions = {}) {
 }
 
 function isQuestionArray<A extends Answers>(
-  questions:
-    | QuestionArray<A>
-    | QuestionAnswerMap<A>
-    | QuestionObservable<A>
-    | Question<A>,
-): questions is QuestionArray<A> {
+  questions: PromptSession<AnyQuestion<A>>,
+): questions is AnyQuestion<A>[] {
   return Array.isArray(questions);
 }
 
 function isQuestionMap<A extends Answers>(
-  questions:
-    | QuestionArray<A>
-    | QuestionAnswerMap<A>
-    | QuestionObservable<A>
-    | Question<A>,
-): questions is QuestionAnswerMap<A> {
+  questions: PromptSession<AnyQuestion<A>>,
+): questions is Record<string, Omit<AnyQuestion<A>, 'name'>> {
   return Object.values(questions).every(
     (maybeQuestion) =>
       typeof maybeQuestion === 'object' &&
@@ -204,38 +189,29 @@ export default class PromptsRunner<A extends Answers> {
   answers: Partial<A> = {};
   process: Observable<any> = EMPTY;
   onClose?: () => void;
-  opt?: StreamOptions;
+  opt: StreamOptions;
   rl?: InquirerReadline;
 
-  constructor(prompts: PromptCollection, opt?: StreamOptions) {
+  constructor(prompts: PromptCollection, opt: StreamOptions = {}) {
     this.opt = opt;
     this.prompts = prompts;
   }
 
-  async run(
-    questions:
-      | QuestionArray<A>
-      | QuestionAnswerMap<A>
-      | QuestionObservable<A>
-      | Question<A>,
-    answers?: Partial<A>,
-  ): Promise<A> {
+  async run(questions: PromptSession<AnyQuestion<A>>, answers?: Partial<A>): Promise<A> {
     // Keep global reference to the answers
     this.answers = typeof answers === 'object' ? { ...answers } : {};
 
-    let obs: Observable<Question<A>>;
+    let obs: Observable<AnyQuestion<A>>;
     if (isQuestionArray(questions)) {
       obs = from(questions);
     } else if (isObservable(questions)) {
       obs = questions;
-    } else if (isQuestionMap<A>(questions)) {
+    } else if (isQuestionMap(questions)) {
       // Case: Called with a set of { name: question }
       obs = from(
-        Object.entries(questions).map(
-          ([name, question]: [string, Omit<Question<A>, 'name'>]): Question<A> => {
-            return Object.assign({}, question, { name }) as Question<A>;
-          },
-        ),
+        Object.entries(questions).map(([name, question]): AnyQuestion<A> => {
+          return Object.assign({}, question, { name });
+        }),
       );
     } else {
       // Case: Called with a single question config
@@ -256,7 +232,7 @@ export default class PromptsRunner<A extends Answers> {
       .finally(() => this.close());
   }
 
-  processQuestion(question: Question<A>) {
+  processQuestion(question: AnyQuestion<A>) {
     question = { ...question };
     return defer(() => {
       const obs = of(question);
@@ -274,10 +250,8 @@ export default class PromptsRunner<A extends Answers> {
           fetchAsyncQuestionProperty(question, 'choices', this.answers),
         ),
         concatMap((question) => {
-          const { choices } = question;
-          if (Array.isArray(choices)) {
-            // @ts-expect-error question type is too loose
-            question.choices = choices.map(
+          if ('choices' in question && Array.isArray(question.choices)) {
+            const choices = question.choices.map(
               (choice: string | number | { value?: string; name: string }) => {
                 if (typeof choice === 'string' || typeof choice === 'number') {
                   return { name: choice, value: choice };
@@ -287,6 +261,8 @@ export default class PromptsRunner<A extends Answers> {
                 return choice;
               },
             );
+
+            return of({ ...question, choices });
           }
 
           return of(question);
@@ -296,7 +272,7 @@ export default class PromptsRunner<A extends Answers> {
     });
   }
 
-  fetchAnswer(question: Question<A>) {
+  fetchAnswer(question: AnyQuestion<A>) {
     const prompt = this.prompts[question.type];
 
     if (prompt == null) {
@@ -368,7 +344,7 @@ export default class PromptsRunner<A extends Answers> {
     }
   };
 
-  setDefaultType = (question: Question<A>): Observable<Question<A>> => {
+  setDefaultType = (question: AnyQuestion<A>): Observable<AnyQuestion<A>> => {
     // Default type to input
     if (!this.prompts[question.type]) {
       question = Object.assign({}, question, { type: 'input' });
@@ -377,7 +353,7 @@ export default class PromptsRunner<A extends Answers> {
     return defer(() => of(question));
   };
 
-  filterIfRunnable = (question: Question<A>): Observable<Question<A>> => {
+  filterIfRunnable = (question: AnyQuestion<A>): Observable<AnyQuestion<A>> => {
     if (
       question.askAnswered !== true &&
       _.get(this.answers, question.name) !== undefined
@@ -402,7 +378,7 @@ export default class PromptsRunner<A extends Answers> {
           }
           return;
         }),
-      ).pipe(filter((val): val is Question<A> => val != null)),
+      ).pipe(filter((val) => val != null)),
     );
   };
 }